FreeOpcUa / python-opcua

    __repr__ = __str__

class SubscriptionAcknowledgement(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar SequenceNumber:

    :vartype 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(uatype_UInt32.pack(self.SubscriptionId))

        packet.append(uatype_UInt32.pack(self.SequenceNumber))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SubscriptionAcknowledgement(data)

    def _binary_init(self, data):

        self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0]

        self.SequenceNumber = uatype_UInt32.unpack(data.read(4))[0]

    def __str__(self):

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

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

    __repr__ = __str__

class PublishParameters(FrozenClass):

    __repr__ = __str__

class XVType(FrozenClass):

    '''

    :ivar X:

    :vartype X: Double

    :ivar Value:

    :vartype 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(uatype_Double.pack(self.X))

        packet.append(uatype_Float.pack(self.Value))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return XVType(data)

    def _binary_init(self, data):

        self.X = uatype_Double.unpack(data.read(8))[0]

        self.Value = uatype_Float.unpack(data.read(4))[0]

    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

    '''

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

        packet.append(uatype_Double.pack(self.Imaginary))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DoubleComplexNumberType(data)

    def _binary_init(self, data):

        self.Real = uatype_Double.unpack(data.read(8))[0]

        self.Imaginary = uatype_Double.unpack(data.read(8))[0]

    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

    '''

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

        packet.append(uatype_Float.pack(self.Imaginary))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ComplexNumberType(data)

    def _binary_init(self, data):

        self.Real = uatype_Float.unpack(data.read(4))[0]

        self.Imaginary = uatype_Float.unpack(data.read(4))[0]

    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

    '''

    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(uatype_Double.pack(self.Low))

        packet.append(uatype_Double.pack(self.High))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return Range(data)

    def _binary_init(self, data):

        self.Low = uatype_Double.unpack(data.read(8))[0]

        self.High = uatype_Double.unpack(data.read(8))[0]

    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

    '''

    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(uatype_UInt32.pack(self.TotalCount))

        packet.append(uatype_UInt32.pack(self.ErrorCount))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ServiceCounterDataType(data)

    def _binary_init(self, data):

        self.TotalCount = uatype_UInt32.unpack(data.read(4))[0]

        self.ErrorCount = uatype_UInt32.unpack(data.read(4))[0]

    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

    '''

    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(uatype_UInt32.pack(self.SubscriptionId))

        packet.append(uatype_UInt32.pack(self.RetransmitSequenceNumber))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RepublishParameters(data)

    def _binary_init(self, data):

        self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0]

        self.RetransmitSequenceNumber = uatype_UInt32.unpack(data.read(4))[0]

    def __str__(self):

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

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

    __repr__ = __str__

class RepublishRequest(FrozenClass):

    __repr__ = __str__

class TimeZoneDataType(FrozenClass):

    '''

    :ivar Offset:

    :vartype Offset: Int16

    :ivar DaylightSavingInOffset:

    :vartype 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(uatype_Int16.pack(self.Offset))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TimeZoneDataType(data)

    def _binary_init(self, data):

        self.Offset = uatype_Int16.unpack(data.read(2))[0]

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

    def __str__(self):

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

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

    __repr__ = __str__

class ApplicationDescription(FrozenClass):

    __repr__ = __str__

class TransferSubscriptionsParameters(FrozenClass):

    '''

    :ivar SubscriptionIds:

    :vartype SubscriptionIds: UInt32

    :ivar SendInitialValues:

    :vartype 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(uatype_Int32.pack(len(self.SubscriptionIds)))

        for fieldname in self.SubscriptionIds:

            packet.append(uatype_UInt32.pack(fieldname))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TransferSubscriptionsParameters(data)

    def _binary_init(self, data):

        self.SubscriptionIds = unpack_uatype_array('UInt32', data)

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

    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

    '''

    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(uatype_Boolean.pack(self.PublishingEnabled))

        packet.append(uatype_Int32.pack(len(self.SubscriptionIds)))

        for fieldname in self.SubscriptionIds:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SetPublishingModeParameters(data)

    def _binary_init(self, data):

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

        self.SubscriptionIds = unpack_uatype_array('UInt32', 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

    '''

    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(uatype_UInt32.pack(self.SubscriptionId))

        packet.append(uatype_Int32.pack(len(self.MonitoredItemIds)))

        for fieldname in self.MonitoredItemIds:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteMonitoredItemsParameters(data)

    def _binary_init(self, data):

        self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0]

        self.MonitoredItemIds = unpack_uatype_array('UInt32', data)

    def __str__(self):

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

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

    __repr__ = __str__

