FreeOpcUa / python-opcua

    __repr__ = __str__

class UnregisterNodesRequest(FrozenClass):

    '''

    Unregisters one or more previously registered nodes.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: UnregisterNodesParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.UnregisterNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = UnregisterNodesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UnregisterNodesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = UnregisterNodesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class UnregisterNodesResponse(FrozenClass):

    __repr__ = __str__

class RegisterNodesResponse(FrozenClass):

    '''

    Registers one or more nodes for repeated use within a session.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: RegisterNodesResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = RegisterNodesResult()

        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 RegisterNodesResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = RegisterNodesResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class UnregisterNodesParameters(FrozenClass):

    __repr__ = __str__

class RegisterNodesRequest(FrozenClass):

    '''

    Registers one or more nodes for repeated use within a session.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: RegisterNodesParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = RegisterNodesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterNodesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = RegisterNodesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class RegisterNodesResult(FrozenClass):

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsRequest(FrozenClass):

    '''

    Translates one or more paths in the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: TranslateBrowsePathsToNodeIdsParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.TranslateBrowsePathsToNodeIdsRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = TranslateBrowsePathsToNodeIdsParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TranslateBrowsePathsToNodeIdsRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = TranslateBrowsePathsToNodeIdsParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsResponse(FrozenClass):

    __repr__ = __str__

class BrowseNextResponse(FrozenClass):

    '''

    Continues one or more browse operations.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

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

    __repr__ = __str__

class BrowseNextRequest(FrozenClass):

    '''

    Continues one or more browse operations.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: BrowseNextParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.BrowseNextRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = BrowseNextParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseNextRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = BrowseNextParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class BrowseNextResult(FrozenClass):

    __repr__ = __str__

class BrowseRequest(FrozenClass):

    '''

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

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: BrowseParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.BrowseRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = BrowseParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = BrowseParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class BrowseResponse(FrozenClass):

    __repr__ = __str__

class DeleteReferencesResponse(FrozenClass):

    '''

    Delete one or more references from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: DeleteReferencesResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = DeleteReferencesResult()

        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 DeleteReferencesResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = DeleteReferencesResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class ViewDescription(FrozenClass):

    __repr__ = __str__

class DeleteReferencesRequest(FrozenClass):

    '''

    Delete one or more references from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: DeleteReferencesParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = DeleteReferencesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteReferencesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = DeleteReferencesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteReferencesResult(FrozenClass):

    __repr__ = __str__

class DeleteNodesRequest(FrozenClass):

    '''

    Delete one or more nodes from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: DeleteNodesParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = DeleteNodesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = DeleteNodesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteNodesResponse(FrozenClass):

    __repr__ = __str__

class AddNodesRequest(FrozenClass):

    '''

    Adds one or more nodes to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: AddNodesParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.AddNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = AddNodesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddNodesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = AddNodesParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class AddNodesResponse(FrozenClass):

    __repr__ = __str__

class CancelResponse(FrozenClass):

    '''

    Cancels an outstanding request.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: CancelResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CancelResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = CancelResult()

        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 CancelResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = CancelResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class NodeAttributes(FrozenClass):

    __repr__ = __str__

class CancelRequest(FrozenClass):

    '''

    Cancels an outstanding request.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: CancelParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CancelRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = CancelParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CancelRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = CancelParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class CancelResult(FrozenClass):

    __repr__ = __str__

class CloseSessionRequest(FrozenClass):

    '''

    Closes a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar DeleteSubscriptions:

    :vartype DeleteSubscriptions: Boolean

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CloseSessionRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.DeleteSubscriptions = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

        packet.append(uatype_Boolean.pack(self.DeleteSubscriptions))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CloseSessionRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.DeleteSubscriptions = uatype_Boolean.unpack(data.read(1))[0]

    def __str__(self):

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

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

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

    __repr__ = __str__

class CloseSessionResponse(FrozenClass):

    __repr__ = __str__

class ActivateSessionResponse(FrozenClass):

    '''

    Activates a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: ActivateSessionResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ActivateSessionResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = ActivateSessionResult()

        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 ActivateSessionResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = ActivateSessionResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class CloseSessionRequest(FrozenClass):

    __repr__ = __str__

class ActivateSessionRequest(FrozenClass):

    '''

    Activates a session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: ActivateSessionParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ActivateSessionRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = ActivateSessionParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ActivateSessionRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = ActivateSessionParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class ActivateSessionResult(FrozenClass):

    __repr__ = __str__

class CreateSessionResponse(FrozenClass):

    '''

    Creates a new session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: CreateSessionResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CreateSessionResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = CreateSessionResult()

        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 CreateSessionResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = CreateSessionResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class UserIdentityToken(FrozenClass):

    __repr__ = __str__

class CreateSessionRequest(FrozenClass):

    '''

    Creates a new session with the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: CreateSessionParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.CreateSessionRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = CreateSessionParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CreateSessionRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = CreateSessionParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class CreateSessionResult(FrozenClass):

    __repr__ = __str__

class OpenSecureChannelResponse(FrozenClass):

    '''

    Creates a secure channel with a server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: OpenSecureChannelResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.OpenSecureChannelResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = OpenSecureChannelResult()

        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 OpenSecureChannelResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = OpenSecureChannelResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class CloseSecureChannelRequest(FrozenClass):

    __repr__ = __str__

class OpenSecureChannelRequest(FrozenClass):

    '''

    Creates a secure channel with a server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: OpenSecureChannelParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.OpenSecureChannelRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = OpenSecureChannelParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return OpenSecureChannelRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = OpenSecureChannelParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class OpenSecureChannelResult(FrozenClass):

    __repr__ = __str__

class RegisterServerRequest(FrozenClass):

    '''

    Registers a server with the discovery server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Server:

    :vartype Server: RegisteredServer

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RegisterServerRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Server = RegisteredServer()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

        packet.append(self.Server.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterServerRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Server = RegisteredServer.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class RegisterServerResponse(FrozenClass):

    __repr__ = __str__

class GetEndpointsRequest(FrozenClass):

    '''

    Gets the endpoints used by the server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: GetEndpointsParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.GetEndpointsRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = GetEndpointsParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return GetEndpointsRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = GetEndpointsParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class GetEndpointsResponse(FrozenClass):

    __repr__ = __str__

class FindServersRequest(FrozenClass):

    '''

    Finds the servers known to the discovery server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: FindServersParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.FindServersRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = FindServersParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return FindServersRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = FindServersParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class FindServersResponse(FrozenClass):

    __repr__ = __str__

class ModelChangeStructureDataType(FrozenClass):

    '''

    :ivar Affected:

    :vartype Affected: NodeId

    :ivar AffectedType:

    :vartype AffectedType: NodeId

    :ivar Verb:

    :vartype Verb: Byte

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Affected = NodeId()

        self.AffectedType = NodeId()

        self.Verb = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Affected.to_binary())

        packet.append(self.AffectedType.to_binary())

        packet.append(uatype_Byte.pack(self.Verb))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ModelChangeStructureDataType(data)

    def _binary_init(self, data):

        self.Affected = NodeId.from_binary(data)

        self.AffectedType = NodeId.from_binary(data)

        self.Verb = uatype_Byte.unpack(data.read(1))[0]

    def __str__(self):

        return 'ModelChangeStructureDataType(' + 'Affected:' + str(self.Affected) + ', ' + \

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

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

    __repr__ = __str__

class SemanticChangeStructureDataType(FrozenClass):

    __repr__ = __str__

class DeleteSubscriptionsRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: DeleteSubscriptionsParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteSubscriptionsRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = DeleteSubscriptionsParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteSubscriptionsRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = DeleteSubscriptionsParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteSubscriptionsResponse(FrozenClass):

    __repr__ = __str__

class TransferSubscriptionsResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: TransferSubscriptionsResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.TransferSubscriptionsResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = TransferSubscriptionsResult()

        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 TransferSubscriptionsResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = TransferSubscriptionsResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteSubscriptionsParameters(FrozenClass):

    __repr__ = __str__

class TransferSubscriptionsRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: TransferSubscriptionsParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.TransferSubscriptionsRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = TransferSubscriptionsParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferSubscriptionsRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = TransferSubscriptionsParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class TransferSubscriptionsResult(FrozenClass):

    __repr__ = __str__

class RepublishResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar NotificationMessage:

    :vartype NotificationMessage: NotificationMessage

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RepublishResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.NotificationMessage = NotificationMessage()

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(self.NotificationMessage.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RepublishResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.NotificationMessage = NotificationMessage.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class TransferResult(FrozenClass):

    __repr__ = __str__

class RepublishRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: RepublishParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.RepublishRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = RepublishParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RepublishRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = RepublishParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class RepublishResponse(FrozenClass):

    __repr__ = __str__

class PublishResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: PublishResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.PublishResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = PublishResult()

        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 PublishResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = PublishResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class RepublishParameters(FrozenClass):

    __repr__ = __str__

class PublishRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: PublishParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.PublishRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = PublishParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.RequestHeader.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return PublishRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = PublishParameters.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class PublishResult(FrozenClass):

    __repr__ = __str__

class SetPublishingModeResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: SetPublishingModeResult

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.SetPublishingModeResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = SetPublishingModeResult()

        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 SetPublishingModeResponse(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = SetPublishingModeResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class NotificationMessage(FrozenClass):

    __repr__ = __str__

class SetPublishingModeRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: SetPublishingModeParameters

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True