FreeOpcUa / python-opcua

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsResponse(FrozenClass):

    '''

    Translates one or more paths in the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: BrowsePathResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'BrowsePathResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.TranslateBrowsePathsToNodeIdsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 TranslateBrowsePathsToNodeIdsResponse(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(BrowsePathResult.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 'TranslateBrowsePathsToNodeIdsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class RegisterNodesParameters(FrozenClass):

    __repr__ = __str__

class BrowseResponse(FrozenClass):

    '''

    Browse the references for one or more nodes from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: BrowseResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'BrowseResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.BrowseResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 BrowseResponse(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(BrowseResult.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 'BrowseResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class BrowseNextParameters(FrozenClass):

    __repr__ = __str__

class DeleteNodesResponse(FrozenClass):

    '''

    Delete one or more nodes from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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):

    __repr__ = __str__

class AddReferencesResponse(FrozenClass):

    '''

    Adds one or more references to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.AddReferencesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 AddReferencesResponse(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 'AddReferencesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class DeleteNodesItem(FrozenClass):

    __repr__ = __str__

class AddNodesResponse(FrozenClass):

    '''

    Adds one or more nodes to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: AddNodesResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'AddNodesResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.AddNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 AddNodesResponse(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(AddNodesResult.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 'AddNodesResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class AddReferencesItem(FrozenClass):

    __repr__ = __str__

class DeleteSubscriptionsResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteSubscriptionsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 DeleteSubscriptionsResponse(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 'DeleteSubscriptionsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class BuildInfo(FrozenClass):

    __repr__ = __str__

class DeleteMonitoredItemsResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteMonitoredItemsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 DeleteMonitoredItemsResponse(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 'DeleteMonitoredItemsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class CreateSubscriptionParameters(FrozenClass):

    __repr__ = __str__

class ModifyMonitoredItemsResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: MonitoredItemModifyResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'MonitoredItemModifyResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ModifyMonitoredItemsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 ModifyMonitoredItemsResponse(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(MonitoredItemModifyResult.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 'ModifyMonitoredItemsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class SetMonitoringModeParameters(FrozenClass):

    __repr__ = __str__

class CreateMonitoredItemsResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: MonitoredItemCreateResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'MonitoredItemCreateResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CreateMonitoredItemsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 CreateMonitoredItemsResponse(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(MonitoredItemCreateResult.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 'CreateMonitoredItemsResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class MonitoredItemModifyRequest(FrozenClass):

    __repr__ = __str__

class CallResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: CallMethodResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'CallMethodResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CallResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 CallResponse(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(CallMethodResult.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 'CallResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class MonitoringFilter(FrozenClass):

    __repr__ = __str__

class HistoryUpdateResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: HistoryUpdateResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'HistoryUpdateResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.HistoryUpdateResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 HistoryUpdateResponse(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(HistoryUpdateResult.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 'HistoryUpdateResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class CallMethodRequest(FrozenClass):

    __repr__ = __str__

class WriteResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.WriteResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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 WriteResponse(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 'WriteResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class HistoryUpdateDetails(FrozenClass):

    __repr__ = __str__

class HistoryReadResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: HistoryReadResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'HistoryReadResult',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.HistoryReadResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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):

    __repr__ = __str__

class ReadResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: DataValue

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Results': 'DataValue',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ReadResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        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.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):

    __repr__ = __str__

class RegisterServer2Response(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar ConfigurationResults:

    :vartype ConfigurationResults: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = {

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'ConfigurationResults': 'StatusCode',

        'DiagnosticInfos': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RegisterServer2Response_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.ConfigurationResults = []

        self.DiagnosticInfos = []

        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.ConfigurationResults)))

        for fieldname in self.ConfigurationResults:

            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 RegisterServer2Response(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.ConfigurationResults = 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 'RegisterServer2Response(' + 'TypeId:' + str(self.TypeId) + ', ' + \

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

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

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

    __repr__ = __str__

class ChannelSecurityToken(FrozenClass):