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

    __repr__ = __str__

class TransferSubscriptionsParameters(FrozenClass):

    '''

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    :ivar SendInitialValues:

    :vartype SendInitialValues: Boolean

    '''

    ua_types = {

        'SubscriptionIds': 'UInt32',

        'SendInitialValues': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionIds = []

        self.SendInitialValues = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.SubscriptionIds:

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferSubscriptionsParameters(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'TransferSubscriptionsParameters(' + 'SubscriptionIds:' + str(self.SubscriptionIds) + ', ' + \

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

    __repr__ = __str__

class TransferSubscriptionsRequest(FrozenClass):

    __repr__ = __str__

class SetPublishingModeParameters(FrozenClass):

    '''

    :ivar PublishingEnabled:

    :vartype PublishingEnabled: Boolean

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    '''

    ua_types = {

        'PublishingEnabled': 'Boolean',

        'SubscriptionIds': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.PublishingEnabled = True

        self.SubscriptionIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.SubscriptionIds:

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SetPublishingModeParameters(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class SetPublishingModeRequest(FrozenClass):

    __repr__ = __str__

class DeleteMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar MonitoredItemIds:

    :vartype MonitoredItemIds: UInt32

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

        'MonitoredItemIds': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.MonitoredItemIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.MonitoredItemIds:

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteMonitoredItemsParameters(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class DeleteMonitoredItemsRequest(FrozenClass):

    __repr__ = __str__

class DeleteEventDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar EventIds:

    :vartype EventIds: ByteString

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'EventIds': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.EventIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.EventIds:

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteEventDetails(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

        self.EventIds = uabin.Primitives.ByteString.unpack_array(data)

    def __str__(self):

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

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

    __repr__ = __str__

class HistoryUpdateResult(FrozenClass):

    __repr__ = __str__

class ReadAtTimeDetails(FrozenClass):

    '''

    :ivar ReqTimes:

    :vartype ReqTimes: DateTime

    :ivar UseSimpleBounds:

    :vartype UseSimpleBounds: Boolean

    '''

    ua_types = {

        'ReqTimes': 'DateTime',

        'UseSimpleBounds': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReqTimes = []

        self.UseSimpleBounds = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

        for fieldname in self.ReqTimes:

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadAtTimeDetails(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'ReadAtTimeDetails(' + 'ReqTimes:' + str(self.ReqTimes) + ', ' + \

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

    __repr__ = __str__

class HistoryData(FrozenClass):

    __repr__ = __str__

class BrowsePathTarget(FrozenClass):

    '''

    The target of the translated path.

    :ivar TargetId:

    :vartype TargetId: ExpandedNodeId

    :ivar RemainingPathIndex:

    :vartype RemainingPathIndex: UInt32

    '''

    ua_types = {

        'TargetId': 'ExpandedNodeId',

        'RemainingPathIndex': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TargetId = ExpandedNodeId()

        self.RemainingPathIndex = 0

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TargetId.to_binary())

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowsePathTarget(data)

    def _binary_init(self, data):

        self.TargetId = ExpandedNodeId.from_binary(data)

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

    def __str__(self):

        return 'BrowsePathTarget(' + 'TargetId:' + str(self.TargetId) + ', ' + \

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

    __repr__ = __str__

class BrowsePathResult(FrozenClass):

    __repr__ = __str__

class BrowseNextParameters(FrozenClass):

    '''

    :ivar ReleaseContinuationPoints:

    :vartype ReleaseContinuationPoints: Boolean

    :ivar ContinuationPoints:

    :vartype ContinuationPoints: ByteString

    '''

    ua_types = {

        'ReleaseContinuationPoints': 'Boolean',

        'ContinuationPoints': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReleaseContinuationPoints = True

        self.ContinuationPoints = []

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        for fieldname in self.ContinuationPoints:

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseNextParameters(data)

    def _binary_init(self, data):

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

        self.ContinuationPoints = uabin.Primitives.ByteString.unpack_array(data)

    def __str__(self):

        return 'BrowseNextParameters(' + 'ReleaseContinuationPoints:' + str(self.ReleaseContinuationPoints) + ', ' + \

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

    __repr__ = __str__

class BrowseNextRequest(FrozenClass):

    __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

    '''

    ua_types = {

        'NodeId': 'NodeId',

        'DeleteTargetReferences': 'Boolean',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodeId = NodeId()

        self.DeleteTargetReferences = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesItem(data)

    def _binary_init(self, data):

        self.NodeId = NodeId.from_binary(data)

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

    def __str__(self):

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

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

    __repr__ = __str__

class DeleteNodesParameters(FrozenClass):

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

    __repr__ = __str__

class XVType(FrozenClass):

    '''

    :ivar X:

    :vartype X: Double

    :ivar Value:

    :vartype Value: Float

    '''

    ua_types = {

        'X': 'Double',

        'Value': 'Float',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.X = 0

        self.Value = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return XVType(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'XVType(' + 'X:' + str(self.X) + ', ' + \

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

    __repr__ = __str__

class ProgramDiagnosticDataType(FrozenClass):

    __repr__ = __str__

class DoubleComplexNumberType(FrozenClass):

    '''

    :ivar Real:

    :vartype Real: Double

    :ivar Imaginary:

    :vartype Imaginary: Double

    '''

    ua_types = {

        'Real': 'Double',

        'Imaginary': 'Double',

               }

    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.Double.pack(self.Real))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DoubleComplexNumberType(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class AxisInformation(FrozenClass):

    __repr__ = __str__

class ComplexNumberType(FrozenClass):

    '''

    :ivar Real:

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

    __repr__ = __str__

class Range(FrozenClass):

    '''

    :ivar Low:

    :vartype Low: Double

    :ivar High:

    :vartype High: Double

    '''

    ua_types = {

        'Low': 'Double',

        'High': 'Double',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Low = 0

        self.High = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return Range(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class EUInformation(FrozenClass):

    __repr__ = __str__

class ServiceCounterDataType(FrozenClass):

    '''

    :ivar TotalCount:

    :vartype TotalCount: UInt32

    :ivar ErrorCount:

    :vartype ErrorCount: UInt32

    '''

    ua_types = {

        'TotalCount': 'UInt32',

        'ErrorCount': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TotalCount = 0

        self.ErrorCount = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ServiceCounterDataType(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'ServiceCounterDataType(' + 'TotalCount:' + str(self.TotalCount) + ', ' + \

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

    __repr__ = __str__

class StatusResult(FrozenClass):

    __repr__ = __str__

class RepublishParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar RetransmitSequenceNumber:

    :vartype RetransmitSequenceNumber: UInt32

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

        'RetransmitSequenceNumber': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.RetransmitSequenceNumber = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RepublishParameters(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class RepublishRequest(FrozenClass):

    __repr__ = __str__

class SubscriptionAcknowledgement(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar SequenceNumber:

    :vartype SequenceNumber: UInt32

    '''

    ua_types = {

        'SubscriptionId': 'UInt32',

        'SequenceNumber': 'UInt32',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.SequenceNumber = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SubscriptionAcknowledgement(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

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

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

    __repr__ = __str__

class PublishParameters(FrozenClass):

    __repr__ = __str__

class MonitoredItemNotification(FrozenClass):

    '''

    :ivar ClientHandle:

    :vartype ClientHandle: UInt32

    :ivar Value:

    :vartype Value: DataValue

    '''

    ua_types = {

        'ClientHandle': 'UInt32',

        'Value': 'DataValue',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ClientHandle = 0

        self.Value = DataValue()

        self._freeze = True

    def to_binary(self):

        packet = []

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

        packet.append(self.Value.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemNotification(data)

    def _binary_init(self, data):

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

        self.Value = DataValue.from_binary(data)

    def __str__(self):

        return 'MonitoredItemNotification(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \

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

    __repr__ = __str__

class EventNotificationList(FrozenClass):

    __repr__ = __str__

class MonitoredItemModifyRequest(FrozenClass):

    '''

    :ivar MonitoredItemId:

    :vartype MonitoredItemId: UInt32

    :ivar RequestedParameters:

    :vartype RequestedParameters: MonitoringParameters

    '''

    ua_types = {

        'MonitoredItemId': 'UInt32',

        'RequestedParameters': 'MonitoringParameters',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MonitoredItemId = 0

        self.RequestedParameters = MonitoringParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemModifyRequest(data)

    def _binary_init(self, data):

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

        self.RequestedParameters = MonitoringParameters.from_binary(data)

    def __str__(self):

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

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

    __repr__ = __str__

class MonitoredItemModifyResult(FrozenClass):

    __repr__ = __str__

class QueryNextParameters(FrozenClass):

    '''

    :ivar ReleaseContinuationPoint:

    :vartype ReleaseContinuationPoint: Boolean

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    '''

    ua_types = {

        'ReleaseContinuationPoint': 'Boolean',

        'ContinuationPoint': 'ByteString',

               }

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReleaseContinuationPoint = True

        self.ContinuationPoint = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return QueryNextParameters(data)

    def _binary_init(self, data):

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

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

    def __str__(self):

        return 'QueryNextParameters(' + 'ReleaseContinuationPoint:' + str(self.ReleaseContinuationPoint) + ', ' + \

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

    __repr__ = __str__

class QueryNextRequest(FrozenClass):

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