FreeOpcUa / python-opcua

    __repr__ = __str__

class MdnsDiscoveryConfiguration(FrozenClass):

    '''

    The discovery information needed for mDNS registration.

    :ivar MdnsServerName:

    :vartype MdnsServerName: String

    :ivar ServerCapabilities:

    :vartype ServerCapabilities: String

    '''

    ua_types = {

        'MdnsServerName': 'String',

        'ServerCapabilities': 'String',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MdnsServerName = None

        self.ServerCapabilities = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.ServerCapabilities:

            packet.append(uabin.Primitives.String.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MdnsDiscoveryConfiguration(data)

    def _binary_init(self, data):

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

        self.ServerCapabilities = uabin.Primitives.String.unpack_array(data)

    def __str__(self):

        return 'MdnsDiscoveryConfiguration(' + 'MdnsServerName:' + str(self.MdnsServerName) + ', ' + \

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

    __repr__ = __str__

class RegisterServer2Parameters(FrozenClass):

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

        'AvailableSequenceNumbers': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.AvailableSequenceNumbers = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.AvailableSequenceNumbers:

            packet.append(uabin.Primitives.UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        self.AvailableSequenceNumbers = uabin.Primitives.UInt32.unpack_array(data)

    def __str__(self):

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

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

    __repr__ = __str__

class TransferSubscriptionsParameters(FrozenClass):

    '''

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    :ivar SendInitialValues:

    :vartype SendInitialValues: Boolean

    '''

    ua_types = {

        'SubscriptionIds': 'UInt32',

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Parameters': 'ModifySubscriptionResult',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ModifySubscriptionResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = ModifySubscriptionResult()

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

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = ModifySubscriptionResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class SetPublishingModeParameters(FrozenClass):

    '''

    :ivar PublishingEnabled:

    :vartype PublishingEnabled: Boolean

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    '''

    ua_types = {

        'PublishingEnabled': 'Boolean',

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Parameters': 'SetTriggeringResult',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.SetTriggeringResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = SetTriggeringResult()

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

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = SetTriggeringResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar MonitoredItemIds:

    :vartype MonitoredItemIds: UInt32

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'ReqTimes': 'DateTime',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.ReqTimes = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.ReqTimes:

            packet.append(uabin.Primitives.DateTime.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteAtTimeDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.ReqTimes = uabin.Primitives.DateTime.unpack_array(data)

    def __str__(self):

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

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

    __repr__ = __str__

class DeleteEventDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar EventIds:

    :vartype EventIds: ByteString

    '''

    ua_types = {

        'NodeId': 'NodeId',

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

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

        for fieldname in self.AggregateType:

            packet.append(fieldname.to_binary())

        packet.append(self.AggregateConfiguration.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadProcessedDetails(data)

    def _binary_init(self, data):

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

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.AggregateType = array

        self.AggregateConfiguration = AggregateConfiguration.from_binary(data)

    def __str__(self):

        return 'ReadProcessedDetails(' + 'StartTime:' + str(self.StartTime) + ', ' + \

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

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

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

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

    __repr__ = __str__

class ReadAtTimeDetails(FrozenClass):

    '''

    :ivar ReqTimes:

    :vartype ReqTimes: DateTime

    :ivar UseSimpleBounds:

    :vartype UseSimpleBounds: Boolean

    '''

    ua_types = {

        'ReqTimes': 'DateTime',

    :ivar RelativePath:

    :vartype RelativePath: RelativePath

    '''

    ua_types = {

        'StartingNode': 'NodeId',

        'RelativePath': 'RelativePath',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StartingNode = NodeId()

        self.RelativePath = RelativePath()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StartingNode.to_binary())

        packet.append(self.RelativePath.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowsePath(data)

    def _binary_init(self, data):

        self.StartingNode = NodeId.from_binary(data)

        self.RelativePath = RelativePath.from_binary(data)

    def __str__(self):

        return 'BrowsePath(' + 'StartingNode:' + str(self.StartingNode) + ', ' + \

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

    __repr__ = __str__

class BrowsePathTarget(FrozenClass):

    '''

    The target of the translated path.

    :ivar TargetId:

    :vartype TargetId: ExpandedNodeId

    :ivar RemainingPathIndex:

    :vartype RemainingPathIndex: UInt32

    '''

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

    '''

    :ivar ReleaseContinuationPoints:

    :vartype ReleaseContinuationPoints: Boolean

    :ivar ContinuationPoints:

    :vartype ContinuationPoints: ByteString

    '''

    ua_types = {

        'ReleaseContinuationPoints': 'Boolean',

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

    '''

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

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar DeleteTargetReferences:

    :vartype DeleteTargetReferences: Boolean

    '''

    __repr__ = __str__

class X509IdentityToken(FrozenClass):

    '''

    A token representing a user identified by an X509 certificate.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar CertificateData:

    :vartype CertificateData: ByteString

    '''

    ua_types = {

        'PolicyId': 'String',

        'CertificateData': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PolicyId = None

        self.CertificateData = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return X509IdentityToken(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'X509IdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \

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

    __repr__ = __str__

class KerberosIdentityToken(FrozenClass):

    __repr__ = __str__

class SignatureData(FrozenClass):

    '''

    A digital signature.

    :ivar Algorithm:

    :vartype Algorithm: String

    :ivar Signature:

    :vartype Signature: ByteString

    '''

    ua_types = {

        'Algorithm': 'String',

        'Signature': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Algorithm = None

        self.Signature = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SignatureData(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'SignatureData(' + 'Algorithm:' + str(self.Algorithm) + ', ' + \

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

    __repr__ = __str__

class CreateSessionParameters(FrozenClass):

    __repr__ = __str__

class SignedSoftwareCertificate(FrozenClass):

    '''

    A software certificate with a digital signature.

    :ivar CertificateData:

    :vartype CertificateData: ByteString

    :ivar Signature:

    :vartype Signature: ByteString

    '''

    ua_types = {

        'CertificateData': 'ByteString',

        'Signature': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.CertificateData = None

        self.Signature = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SignedSoftwareCertificate(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'SignedSoftwareCertificate(' + 'CertificateData:' + str(self.CertificateData) + ', ' + \

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

    __repr__ = __str__

class SignatureData(FrozenClass):

    __repr__ = __str__

class OptionSet(FrozenClass):

    '''

    This abstract Structured DataType is the base DataType for all DataTypes representing a bit mask.

    :ivar Value:

    :vartype Value: ByteString

    :ivar ValidBits:

    :vartype ValidBits: ByteString

    '''

    ua_types = {

        'Value': 'ByteString',

        'ValidBits': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Value = None

        self.ValidBits = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return OptionSet(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'OptionSet(' + 'Value:' + str(self.Value) + ', ' + \

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

    __repr__ = __str__

class Union(FrozenClass):

        self.EngineeringUnits = EUInformation()

        self.EURange = Range()

        self.Title = LocalizedText()

        self.AxisScaleType = AxisScaleEnumeration(0)

        self.AxisSteps = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.EngineeringUnits.to_binary())

        packet.append(self.EURange.to_binary())

        packet.append(self.Title.to_binary())

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

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

        for fieldname in self.AxisSteps:

            packet.append(uabin.Primitives.Double.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AxisInformation(data)

    def _binary_init(self, data):

        self.EngineeringUnits = EUInformation.from_binary(data)

        self.EURange = Range.from_binary(data)

        self.Title = LocalizedText.from_binary(data)

        self.AxisScaleType = AxisScaleEnumeration(uabin.Primitives.UInt32.unpack(data))

        self.AxisSteps = uabin.Primitives.Double.unpack_array(data)

    def __str__(self):

        return 'AxisInformation(' + 'EngineeringUnits:' + str(self.EngineeringUnits) + ', ' + \

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

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

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

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

    __repr__ = __str__

class XVType(FrozenClass):

    '''

    :ivar X:

    :vartype X: Double

    :ivar Value:

    :vartype Value: Float

    '''

    :ivar Imaginary:

    :vartype Imaginary: Float

    '''

    ua_types = {

        'Real': 'Float',

        'Imaginary': 'Float',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Real = 0

        self.Imaginary = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Float.pack(self.Real))

        packet.append(uabin.Primitives.Float.pack(self.Imaginary))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ComplexNumberType(data)

    def _binary_init(self, data):

        self.Real = uabin.Primitives.Float.unpack(data)

        self.Imaginary = uabin.Primitives.Float.unpack(data)

    def __str__(self):

        return 'ComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \

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

    __repr__ = __str__

class DoubleComplexNumberType(FrozenClass):

    '''

    :ivar Real:

    :vartype Real: Double

    :ivar Imaginary:

    :vartype Imaginary: Double

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NamespaceUri = None

        self.UnitId = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(uabin.Primitives.Int32.pack(self.UnitId))

        packet.append(self.DisplayName.to_binary())

        packet.append(self.Description.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EUInformation(data)

    def _binary_init(self, data):

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

        self.UnitId = uabin.Primitives.Int32.unpack(data)

        self.DisplayName = LocalizedText.from_binary(data)

        self.Description = LocalizedText.from_binary(data)

    def __str__(self):

        return 'EUInformation(' + 'NamespaceUri:' + str(self.NamespaceUri) + ', ' + \

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

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

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

    __repr__ = __str__

class ComplexNumberType(FrozenClass):

    '''

    :ivar Real:

    :vartype Real: Float

    :ivar Imaginary:

    :vartype Imaginary: Float

    '''

    :ivar AffectedType:

    :vartype AffectedType: NodeId

    '''

    ua_types = {

        'Affected': 'NodeId',

        'AffectedType': 'NodeId',

               }

    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._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SemanticChangeStructureDataType(data)

    def _binary_init(self, data):

        self.Affected = NodeId.from_binary(data)

        self.AffectedType = NodeId.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

class Range(FrozenClass):

    '''

    :ivar Low:

    :vartype Low: Double

    :ivar High:

    :vartype High: Double

    '''

        for fieldname in self.ClientUserIdHistory:

            packet.append(uabin.Primitives.String.pack(fieldname))

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

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

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

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

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SessionSecurityDiagnosticsDataType(data)

    def _binary_init(self, data):

        self.SessionId = NodeId.from_binary(data)

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

        self.ClientUserIdHistory = uabin.Primitives.String.unpack_array(data)

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

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

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

        self.SecurityMode = MessageSecurityMode(uabin.Primitives.UInt32.unpack(data))

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

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

    def __str__(self):

        return 'SessionSecurityDiagnosticsDataType(' + 'SessionId:' + str(self.SessionId) + ', ' + \

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

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

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

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

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

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

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

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

    __repr__ = __str__

class ServiceCounterDataType(FrozenClass):

    '''

    :ivar TotalCount:

    :vartype TotalCount: UInt32

    :ivar ErrorCount:

    :vartype ErrorCount: UInt32

    '''

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

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

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar RetransmitSequenceNumber:

    :vartype RetransmitSequenceNumber: UInt32

    '''

    :ivar DiagnosticInfo:

    :vartype DiagnosticInfo: DiagnosticInfo

    '''

    ua_types = {

        'Status': 'StatusCode',

        'DiagnosticInfo': 'DiagnosticInfo',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Status = StatusCode()

        self.DiagnosticInfo = DiagnosticInfo()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Status.to_binary())

        packet.append(self.DiagnosticInfo.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return StatusChangeNotification(data)

    def _binary_init(self, data):

        self.Status = StatusCode.from_binary(data)

        self.DiagnosticInfo = DiagnosticInfo.from_binary(data)

    def __str__(self):

        return 'StatusChangeNotification(' + 'Status:' + str(self.Status) + ', ' + \

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

    __repr__ = __str__

class SubscriptionAcknowledgement(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar SequenceNumber:

    :vartype SequenceNumber: UInt32

    '''

        self.MonitoredItems = []

        self.DiagnosticInfos = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.MonitoredItems:

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

    def _binary_init(self, data):

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(MonitoredItemNotification.from_binary(data))

        self.MonitoredItems = 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 'DataChangeNotification(' + 'MonitoredItems:' + str(self.MonitoredItems) + ', ' + \

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

    __repr__ = __str__

class MonitoredItemNotification(FrozenClass):

    '''

    :ivar ClientHandle:

    :vartype ClientHandle: UInt32

    :ivar Value:

    :vartype Value: DataValue

    '''

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

    '''

    :ivar MonitoredItemId:

    :vartype MonitoredItemId: UInt32

    :ivar RequestedParameters:

    :vartype RequestedParameters: MonitoringParameters

    '''

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

        'Parameters': 'QueryFirstResult',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.QueryFirstResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = QueryFirstResult()

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

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.ResponseHeader = ResponseHeader.from_binary(data)

        self.Parameters = QueryFirstResult.from_binary(data)

    def __str__(self):

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

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

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

    __repr__ = __str__

class QueryNextParameters(FrozenClass):

    '''

    :ivar ReleaseContinuationPoint:

    :vartype ReleaseContinuationPoint: Boolean

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    '''

    __repr__ = __str__

class KerberosIdentityToken(FrozenClass):

    '''

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar TicketData:

    :vartype TicketData: ByteString

    '''

    ua_types = {

        'PolicyId': 'String',

        'TicketData': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PolicyId = None

        self.TicketData = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return KerberosIdentityToken(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'KerberosIdentityToken(' + 'PolicyId:' + str(self.PolicyId) + ', ' + \

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

    __repr__ = __str__

class IssuedIdentityToken(FrozenClass):

    __repr__ = __str__

class TimeZoneDataType(FrozenClass):

    '''

    :ivar Offset:

    :vartype Offset: Int16

    :ivar DaylightSavingInOffset:

    :vartype DaylightSavingInOffset: Boolean

    '''

    ua_types = {

        'Offset': 'Int16',

        'DaylightSavingInOffset': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Offset = 0

        self.DaylightSavingInOffset = True

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Int16.pack(self.Offset))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TimeZoneDataType(data)

    def _binary_init(self, data):

        self.Offset = uabin.Primitives.Int16.unpack(data)

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

    def __str__(self):

        return 'TimeZoneDataType(' + 'Offset:' + str(self.Offset) + ', ' + \

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

    __repr__ = __str__

class ApplicationDescription(FrozenClass):

    __repr__ = __str__

class EnumValueType(FrozenClass):

    '''

    A mapping between a value of an enumerated type and a name and description.

    :ivar Value:

    :vartype Value: Int64

    :ivar DisplayName:

    :vartype DisplayName: LocalizedText

    :ivar Description:

    :vartype Description: LocalizedText

    '''

    ua_types = {

        'Value': 'Int64',

        'DisplayName': 'LocalizedText',

        'Description': 'LocalizedText',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Value = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.Int64.pack(self.Value))

        packet.append(self.DisplayName.to_binary())

        packet.append(self.Description.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EnumValueType(data)

    def _binary_init(self, data):

        self.Value = uabin.Primitives.Int64.unpack(data)

        self.DisplayName = LocalizedText.from_binary(data)

        self.Description = LocalizedText.from_binary(data)

    def __str__(self):

        return 'EnumValueType(' + 'Value:' + str(self.Value) + ', ' + \

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

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

    __repr__ = __str__

class OptionSet(FrozenClass):

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

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

    def __str__(self):

        return 'SubscriptionDiagnosticsDataType(' + 'SessionId:' + str(self.SessionId) + ', ' + \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    __repr__ = __str__

class ModelChangeStructureDataType(FrozenClass):

    '''

    :ivar Affected:

    :vartype Affected: NodeId

    :ivar AffectedType:

    :vartype AffectedType: NodeId

    :ivar Verb:

    :vartype Verb: Byte

    '''

    ua_types = {

        'Affected': 'NodeId',

        'AffectedType': 'NodeId',

        'Verb': 'Byte',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.IndexRange = None

        self.DataEncoding = QualifiedName()

        self.ContinuationPoint = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(self.DataEncoding.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryReadValueId(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

        self.DataEncoding = QualifiedName.from_binary(data)

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

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class HistoryReadResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    :ivar HistoryData:

    :vartype HistoryData: ExtensionObject

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

        'ContinuationPoint': 'ByteString',

        'HistoryData': 'ExtensionObject',

               }

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SoftwareCertificate(data)

    def _binary_init(self, data):

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

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

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

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

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

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

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

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

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

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

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(SupportedProfile.from_binary(data))

        self.SupportedProfiles = array

    def __str__(self):

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

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

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

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

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

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

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

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

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

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

    __repr__ = __str__

class QueryDataDescription(FrozenClass):

    '''

    :ivar RelativePath:

    :vartype RelativePath: RelativePath

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    '''

    ua_types = {

        'RelativePath': 'RelativePath',

        'AttributeId': 'UInt32',

        'IndexRange': 'String',

               }

    __repr__ = __str__

class OpenSecureChannelResult(FrozenClass):

    '''

    :ivar ServerProtocolVersion:

    :vartype ServerProtocolVersion: UInt32

    :ivar SecurityToken:

    :vartype SecurityToken: ChannelSecurityToken

    :ivar ServerNonce:

    :vartype ServerNonce: ByteString

    '''

    ua_types = {

        'ServerProtocolVersion': 'UInt32',

        'SecurityToken': 'ChannelSecurityToken',

        'ServerNonce': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ServerProtocolVersion = 0

        self.SecurityToken = ChannelSecurityToken()

        self.ServerNonce = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.SecurityToken.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return OpenSecureChannelResult(data)

    def _binary_init(self, data):

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

        self.SecurityToken = ChannelSecurityToken.from_binary(data)

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

    def __str__(self):

        return 'OpenSecureChannelResult(' + 'ServerProtocolVersion:' + str(self.ServerProtocolVersion) + ', ' + \

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

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

    __repr__ = __str__

class OpenSecureChannelResponse(FrozenClass):

        'TypeId': 'NodeId',

        'ResponseHeader': 'ResponseHeader',

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

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar AvailableSequenceNumbers:

    :vartype AvailableSequenceNumbers: UInt32

    '''

    ua_types = {

        'StatusCode': 'StatusCode',

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.IsDeleteModified = True

        self.StartTime = datetime.utcnow()

        self.EndTime = datetime.utcnow()

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteRawModifiedDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

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

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

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class DeleteAtTimeDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId