FreeOpcUa / python-opcua

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

    __repr__ = __str__

class BrowseResult(FrozenClass):

    '''

    The result of a browse operation.

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    :ivar References:

    :vartype References: ReferenceDescription

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

        'ContinuationPoint': 'ByteString',

        'References': 'ReferenceDescription',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.ContinuationPoint = None

        self.References = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StatusCode.to_binary())

        packet.append(uabin.Primitives.ByteString.pack(self.ContinuationPoint))

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

        for fieldname in self.References:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.ContinuationPoint = uabin.Primitives.ByteString.unpack(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(ReferenceDescription.from_binary(data))

        self.References = array

    def __str__(self):

        return 'BrowseResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class NotificationMessage(FrozenClass):

    '''

    :ivar SequenceNumber:

    :vartype SequenceNumber: UInt32

    :ivar PublishTime:

    :vartype PublishTime: DateTime

    :ivar NotificationData:

    :vartype NotificationData: ExtensionObject

    '''

    ua_types = {

        'SequenceNumber': 'UInt32',

        'PublishTime': 'DateTime',

        'NotificationData': 'ExtensionObject',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SequenceNumber = 0

        self.PublishTime = datetime.utcnow()

        self.NotificationData = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.NotificationData:

            packet.append(extensionobject_to_binary(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NotificationMessage(data)

    def _binary_init(self, data):

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(extensionobject_from_binary(data))

        self.NotificationData = array

    def __str__(self):

        return 'NotificationMessage(' + 'SequenceNumber:' + str(self.SequenceNumber) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class ModifyMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar TimestampsToReturn:

    :vartype TimestampsToReturn: TimestampsToReturn

    :ivar ItemsToModify:

    :vartype ItemsToModify: MonitoredItemModifyRequest

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

        'TimestampsToReturn': 'TimestampsToReturn',

        'ItemsToModify': 'MonitoredItemModifyRequest',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.TimestampsToReturn = TimestampsToReturn(0)

        self.ItemsToModify = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.ItemsToModify:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ModifyMonitoredItemsParameters(data)

    def _binary_init(self, data):

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(MonitoredItemModifyRequest.from_binary(data))

        self.ItemsToModify = array

    def __str__(self):

        return 'ModifyMonitoredItemsParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class CreateMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar TimestampsToReturn:

    :vartype TimestampsToReturn: TimestampsToReturn

    :ivar ItemsToCreate:

    :vartype ItemsToCreate: MonitoredItemCreateRequest

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

        'TimestampsToReturn': 'TimestampsToReturn',

        'ItemsToCreate': 'MonitoredItemCreateRequest',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.TimestampsToReturn = TimestampsToReturn(0)

        self.ItemsToCreate = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.ItemsToCreate:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CreateMonitoredItemsParameters(data)

    def _binary_init(self, data):

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(MonitoredItemCreateRequest.from_binary(data))

        self.ItemsToCreate = array

    def __str__(self):

        return 'CreateMonitoredItemsParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class UpdateStructureDataDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar PerformInsertReplace:

    :vartype PerformInsertReplace: PerformUpdateType

    :ivar UpdateValues:

    :vartype UpdateValues: DataValue

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'PerformInsertReplace': 'PerformUpdateType',

        'UpdateValues': 'DataValue',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.PerformInsertReplace = PerformUpdateType(0)

        self.UpdateValues = []

        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(uabin.Primitives.Int32.pack(len(self.UpdateValues)))

        for fieldname in self.UpdateValues:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UpdateStructureDataDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.UpdateValues = array

    def __str__(self):

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

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

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

    __repr__ = __str__

        return 'HistoryUpdateDetails(' + 'NodeId:' + str(self.NodeId) + ')'

    __repr__ = __str__

class UpdateDataDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar PerformInsertReplace:

    :vartype PerformInsertReplace: PerformUpdateType

    :ivar UpdateValues:

    :vartype UpdateValues: DataValue

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'PerformInsertReplace': 'PerformUpdateType',

        'UpdateValues': 'DataValue',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.PerformInsertReplace = PerformUpdateType(0)

        self.UpdateValues = []

        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(uabin.Primitives.Int32.pack(len(self.UpdateValues)))

        for fieldname in self.UpdateValues:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UpdateDataDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.UpdateValues = array

    def __str__(self):

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

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class ReadParameters(FrozenClass):

    '''

    :ivar MaxAge:

    :vartype MaxAge: Double

    :ivar TimestampsToReturn:

    :vartype TimestampsToReturn: TimestampsToReturn

    :ivar NodesToRead:

    :vartype NodesToRead: ReadValueId

    '''

    ua_types = {

        'MaxAge': 'Double',

        'TimestampsToReturn': 'TimestampsToReturn',

        'NodesToRead': 'ReadValueId',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MaxAge = 0

        self.TimestampsToReturn = TimestampsToReturn(0)

        self.NodesToRead = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.NodesToRead:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadParameters(data)

    def _binary_init(self, data):

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(ReadValueId.from_binary(data))

        self.NodesToRead = array

    def __str__(self):

        return 'ReadParameters(' + 'MaxAge:' + str(self.MaxAge) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class NodeTypeDescription(FrozenClass):

    '''

    :ivar TypeDefinitionNode:

    :vartype TypeDefinitionNode: ExpandedNodeId

    :ivar IncludeSubTypes:

    :vartype IncludeSubTypes: Boolean

    :ivar DataToReturn:

    :vartype DataToReturn: QueryDataDescription

    '''

    ua_types = {

        'TypeDefinitionNode': 'ExpandedNodeId',

        'IncludeSubTypes': 'Boolean',

        'DataToReturn': 'QueryDataDescription',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeDefinitionNode = ExpandedNodeId()

        self.IncludeSubTypes = True

        self.DataToReturn = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeDefinitionNode.to_binary())

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

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

        for fieldname in self.DataToReturn:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeTypeDescription(data)

    def _binary_init(self, data):

        self.TypeDefinitionNode = ExpandedNodeId.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(QueryDataDescription.from_binary(data))

        self.DataToReturn = array

    def __str__(self):

        return 'NodeTypeDescription(' + 'TypeDefinitionNode:' + str(self.TypeDefinitionNode) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class BrowseParameters(FrozenClass):

    '''

    :ivar View:

    :vartype View: ViewDescription

    :ivar RequestedMaxReferencesPerNode:

    :vartype RequestedMaxReferencesPerNode: UInt32

    :ivar NodesToBrowse:

    :vartype NodesToBrowse: BrowseDescription

    '''

    ua_types = {

        'View': 'ViewDescription',

        'RequestedMaxReferencesPerNode': 'UInt32',

        'NodesToBrowse': 'BrowseDescription',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.View = ViewDescription()

        self.RequestedMaxReferencesPerNode = 0

        self.NodesToBrowse = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.View.to_binary())

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

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

        for fieldname in self.NodesToBrowse:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseParameters(data)

    def _binary_init(self, data):

        self.View = ViewDescription.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(BrowseDescription.from_binary(data))

        self.NodesToBrowse = array

    def __str__(self):

        return 'BrowseParameters(' + 'View:' + str(self.View) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class NodeReference(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar ReferencedNodeIds:

    :vartype ReferencedNodeIds: NodeId

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'ReferenceTypeId': 'NodeId',

        'IsForward': 'Boolean',

        'ReferencedNodeIds': 'NodeId',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.ReferenceTypeId = NodeId()

        self.IsForward = True

        self.ReferencedNodeIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.ReferenceTypeId.to_binary())

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

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

        for fieldname in self.ReferencedNodeIds:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return NodeReference(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.ReferenceTypeId = NodeId.from_binary(data)

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.ReferencedNodeIds = array

    def __str__(self):

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

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

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class GetEndpointsResponse(FrozenClass):

    '''

    Gets the endpoints used by the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Endpoints:

    :vartype Endpoints: EndpointDescription

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Endpoints': 'EndpointDescription',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Endpoints = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.Endpoints:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return GetEndpointsResponse(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(EndpointDescription.from_binary(data))

        self.Endpoints = array

    def __str__(self):

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

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class FindServersResponse(FrozenClass):

    '''

    Finds the servers known to the discovery server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Servers:

    :vartype Servers: ApplicationDescription

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Servers': 'ApplicationDescription',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.FindServersResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Servers = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        for fieldname in self.Servers:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return FindServersResponse(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(ApplicationDescription.from_binary(data))

        self.Servers = array

    def __str__(self):

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

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class CallMethodRequest(FrozenClass):

    '''

    :ivar ObjectId:

    :vartype ObjectId: NodeId

    :ivar MethodId:

    :vartype MethodId: NodeId

    :ivar InputArguments:

    :vartype InputArguments: Variant

    '''

    ua_types = {

        'ObjectId': 'NodeId',

        'MethodId': 'NodeId',

        'InputArguments': 'Variant',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ObjectId = NodeId()

        self.MethodId = NodeId()

        self.InputArguments = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.ObjectId.to_binary())

        packet.append(self.MethodId.to_binary())

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

        for fieldname in self.InputArguments:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CallMethodRequest(data)

    def _binary_init(self, data):

        self.ObjectId = NodeId.from_binary(data)

        self.MethodId = NodeId.from_binary(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Variant.from_binary(data))

        self.InputArguments = array

    def __str__(self):

        return 'CallMethodRequest(' + 'ObjectId:' + str(self.ObjectId) + ', ' + \

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

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

    __repr__ = __str__

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

    __repr__ = __str__

class QueryDataSet(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: ExpandedNodeId

    :ivar TypeDefinitionNode:

    :vartype TypeDefinitionNode: ExpandedNodeId

    :ivar Values:

    :vartype Values: Variant

    '''

    ua_types = {

        'NodeId': 'ExpandedNodeId',

        'TypeDefinitionNode': 'ExpandedNodeId',

        'Values': 'Variant',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = ExpandedNodeId()

        self.TypeDefinitionNode = ExpandedNodeId()

        self.Values = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.TypeDefinitionNode.to_binary())

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

        for fieldname in self.Values:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryDataSet(data)

    def _binary_init(self, data):

        self.NodeId = ExpandedNodeId.from_binary(data)

        self.TypeDefinitionNode = ExpandedNodeId.from_binary(data)

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Variant.from_binary(data))

        self.Values = array

    def __str__(self):

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

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

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

    __repr__ = __str__