class DeleteMonitoredItemsRequest(FrozenClass):

    __repr__ = __str__

class ReadAtTimeDetails(FrozenClass):

    '''

    :ivar ReqTimes:

    :vartype ReqTimes: DateTime

    :ivar UseSimpleBounds:

    :vartype 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(uatype_Int32.pack(len(self.ReqTimes)))

        for fieldname in self.ReqTimes:

            packet.append(pack_datetime(fieldname))

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ReadAtTimeDetails(data)

    def _binary_init(self, data):

        self.ReqTimes = unpack_uatype_array('DateTime', data)

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

    def __str__(self):

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

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

    __repr__ = __str__

class HistoryData(FrozenClass):

    __repr__ = __str__

class BrowseNextParameters(FrozenClass):

    '''

    :ivar ReleaseContinuationPoints:

    :vartype ReleaseContinuationPoints: Boolean

    :ivar ContinuationPoints:

    :vartype 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(uatype_Boolean.pack(self.ReleaseContinuationPoints))

        packet.append(uatype_Int32.pack(len(self.ContinuationPoints)))

        for fieldname in self.ContinuationPoints:

            packet.append(pack_bytes(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowseNextParameters(data)

    def _binary_init(self, data):

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

        self.ContinuationPoints = unpack_uatype_array('ByteString', data)

    def __str__(self):

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

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

    __repr__ = __str__

class BrowseNextRequest(FrozenClass):

    __repr__ = __str__

class RelativePath(FrozenClass):

    '''

    A relative path constructed from reference types and browse names.

    :ivar Elements:

    :vartype Elements: RelativePathElement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Elements = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.Elements)))

        for fieldname in self.Elements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RelativePath(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(RelativePathElement.from_binary(data))

        self.Elements = array

    def __str__(self):

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

    __repr__ = __str__

class BrowsePath(FrozenClass):

    __repr__ = __str__

class PublishParameters(FrozenClass):

    '''

    :ivar SubscriptionAcknowledgements:

    :vartype SubscriptionAcknowledgements: SubscriptionAcknowledgement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionAcknowledgements = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.SubscriptionAcknowledgements)))

        for fieldname in self.SubscriptionAcknowledgements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return PublishParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(SubscriptionAcknowledgement.from_binary(data))

        self.SubscriptionAcknowledgements = array

    def __str__(self):

        return 'PublishParameters(' + 'SubscriptionAcknowledgements:' + str(self.SubscriptionAcknowledgements) + ')'

    __repr__ = __str__

class PublishRequest(FrozenClass):

    __repr__ = __str__

