FreeOpcUa / python-opcua

        'Parameters': 'BrowseNextResult',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.BrowseNextResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = BrowseNextResult()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseNextResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = BrowseNextResult.from_binary(data)

    def __str__(self):

        return 'BrowseNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

class RelativePathElement(FrozenClass):

    '''

    An element in a relative path.

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsInverse:

    :vartype IsInverse: Boolean

    :ivar IncludeSubtypes:

    :vartype IncludeSubtypes: Boolean

    :ivar TargetName:

    :vartype TargetName: QualifiedName

    '''

    ua_types = {

        'ReferenceTypeId': 'NodeId',

        'IsInverse': 'Boolean',

        'IncludeSubtypes': 'Boolean',

        'TargetName': 'QualifiedName',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

    '''

    ua_types = {

        'Low': 'Double',

        'High': 'Double',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Low = 0

        self.High = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Double.pack(self.Low))

        packet.append(uabin.Primitives.Double.pack(self.High))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return Range(data)

    def _binary_init(self, data):

        self.Low = uabin.Primitives.Double.unpack(data)

        self.High = uabin.Primitives.Double.unpack(data)

    def __str__(self):

        return 'Range(' + 'Low:' + str(self.Low) + ', ' + \

               'High:' + str(self.High) + ')'

    __repr__ = __str__

class EUInformation(FrozenClass):

    '''

    :ivar NamespaceUri:

    :vartype NamespaceUri: String

    :ivar UnitId:

    :vartype UnitId: Int32

    :ivar DisplayName:

    :vartype DisplayName: LocalizedText

    :ivar Description:

    :vartype Description: LocalizedText

    '''

    ua_types = {

        'NamespaceUri': 'String',

        'UnitId': 'Int32',

        'DisplayName': 'LocalizedText',

        'Description': 'LocalizedText',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

    '''

    ua_types = {

        'MonitoredItemId': 'UInt32',

        'RequestedParameters': 'MonitoringParameters',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MonitoredItemId = 0

        self.RequestedParameters = MonitoringParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.UInt32.pack(self.MonitoredItemId))

        packet.append(self.RequestedParameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemModifyRequest(data)

    def _binary_init(self, data):

        self.MonitoredItemId = uabin.Primitives.UInt32.unpack(data)

        self.RequestedParameters = MonitoringParameters.from_binary(data)

    def __str__(self):

        return 'MonitoredItemModifyRequest(' + 'MonitoredItemId:' + str(self.MonitoredItemId) + ', ' + \

               'RequestedParameters:' + str(self.RequestedParameters) + ')'

    __repr__ = __str__

class MonitoredItemModifyResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar RevisedSamplingInterval:

    :vartype RevisedSamplingInterval: Double

    :ivar RevisedQueueSize:

    :vartype RevisedQueueSize: UInt32

    :ivar FilterResult:

    :vartype FilterResult: ExtensionObject

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

        'RevisedSamplingInterval': 'Double',

        'RevisedQueueSize': 'UInt32',

        'FilterResult': 'ExtensionObject',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        packet.append(uabin.Primitives.Int32.pack(len(self.Results)))

        for fieldname in self.Results:

            packet.append(fieldname.to_binary())

        packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))

        for fieldname in self.DiagnosticInfos:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(HistoryReadResult.from_binary(data))

        self.Results = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        self.DiagnosticInfos = array

    def __str__(self):

        return 'HistoryReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Results:' + str(self.Results) + ', ' + \

               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__

class WriteValue(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    :ivar Value:

    :vartype Value: DataValue

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'AttributeId': 'UInt32',

        'IndexRange': 'String',

        'Value': 'DataValue',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        packet.append(uabin.Primitives.Int32.pack(len(self.Results)))

        for fieldname in self.Results:

            packet.append(fieldname.to_binary())

        packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))

        for fieldname in self.DiagnosticInfos:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.Results = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        self.DiagnosticInfos = array

    def __str__(self):

        return 'ReadResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Results:' + str(self.Results) + ', ' + \

               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__

