FreeOpcUa / python-opcua

        ('RevisedQueueSize', 'UInt32'),

        ('FilterResult', 'ExtensionObject'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.RevisedSamplingInterval = 0

        self.RevisedQueueSize = 0

        self.FilterResult = None

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        packet.append(extensionobject_to_binary(self.FilterResult))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return MonitoredItemModifyResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

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

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

        self.FilterResult = extensionobject_from_binary(data)

    def __str__(self):

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

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

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

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

    __repr__ = __str__

class ModifyMonitoredItemsParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar TimestampsToReturn:

    :vartype TimestampsToReturn: TimestampsToReturn

    :ivar ItemsToModify:

    :vartype ItemsToModify: MonitoredItemModifyRequest

    '''

    ua_types = (

        ('SubscriptionId', 'UInt32'),

        ('TimestampsToReturn', 'TimestampsToReturn'),

        ('ItemsToModify', 'ListOfMonitoredItemModifyRequest'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

        packet.append(self.ServiceResult.to_binary())

        packet.append(self.ServiceDiagnostics.to_binary())

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

        for fieldname in self.StringTable:

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

        packet.append(extensionobject_to_binary(self.AdditionalHeader))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ResponseHeader(data)

    def _binary_init(self, data):

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

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

        self.ServiceResult = StatusCode.from_binary(data)

        self.ServiceDiagnostics = DiagnosticInfo.from_binary(data)

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

        self.AdditionalHeader = extensionobject_from_binary(data)

    def __str__(self):

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

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

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

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

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

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

    __repr__ = __str__

class ServiceFault(FrozenClass):

    '''

    The response returned by all services when there is a service level error.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    ua_types = (

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.ServiceFault_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def to_binary(self):