class HistoryEventFieldList(FrozenClass):

    '''

    :ivar EventFields:

    :vartype EventFields: Variant

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.EventFields = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.EventFields)))

        for fieldname in self.EventFields:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryEventFieldList(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Variant.from_binary(data))

        self.EventFields = array

    def __str__(self):

        return 'HistoryEventFieldList(' + 'EventFields:' + str(self.EventFields) + ')'

    __repr__ = __str__

class StatusChangeNotification(FrozenClass):

    __repr__ = __str__

class EventNotificationList(FrozenClass):

    '''

    :ivar Events:

    :vartype Events: EventFieldList

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Events = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.Events)))

        for fieldname in self.Events:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EventNotificationList(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(EventFieldList.from_binary(data))

        self.Events = array

    def __str__(self):

        return 'EventNotificationList(' + 'Events:' + str(self.Events) + ')'

    __repr__ = __str__

class EventFieldList(FrozenClass):

    __repr__ = __str__

class CallParameters(FrozenClass):

    '''

    :ivar MethodsToCall:

    :vartype MethodsToCall: CallMethodRequest

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.MethodsToCall = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.MethodsToCall)))

        for fieldname in self.MethodsToCall:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return CallParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(CallMethodRequest.from_binary(data))

        self.MethodsToCall = array

    def __str__(self):

        return 'CallParameters(' + 'MethodsToCall:' + str(self.MethodsToCall) + ')'

    __repr__ = __str__

class CallRequest(FrozenClass):

    __repr__ = __str__

class HistoryUpdateParameters(FrozenClass):

    '''

    :ivar HistoryUpdateDetails:

    :vartype HistoryUpdateDetails: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.HistoryUpdateDetails = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.HistoryUpdateDetails)))

        for fieldname in self.HistoryUpdateDetails:

            packet.append(extensionobject_to_binary(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryUpdateParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(extensionobject_from_binary(data))

        self.HistoryUpdateDetails = array

    def __str__(self):

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

    __repr__ = __str__

class HistoryUpdateRequest(FrozenClass):

    __repr__ = __str__

class WriteParameters(FrozenClass):

    '''

    :ivar NodesToWrite:

    :vartype NodesToWrite: WriteValue

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToWrite = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.NodesToWrite)))

        for fieldname in self.NodesToWrite:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return WriteParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(WriteValue.from_binary(data))

        self.NodesToWrite = array

    def __str__(self):

        return 'WriteParameters(' + 'NodesToWrite:' + str(self.NodesToWrite) + ')'

    __repr__ = __str__

class WriteRequest(FrozenClass):

    __repr__ = __str__

class HistoryEvent(FrozenClass):

    '''

    :ivar Events:

    :vartype Events: HistoryEventFieldList

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Events = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.Events)))

        for fieldname in self.Events:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryEvent(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(HistoryEventFieldList.from_binary(data))

        self.Events = array

    def __str__(self):

        return 'HistoryEvent(' + 'Events:' + str(self.Events) + ')'

    __repr__ = __str__

class HistoryReadParameters(FrozenClass):

    __repr__ = __str__

class HistoryData(FrozenClass):

    '''

    :ivar DataValues:

    :vartype DataValues: DataValue

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.DataValues = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.DataValues)))

        for fieldname in self.DataValues:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return HistoryData(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DataValue.from_binary(data))

        self.DataValues = array

    def __str__(self):

        return 'HistoryData(' + 'DataValues:' + str(self.DataValues) + ')'

    __repr__ = __str__

class ModificationInfo(FrozenClass):

    __repr__ = __str__

class ContentFilter(FrozenClass):

    '''

    :ivar Elements:

    :vartype Elements: ContentFilterElement

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Elements = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.Elements)))

        for fieldname in self.Elements:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ContentFilter(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(ContentFilterElement.from_binary(data))

        self.Elements = array

    def __str__(self):

        return 'ContentFilter(' + 'Elements:' + str(self.Elements) + ')'

    __repr__ = __str__

class ElementOperand(FrozenClass):

    __repr__ = __str__

class UnregisterNodesParameters(FrozenClass):

    '''

    :ivar NodesToUnregister:

    :vartype NodesToUnregister: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToUnregister = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.NodesToUnregister)))

        for fieldname in self.NodesToUnregister:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return UnregisterNodesParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.NodesToUnregister = array

    def __str__(self):

        return 'UnregisterNodesParameters(' + 'NodesToUnregister:' + str(self.NodesToUnregister) + ')'

    __repr__ = __str__

class UnregisterNodesRequest(FrozenClass):

    __repr__ = __str__

class RegisterNodesResult(FrozenClass):

    '''

    :ivar RegisteredNodeIds:

    :vartype RegisteredNodeIds: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.RegisteredNodeIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.RegisteredNodeIds)))

        for fieldname in self.RegisteredNodeIds:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterNodesResult(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.RegisteredNodeIds = array

    def __str__(self):

        return 'RegisterNodesResult(' + 'RegisteredNodeIds:' + str(self.RegisteredNodeIds) + ')'

    __repr__ = __str__

class RegisterNodesResponse(FrozenClass):

    __repr__ = __str__

class RegisterNodesParameters(FrozenClass):

    '''

    :ivar NodesToRegister:

    :vartype NodesToRegister: NodeId

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToRegister = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.NodesToRegister)))

        for fieldname in self.NodesToRegister:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterNodesParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(NodeId.from_binary(data))

        self.NodesToRegister = array

    def __str__(self):

        return 'RegisterNodesParameters(' + 'NodesToRegister:' + str(self.NodesToRegister) + ')'

    __repr__ = __str__

class RegisterNodesRequest(FrozenClass):

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsParameters(FrozenClass):

    '''

    :ivar BrowsePaths:

    :vartype BrowsePaths: BrowsePath

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.BrowsePaths = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.BrowsePaths)))

        for fieldname in self.BrowsePaths:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return TranslateBrowsePathsToNodeIdsParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(BrowsePath.from_binary(data))

        self.BrowsePaths = array

    def __str__(self):

        return 'TranslateBrowsePathsToNodeIdsParameters(' + 'BrowsePaths:' + str(self.BrowsePaths) + ')'

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsRequest(FrozenClass):

    __repr__ = __str__

