FreeOpcUa / python-opcua

        ('ReferencesToDelete', 'ListOfDeleteReferencesItem'),

               )

    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(uabin.Primitives.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 = uabin.Primitives.Int32.unpack(data)

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

    '''

    Delete one or more references from the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: DeleteReferencesParameters

    '''

    ua_types = (

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'DeleteReferencesParameters'),

               )

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.TypeId = FourByteNodeId(ObjectIds.DeleteReferencesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = DeleteReferencesParameters()

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return DeleteReferencesRequest(data)

    def _binary_init(self, data):

        self.TypeId = NodeId.from_binary(data)

        self.RequestHeader = RequestHeader.from_binary(data)

        self.Parameters = DeleteReferencesParameters.from_binary(data)

    def __str__(self):

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

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

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SpecifiedAttributes = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self.WriteMask = 0

        self.UserWriteMask = 0

        self.Value = Variant()

        self.DataType = NodeId()

        self.ValueRank = 0

        self.ArrayDimensions = []

        self.IsAbstract = True

        self._freeze = True

    def to_binary(self):

        packet = []

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

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

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

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

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

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

        packet.append(self.DataType.to_binary())

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

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

        for fieldname in self.ArrayDimensions:

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

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

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return VariableTypeAttributes(data)

    def _binary_init(self, data):

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

        self.DisplayName = LocalizedText.from_binary(data)

        self.Description = LocalizedText.from_binary(data)

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

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

        self.Value = Variant.from_binary(data)

        self.DataType = NodeId.from_binary(data)

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

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

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

    def __str__(self):

        return 'VariableTypeAttributes(' + 'SpecifiedAttributes:' + str(self.SpecifiedAttributes) + ', ' + \

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

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

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

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

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

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

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

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

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

    __repr__ = __str__

class ReferenceTypeAttributes(FrozenClass):

    '''

    The attributes for a reference type node.

    :ivar SpecifiedAttributes:

    :vartype SpecifiedAttributes: UInt32

    :ivar DisplayName:

    :vartype DisplayName: LocalizedText

    :ivar Description:

    :vartype Description: LocalizedText

    :ivar WriteMask:

    :vartype WriteMask: UInt32

    :ivar UserWriteMask:

    :vartype UserWriteMask: UInt32

    :ivar IsAbstract:

    :vartype IsAbstract: Boolean

    :ivar Symmetric:

    :vartype Symmetric: Boolean

    :ivar InverseName:

    :vartype InverseName: LocalizedText