class HistoryReadValueId(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar IndexRange:

    :vartype IndexRange: String

    :ivar DataEncoding:

    :vartype DataEncoding: QualifiedName

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'IndexRange': 'String',

        'DataEncoding': 'QualifiedName',

        'ContinuationPoint': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        'Parameters': 'QueryNextResult',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.QueryNextResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = QueryNextResult()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryNextResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = QueryNextResult.from_binary(data)

    def __str__(self):

        return 'QueryNextResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

class ReadValueId(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    :ivar DataEncoding:

    :vartype DataEncoding: QualifiedName

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'AttributeId': 'UInt32',

        'IndexRange': 'String',

        'DataEncoding': 'QualifiedName',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        packet.append(uabin.Primitives.Int32.pack(len(self.Results)))

        for fieldname in self.Results:

            packet.append(fieldname.to_binary())

        packet.append(uabin.Primitives.Int32.pack(len(self.DiagnosticInfos)))

        for fieldname in self.DiagnosticInfos:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(StatusCode.from_binary(data))

        self.Results = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        self.DiagnosticInfos = array

    def __str__(self):

        return 'DeleteNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Results:' + str(self.Results) + ', ' + \

               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__

class DeleteReferencesItem(FrozenClass):

    '''

    A request to delete a node from the server address space.

    :ivar SourceNodeId:

    :vartype SourceNodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar TargetNodeId:

    :vartype TargetNodeId: ExpandedNodeId

    :ivar DeleteBidirectional:

    :vartype DeleteBidirectional: Boolean

    '''

    ua_types = {

        'SourceNodeId': 'NodeId',

        'ReferenceTypeId': 'NodeId',

        'IsForward': 'Boolean',

        'TargetNodeId': 'ExpandedNodeId',

        'DeleteBidirectional': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SourceNodeId = NodeId()

        self.ReferenceTypeId = NodeId()

        self.IsForward = True

        self.TargetNodeId = ExpandedNodeId()

        self.BuildNumber = None

        self.BuildDate = datetime.utcnow()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.String.pack(self.ProductUri))

        packet.append(uabin.Primitives.String.pack(self.ManufacturerName))

        packet.append(uabin.Primitives.String.pack(self.ProductName))

        packet.append(uabin.Primitives.String.pack(self.SoftwareVersion))

        packet.append(uabin.Primitives.String.pack(self.BuildNumber))

        packet.append(uabin.Primitives.DateTime.pack(self.BuildDate))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BuildInfo(data)

    def _binary_init(self, data):

        self.ProductUri = uabin.Primitives.String.unpack(data)

        self.ManufacturerName = uabin.Primitives.String.unpack(data)

        self.ProductName = uabin.Primitives.String.unpack(data)

        self.SoftwareVersion = uabin.Primitives.String.unpack(data)

        self.BuildNumber = uabin.Primitives.String.unpack(data)

        self.BuildDate = uabin.Primitives.DateTime.unpack(data)

    def __str__(self):

        return 'BuildInfo(' + 'ProductUri:' + str(self.ProductUri) + ', ' + \

               'ManufacturerName:' + str(self.ManufacturerName) + ', ' + \

               'ProductName:' + str(self.ProductName) + ', ' + \

               'SoftwareVersion:' + str(self.SoftwareVersion) + ', ' + \

               'BuildNumber:' + str(self.BuildNumber) + ', ' + \

               'BuildDate:' + str(self.BuildDate) + ')'

    __repr__ = __str__

class RedundantServerDataType(FrozenClass):

    '''

    :ivar ServerId:

    :vartype ServerId: String

    :ivar ServiceLevel:

    :vartype ServiceLevel: Byte

    :ivar ServerState:

    :vartype ServerState: ServerState

    '''

    ua_types = {

        'ServerId': 'String',

        'ServiceLevel': 'Byte',

        'ServerState': 'ServerState',

               }

    def __init__(self, binary=None):

        self.UseServerCapabilitiesDefaults = True

        self.TreatUncertainAsBad = True

        self.PercentDataBad = 0

        self.PercentDataGood = 0

        self.UseSlopedExtrapolation = True

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Boolean.pack(self.UseServerCapabilitiesDefaults))

        packet.append(uabin.Primitives.Boolean.pack(self.TreatUncertainAsBad))

        packet.append(uabin.Primitives.Byte.pack(self.PercentDataBad))

        packet.append(uabin.Primitives.Byte.pack(self.PercentDataGood))

        packet.append(uabin.Primitives.Boolean.pack(self.UseSlopedExtrapolation))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AggregateConfiguration(data)

    def _binary_init(self, data):

        self.UseServerCapabilitiesDefaults = uabin.Primitives.Boolean.unpack(data)

        self.TreatUncertainAsBad = uabin.Primitives.Boolean.unpack(data)

        self.PercentDataBad = uabin.Primitives.Byte.unpack(data)

        self.PercentDataGood = uabin.Primitives.Byte.unpack(data)

        self.UseSlopedExtrapolation = uabin.Primitives.Boolean.unpack(data)

    def __str__(self):

        return 'AggregateConfiguration(' + 'UseServerCapabilitiesDefaults:' + str(self.UseServerCapabilitiesDefaults) + ', ' + \

               'TreatUncertainAsBad:' + str(self.TreatUncertainAsBad) + ', ' + \

               'PercentDataBad:' + str(self.PercentDataBad) + ', ' + \

               'PercentDataGood:' + str(self.PercentDataGood) + ', ' + \

               'UseSlopedExtrapolation:' + str(self.UseSlopedExtrapolation) + ')'

    __repr__ = __str__

class AggregateFilter(FrozenClass):

    '''

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar AggregateType:

    :vartype AggregateType: NodeId

    :ivar ProcessingInterval:

    :vartype ProcessingInterval: Double

    :ivar AggregateConfiguration:

    :vartype AggregateConfiguration: AggregateConfiguration

    '''

    ua_types = {

        'StartTime': 'DateTime',

        'AggregateType': 'NodeId',

        'ProcessingInterval': 'Double',

        'AggregateConfiguration': 'AggregateConfiguration',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.EventData = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.NodeId.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.PerformInsertReplace.value))

        packet.append(self.Filter.to_binary())

        packet.append(uabin.Primitives.Int32.pack(len(self.EventData)))

        for fieldname in self.EventData:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UpdateEventDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.PerformInsertReplace = PerformUpdateType(uabin.Primitives.UInt32.unpack(data))

        self.Filter = EventFilter.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(HistoryEventFieldList.from_binary(data))

        self.EventData = array

    def __str__(self):

        return 'UpdateEventDetails(' + 'NodeId:' + str(self.NodeId) + ', ' + \

               'PerformInsertReplace:' + str(self.PerformInsertReplace) + ', ' + \

               'Filter:' + str(self.Filter) + ', ' + \

               'EventData:' + str(self.EventData) + ')'

    __repr__ = __str__

class DeleteRawModifiedDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar IsDeleteModified:

    :vartype IsDeleteModified: Boolean

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'IsDeleteModified': 'Boolean',

        'StartTime': 'DateTime',

        'EndTime': 'DateTime',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

               'ContinuationPoint:' + str(self.ContinuationPoint) + ', ' + \

               'HistoryData:' + str(self.HistoryData) + ')'

    __repr__ = __str__

class HistoryReadDetails(FrozenClass):

    '''

    '''

    ua_types = {

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self._freeze = True

    def to_binary(self):

        packet = []

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadDetails(data)

    def _binary_init(self, data):

        pass

    def __str__(self):

        return 'HistoryReadDetails(' +  + ')'

    __repr__ = __str__

class ReadEventDetails(FrozenClass):

    '''

    :ivar NumValuesPerNode:

    :vartype NumValuesPerNode: UInt32

    :ivar StartTime:

    :vartype StartTime: DateTime

    :ivar EndTime:

    :vartype EndTime: DateTime

    :ivar Filter:

    :vartype Filter: EventFilter

    '''

    ua_types = {

        'NumValuesPerNode': 'UInt32',

        'StartTime': 'DateTime',

        'EndTime': 'DateTime',

        'Filter': 'EventFilter',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

    def _binary_init(self, data):

        self.CreateSessionId = NodeId.from_binary(data)

        self.CreateClientName = uabin.Primitives.String.unpack(data)

        self.InvocationCreationTime = uabin.Primitives.DateTime.unpack(data)

        self.LastTransitionTime = uabin.Primitives.DateTime.unpack(data)

        self.LastMethodCall = uabin.Primitives.String.unpack(data)

        self.LastMethodSessionId = NodeId.from_binary(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Argument.from_binary(data))

        self.LastMethodInputArguments = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Argument.from_binary(data))

        self.LastMethodOutputArguments = array

        self.LastMethodCallTime = uabin.Primitives.DateTime.unpack(data)

        self.LastMethodReturnStatus = StatusResult.from_binary(data)

    def __str__(self):

        return 'ProgramDiagnosticDataType(' + 'CreateSessionId:' + str(self.CreateSessionId) + ', ' + \

               'CreateClientName:' + str(self.CreateClientName) + ', ' + \

               'InvocationCreationTime:' + str(self.InvocationCreationTime) + ', ' + \

               'LastTransitionTime:' + str(self.LastTransitionTime) + ', ' + \

               'LastMethodCall:' + str(self.LastMethodCall) + ', ' + \

               'LastMethodSessionId:' + str(self.LastMethodSessionId) + ', ' + \

               'LastMethodInputArguments:' + str(self.LastMethodInputArguments) + ', ' + \

               'LastMethodOutputArguments:' + str(self.LastMethodOutputArguments) + ', ' + \

               'LastMethodCallTime:' + str(self.LastMethodCallTime) + ', ' + \

               'LastMethodReturnStatus:' + str(self.LastMethodReturnStatus) + ')'

    __repr__ = __str__

class Annotation(FrozenClass):

    '''

    :ivar Message:

    :vartype Message: String

    :ivar UserName:

    :vartype UserName: String

    :ivar AnnotationTime:

    :vartype AnnotationTime: DateTime

    '''

    ua_types = {

        'Message': 'String',

        'UserName': 'String',

        'AnnotationTime': 'DateTime',

               }

    def __init__(self, binary=None):

    ua_types = {

        'DataValues': 'DataValue',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.DataValues = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Int32.pack(len(self.DataValues)))

        for fieldname in self.DataValues:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryData(data)

    def _binary_init(self, data):

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.DataValues = array

    def __str__(self):

        return 'HistoryData(' + 'DataValues:' + str(self.DataValues) + ')'

    __repr__ = __str__

class ModificationInfo(FrozenClass):

    '''

    :ivar ModificationTime:

    :vartype ModificationTime: DateTime

    :ivar UpdateType:

    :vartype UpdateType: HistoryUpdateType

    :ivar UserName:

    :vartype UserName: String

    '''

    ua_types = {

        'ModificationTime': 'DateTime',

        'UpdateType': 'HistoryUpdateType',

        'UserName': 'String',

               }

    def __init__(self, binary=None):