class DeleteReferencesParameters(FrozenClass):

    '''

    :ivar ReferencesToDelete:

    :vartype ReferencesToDelete: DeleteReferencesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ReferencesToDelete = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.ReferencesToDelete)))

        for fieldname in self.ReferencesToDelete:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteReferencesParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DeleteReferencesItem.from_binary(data))

        self.ReferencesToDelete = array

    def __str__(self):

        return 'DeleteReferencesParameters(' + 'ReferencesToDelete:' + str(self.ReferencesToDelete) + ')'

    __repr__ = __str__

class DeleteReferencesRequest(FrozenClass):

    __repr__ = __str__

class DeleteNodesParameters(FrozenClass):

    '''

    :ivar NodesToDelete:

    :vartype NodesToDelete: DeleteNodesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToDelete = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.NodesToDelete)))

        for fieldname in self.NodesToDelete:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteNodesParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DeleteNodesItem.from_binary(data))

        self.NodesToDelete = array

    def __str__(self):

        return 'DeleteNodesParameters(' + 'NodesToDelete:' + str(self.NodesToDelete) + ')'

    __repr__ = __str__

class DeleteNodesRequest(FrozenClass):

    __repr__ = __str__

class AddNodesParameters(FrozenClass):

    '''

    :ivar NodesToAdd:

    :vartype NodesToAdd: AddNodesItem

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.NodesToAdd = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.NodesToAdd)))

        for fieldname in self.NodesToAdd:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return AddNodesParameters(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(AddNodesItem.from_binary(data))

        self.NodesToAdd = array

    def __str__(self):

        return 'AddNodesParameters(' + 'NodesToAdd:' + str(self.NodesToAdd) + ')'

    __repr__ = __str__

class AddNodesRequest(FrozenClass):

    __repr__ = __str__

class SequenceHeader(uatypes.FrozenClass):

    def __init__(self):

        self.SequenceNumber = None

        self.RequestId = None

        self._freeze = True

    @staticmethod

    def from_binary(data):

        obj = SequenceHeader()

        obj.SequenceNumber = uatype_UInt32.unpack(data.read(4))[0]

        obj.RequestId = uatype_UInt32.unpack(data.read(4))[0]

        return obj

    def to_binary(self):

        b = []

        b.append(uatype_UInt32.pack(self.SequenceNumber))

        b.append(uatype_UInt32.pack(self.RequestId))

        return b"".join(b)

    @staticmethod

    def max_size():

        return struct.calcsize("<II")

    def __str__(self):

        return "{}(SequenceNumber:{}, RequestId:{} )".format(self.__class__.__name__, self.SequenceNumber, self.RequestId)

    __repr__ = __str__

class CryptographyNone: