FreeOpcUa / python-opcua

    __repr__ = __str__

class CreateSessionResult(FrozenClass):

    '''

    :ivar SessionId:

    :vartype SessionId: NodeId

    :ivar AuthenticationToken:

    :vartype AuthenticationToken: NodeId

    :ivar RevisedSessionTimeout:

    :vartype RevisedSessionTimeout: Double

    :ivar ServerNonce:

    :vartype ServerNonce: ByteString

    :ivar ServerCertificate:

    :vartype ServerCertificate: ByteString

    :ivar ServerEndpoints:

    :vartype ServerEndpoints: EndpointDescription

    :ivar ServerSoftwareCertificates:

    :vartype ServerSoftwareCertificates: SignedSoftwareCertificate

    :ivar ServerSignature:

    :vartype ServerSignature: SignatureData

    :ivar MaxRequestMessageSize:

    :vartype MaxRequestMessageSize: UInt32

    '''

    ua_types = [

        ('SessionId', 'NodeId'),

        ('AuthenticationToken', 'NodeId'),

        ('RevisedSessionTimeout', 'Double'),

        ('ServerNonce', 'ByteString'),

        ('ServerCertificate', 'ByteString'),

        ('ServerEndpoints', 'ListOfEndpointDescription'),

        ('ServerSoftwareCertificates', 'ListOfSignedSoftwareCertificate'),

        ('ServerSignature', 'SignatureData'),

        ('MaxRequestMessageSize', 'UInt32'),

    :ivar Signature:

    :vartype Signature: ByteString

    '''

    ua_types = [

        ('Algorithm', 'String'),

        ('Signature', 'ByteString'),

               ]

    def __init__(self):

        self.Algorithm = None

        self.Signature = None

        self._freeze = True

    def __str__(self):

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

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

    __repr__ = __str__

class CreateSessionParameters(FrozenClass):

    '''

    :ivar ClientDescription:

    :vartype ClientDescription: ApplicationDescription

    :ivar ServerUri:

    :vartype ServerUri: String

    :ivar EndpointUrl:

    :vartype EndpointUrl: String

    :ivar SessionName:

    :vartype SessionName: String

    :ivar ClientNonce:

    :vartype ClientNonce: ByteString

    :ivar ClientCertificate:

    :vartype ClientCertificate: ByteString

    :ivar RequestedSessionTimeout:

class CloseSecureChannelRequest(FrozenClass):

    '''

    Closes a secure channel.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.CloseSecureChannelRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self._freeze = True

    def __str__(self):

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

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

    __repr__ = __str__

class CloseSecureChannelResponse(FrozenClass):

    '''

    Closes a secure channel.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

        ('DiscoveryConfiguration', 'ListOfExtensionObject'),

               ]

    def __init__(self):

        self.Server = RegisteredServer()

        self.DiscoveryConfiguration = []

        self._freeze = True

    def __str__(self):

        return 'RegisterServer2Parameters(' + 'Server:' + str(self.Server) + ', ' + \

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

    __repr__ = __str__

class RegisterServer2Request(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: RegisterServer2Parameters

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'RegisterServer2Parameters'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.RegisterServer2Request_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = RegisterServer2Parameters()

        self._freeze = True

        self.RequestHeader = RequestHeader()

        self.Server = RegisteredServer()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class RegisterServerResponse(FrozenClass):

    '''

    Registers a server with the discovery server.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.RegisterServerResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self._freeze = True

    def __str__(self):

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

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

        self.ResponseHeader = ResponseHeader()

        self.Parameters = FindServersOnNetworkResult()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class UserTokenPolicy(FrozenClass):

    '''

    Describes a user token that can be used with a server.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar TokenType:

    :vartype TokenType: UserTokenType

    :ivar IssuedTokenType:

    :vartype IssuedTokenType: String

    :ivar IssuerEndpointUrl:

    :vartype IssuerEndpointUrl: String

    :ivar SecurityPolicyUri:

    :vartype SecurityPolicyUri: String

    '''

    ua_types = [

        ('PolicyId', 'String'),

        ('TokenType', 'UserTokenType'),

        ('IssuedTokenType', 'String'),

        ('IssuerEndpointUrl', 'String'),

        ('SecurityPolicyUri', 'String'),

               ]

    :vartype DiscoveryUrl: String

    :ivar ServerCapabilities:

    :vartype ServerCapabilities: String

    '''

    ua_types = [

        ('RecordId', 'UInt32'),

        ('ServerName', 'String'),

        ('DiscoveryUrl', 'String'),

        ('ServerCapabilities', 'ListOfString'),

               ]

    def __init__(self):

        self.RecordId = 0

        self.ServerName = None

        self.DiscoveryUrl = None

        self.ServerCapabilities = []

        self._freeze = True

    def __str__(self):

        return 'ServerOnNetwork(' + 'RecordId:' + str(self.RecordId) + ', ' + \

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

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

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

    __repr__ = __str__

class FindServersOnNetworkParameters(FrozenClass):

    '''

    :ivar StartingRecordId:

    :vartype StartingRecordId: UInt32

    :ivar MaxRecordsToReturn:

    :vartype MaxRecordsToReturn: UInt32

    :ivar ServerCapabilityFilter:

    :vartype ServerCapabilityFilter: String

    def __init__(self):

        self.NamespaceUris = []

        self.ServerUris = []

        self.ServiceId = 0

        self._freeze = True

    def __str__(self):

        return 'SessionlessInvokeResponseType(' + 'NamespaceUris:' + str(self.NamespaceUris) + ', ' + \

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

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

    __repr__ = __str__

class FindServersParameters(FrozenClass):

    '''

    :ivar EndpointUrl:

    :vartype EndpointUrl: String

    :ivar LocaleIds:

    :vartype LocaleIds: String

    :ivar ServerUris:

    :vartype ServerUris: String

    '''

    ua_types = [

        ('EndpointUrl', 'String'),

        ('LocaleIds', 'ListOfString'),

        ('ServerUris', 'ListOfString'),

               ]

    def __init__(self):

        self.EndpointUrl = None

        self.LocaleIds = []

        self.ServerUris = []

        self._freeze = True

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

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

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

    __repr__ = __str__

class ResponseHeader(FrozenClass):

    '''

    The header passed with every server response.

    :ivar Timestamp:

    :vartype Timestamp: DateTime

    :ivar RequestHandle:

    :vartype RequestHandle: UInt32

    :ivar ServiceResult:

    :vartype ServiceResult: StatusCode

    :ivar ServiceDiagnostics:

    :vartype ServiceDiagnostics: DiagnosticInfo

    :ivar StringTable:

    :vartype StringTable: String

    :ivar AdditionalHeader:

    :vartype AdditionalHeader: ExtensionObject

    '''

    ua_types = [

        ('Timestamp', 'DateTime'),

        ('RequestHandle', 'UInt32'),

        ('ServiceResult', 'StatusCode'),

        ('ServiceDiagnostics', 'DiagnosticInfo'),

        ('StringTable', 'ListOfString'),

        ('AdditionalHeader', 'ExtensionObject'),

               ]

    def __init__(self):

        self.Timestamp = datetime.utcnow()

        self.DataSetMessageContentMask = UadpDataSetMessageContentMask(0)

        self.PublishingInterval = 0

        self.ReceiveOffset = 0

        self.ProcessingOffset = 0

        self._freeze = True

    def __str__(self):

        return 'UadpDataSetReaderMessageDataType(' + 'GroupVersion:' + str(self.GroupVersion) + ', ' + \

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

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

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

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

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

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

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

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

    __repr__ = __str__

class JsonWriterGroupMessageDataType(FrozenClass):

    '''

    :ivar NetworkMessageContentMask:

    :vartype NetworkMessageContentMask: JsonNetworkMessageContentMask

    '''

    ua_types = [

        ('NetworkMessageContentMask', 'JsonNetworkMessageContentMask'),

               ]

    def __init__(self):

        self.NetworkMessageContentMask = JsonNetworkMessageContentMask(0)

        self._freeze = True

    def __str__(self):

        return 'JsonWriterGroupMessageDataType(' + 'NetworkMessageContentMask:' + str(self.NetworkMessageContentMask) + ')'

    __repr__ = __str__

class SubscribedDataSetMirrorDataType(FrozenClass):

    '''

    :ivar ParentNodeName:

    :vartype ParentNodeName: String

    :ivar RolePermissions:

    :vartype RolePermissions: RolePermissionType

    '''

    ua_types = [

        ('ParentNodeName', 'String'),

        ('RolePermissions', 'ListOfRolePermissionType'),

               ]

    def __init__(self):

        self.ParentNodeName = None

        self.RolePermissions = []

        self._freeze = True

    def __str__(self):

        return 'SubscribedDataSetMirrorDataType(' + 'ParentNodeName:' + str(self.ParentNodeName) + ', ' + \

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

    __repr__ = __str__

class PubSubConfigurationDataType(FrozenClass):

    '''

    :ivar PublishedDataSets:

    :vartype PublishedDataSets: PublishedDataSetDataType

    :ivar Connections:

    :vartype Connections: PubSubConnectionDataType

    :ivar Enabled:

    :vartype Enabled: Boolean

class NetworkAddressUrlDataType(FrozenClass):

    '''

    :ivar NetworkInterface:

    :vartype NetworkInterface: String

    :ivar Url:

    :vartype Url: String

    '''

    ua_types = [

        ('NetworkInterface', 'String'),

        ('Url', 'String'),

               ]

    def __init__(self):

        self.NetworkInterface = None

        self.Url = None

        self._freeze = True

    def __str__(self):

        return 'NetworkAddressUrlDataType(' + 'NetworkInterface:' + str(self.NetworkInterface) + ', ' + \

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

    __repr__ = __str__

class ReaderGroupDataType(FrozenClass):

    '''

    :ivar Name:

    :vartype Name: String

    :ivar Enabled:

    :vartype Enabled: Boolean

    :ivar SecurityMode:

    :vartype SecurityMode: MessageSecurityMode

    :ivar SecurityGroupId:

    :vartype SecurityGroupId: String

    :ivar SecurityKeyServices:

    :vartype SecurityKeyServices: EndpointDescription

    :ivar MaxNetworkMessageSize:

    :vartype MaxNetworkMessageSize: UInt32

    :ivar GroupProperties:

    :vartype GroupProperties: KeyValuePair

    '''

    ua_types = [

        ('Name', 'String'),

        ('Enabled', 'Boolean'),

        ('SecurityMode', 'MessageSecurityMode'),

        ('SecurityGroupId', 'String'),

        ('SecurityKeyServices', 'ListOfEndpointDescription'),

        ('MaxNetworkMessageSize', 'UInt32'),

        ('GroupProperties', 'ListOfKeyValuePair'),

               ]

    def __init__(self):

        self.Name = None

        self.Enabled = True

        self.SecurityMode = MessageSecurityMode(0)

        self.SecurityGroupId = None

        self.SecurityKeyServices = []

        self.MaxNetworkMessageSize = 0

        self.GroupProperties = []

        self._freeze = True

    def __str__(self):

        return 'PubSubGroupDataType(' + 'Name:' + str(self.Name) + ', ' + \

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

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

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

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

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

    '''

    ua_types = [

        ('Namespaces', 'ListOfString'),

        ('StructureDataTypes', 'ListOfStructureDescription'),

        ('EnumDataTypes', 'ListOfEnumDescription'),

        ('SimpleDataTypes', 'ListOfSimpleTypeDescription'),

        ('Name', 'String'),

        ('Description', 'LocalizedText'),

        ('Fields', 'ListOfFieldMetaData'),

        ('DataSetClassId', 'Guid'),

        ('ConfigurationVersion', 'ConfigurationVersionDataType'),

               ]

    def __init__(self):

        self.Namespaces = []

        self.StructureDataTypes = []

        self.EnumDataTypes = []

        self.SimpleDataTypes = []

        self.Name = None

        self.Description = LocalizedText()

        self.Fields = []

        self.DataSetClassId = Guid()

        self.ConfigurationVersion = ConfigurationVersionDataType()

        self._freeze = True

    def __str__(self):

        return 'DataSetMetaDataType(' + 'Namespaces:' + str(self.Namespaces) + ', ' + \

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

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

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

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

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

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

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

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

    ua_types = [

        ('EndpointUrl', 'String'),

        ('SecurityMode', 'MessageSecurityMode'),

        ('SecurityPolicyUri', 'String'),

        ('TransportProfileUri', 'String'),

               ]

    def __init__(self):

        self.EndpointUrl = None

        self.SecurityMode = MessageSecurityMode(0)

        self.SecurityPolicyUri = None

        self.TransportProfileUri = None

        self._freeze = True

    def __str__(self):

        return 'EndpointType(' + 'EndpointUrl:' + str(self.EndpointUrl) + ', ' + \

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

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

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

    __repr__ = __str__

class IdentityMappingRuleType(FrozenClass):

    '''

    :ivar CriteriaType:

    :vartype CriteriaType: IdentityCriteriaType

    :ivar Criteria:

    :vartype Criteria: String

    '''

    ua_types = [

        ('CriteriaType', 'IdentityCriteriaType'),

        ('Criteria', 'String'),

               ]

    :vartype UpdateValues: DataValue

    '''

    ua_types = [

        ('NodeId', 'NodeId'),

        ('PerformInsertReplace', 'PerformUpdateType'),

        ('UpdateValues', 'ListOfDataValue'),

               ]

    def __init__(self):

        self.NodeId = NodeId()

        self.PerformInsertReplace = PerformUpdateType(0)

        self.UpdateValues = []

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class UpdateEventDetails(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar PerformInsertReplace:

    :vartype PerformInsertReplace: PerformUpdateType

    :ivar Filter:

    :vartype Filter: EventFilter

    :ivar EventData:

    :vartype EventData: HistoryEventFieldList

    '''

        self.TypeId = FourByteNodeId(ObjectIds.WriteRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = WriteParameters()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class WriteResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: StatusCode

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Results', 'ListOfStatusCode'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.WriteResponse_Encoding_DefaultBinary)

    __repr__ = __str__

class HistoryReadResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Results:

    :vartype Results: HistoryReadResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Results', 'ListOfHistoryReadResult'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.HistoryReadResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        self._freeze = True

    def __str__(self):

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

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

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

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

    :vartype UserName: String

    '''

    ua_types = [

        ('ModificationTime', 'DateTime'),

        ('UpdateType', 'HistoryUpdateType'),

        ('UserName', 'String'),

               ]

    def __init__(self):

        self.ModificationTime = datetime.utcnow()

        self.UpdateType = HistoryUpdateType(0)

        self.UserName = None

        self._freeze = True

    def __str__(self):

        return 'ModificationInfo(' + 'ModificationTime:' + str(self.ModificationTime) + ', ' + \

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

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

    __repr__ = __str__

class HistoryModifiedData(FrozenClass):

    '''

    :ivar DataValues:

    :vartype DataValues: DataValue

    :ivar ModificationInfos:

    :vartype ModificationInfos: ModificationInfo

    '''

    ua_types = [

        ('DataValues', 'ListOfDataValue'),

        ('ModificationInfos', 'ListOfModificationInfo'),

    __repr__ = __str__

class ReadRequest(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: ReadParameters

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'ReadParameters'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.ReadRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = ReadParameters()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class ReadResponse(FrozenClass):

    :ivar QueryDataSets:

    :vartype QueryDataSets: QueryDataSet

    :ivar RevisedContinuationPoint:

    :vartype RevisedContinuationPoint: ByteString

    '''

    ua_types = [

        ('QueryDataSets', 'ListOfQueryDataSet'),

        ('RevisedContinuationPoint', 'ByteString'),

               ]

    def __init__(self):

        self.QueryDataSets = []

        self.RevisedContinuationPoint = None

        self._freeze = True

    def __str__(self):

        return 'QueryNextResult(' + 'QueryDataSets:' + str(self.QueryDataSets) + ', ' + \

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

    __repr__ = __str__

class QueryNextResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: QueryNextResult

    '''

    ua_types = [

        self.TypeId = FourByteNodeId(ObjectIds.QueryFirstRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = QueryFirstParameters()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class QueryFirstResult(FrozenClass):

    '''

    :ivar QueryDataSets:

    :vartype QueryDataSets: QueryDataSet

    :ivar ContinuationPoint:

    :vartype ContinuationPoint: ByteString

    :ivar ParsingResults:

    :vartype ParsingResults: ParsingResult

    :ivar DiagnosticInfos:

    :vartype DiagnosticInfos: DiagnosticInfo

    :ivar FilterResult:

    :vartype FilterResult: ContentFilterResult

    '''

    ua_types = [

        ('QueryDataSets', 'ListOfQueryDataSet'),

        ('ContinuationPoint', 'ByteString'),

        ('ParsingResults', 'ListOfParsingResult'),

        ('DiagnosticInfos', 'ListOfDiagnosticInfo'),

        ('FilterResult', 'ContentFilterResult'),

               ]

    :ivar ElementResults:

    :vartype ElementResults: ContentFilterElementResult

    :ivar ElementDiagnosticInfos:

    :vartype ElementDiagnosticInfos: DiagnosticInfo

    '''

    ua_types = [

        ('ElementResults', 'ListOfContentFilterElementResult'),

        ('ElementDiagnosticInfos', 'ListOfDiagnosticInfo'),

               ]

    def __init__(self):

        self.ElementResults = []

        self.ElementDiagnosticInfos = []

        self._freeze = True

    def __str__(self):

        return 'ContentFilterResult(' + 'ElementResults:' + str(self.ElementResults) + ', ' + \

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

    __repr__ = __str__

class ParsingResult(FrozenClass):

    '''

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar DataStatusCodes:

    :vartype DataStatusCodes: StatusCode

    :ivar DataDiagnosticInfos:

    :vartype DataDiagnosticInfos: DiagnosticInfo

    '''

    ua_types = [

        ('Value', 'Variant'),

               ]

    def __init__(self):

        self.Value = Variant()

        self._freeze = True

    def __str__(self):

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

    __repr__ = __str__

class AttributeOperand(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar Alias:

    :vartype Alias: String

    :ivar BrowsePath:

    :vartype BrowsePath: RelativePath

    :ivar AttributeId:

    :vartype AttributeId: UInt32

    :ivar IndexRange:

    :vartype IndexRange: String

    '''

    ua_types = [

        ('NodeId', 'NodeId'),

        ('Alias', 'String'),

        ('BrowsePath', 'RelativePath'),

        ('AttributeId', 'UInt32'),

        ('IndexRange', 'String'),

               ]

        self.NodeId = ExpandedNodeId()

        self.TypeDefinitionNode = ExpandedNodeId()

        self.Values = []

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class NodeReference(FrozenClass):

    '''

    :ivar NodeId:

    :vartype NodeId: NodeId

    :ivar ReferenceTypeId:

    :vartype ReferenceTypeId: NodeId

    :ivar IsForward:

    :vartype IsForward: Boolean

    :ivar ReferencedNodeIds:

    :vartype ReferencedNodeIds: NodeId

    '''

    ua_types = [

        ('NodeId', 'NodeId'),

        ('ReferenceTypeId', 'NodeId'),

        ('IsForward', 'Boolean'),

        ('ReferencedNodeIds', 'ListOfNodeId'),

               ]

    def __init__(self):

        self.NodeId = NodeId()

        self.ChannelLifetime = 0

        self.SecurityTokenLifetime = 0

        self._freeze = True

    def __str__(self):

        return 'EndpointConfiguration(' + 'OperationTimeout:' + str(self.OperationTimeout) + ', ' + \

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

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

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

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

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

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

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

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

    __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'),

               ]

class RegisterNodesResponse(FrozenClass):

    '''

    Registers one or more nodes for repeated use within a session.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: RegisterNodesResult

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Parameters', 'RegisterNodesResult'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.RegisterNodesResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = RegisterNodesResult()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

        self.ResponseHeader = ResponseHeader()

        self.Results = []

        self.DiagnosticInfos = []

        self._freeze = True

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

        ('ContinuationPoints', 'ListOfByteString'),

               ]

    def __init__(self):

        self.ReleaseContinuationPoints = True

        self.ContinuationPoints = []

        self._freeze = True

    def __str__(self):

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

    ua_types = [

        ('ReferenceTypeId', 'NodeId'),

        ('IsForward', 'Boolean'),

        ('NodeId', 'ExpandedNodeId'),

        ('BrowseName', 'QualifiedName'),

        ('DisplayName', 'LocalizedText'),

        ('NodeClass', 'NodeClass'),

        ('TypeDefinition', 'ExpandedNodeId'),

               ]

    def __init__(self):

        self.ReferenceTypeId = NodeId()

        self.IsForward = True

        self.NodeId = ExpandedNodeId()

        self.BrowseName = QualifiedName()

        self.DisplayName = LocalizedText()

        self.NodeClass = NodeClass(0)

        self.TypeDefinition = ExpandedNodeId()

        self._freeze = True

    def __str__(self):

        return 'ReferenceDescription(' + 'ReferenceTypeId:' + str(self.ReferenceTypeId) + ', ' + \

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

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

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

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

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

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

    __repr__ = __str__

class BrowseResult(FrozenClass):

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: DeleteNodesParameters

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'DeleteNodesParameters'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.DeleteNodesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = DeleteNodesParameters()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class DeleteNodesResponse(FrozenClass):

    '''

    Delete one or more nodes from the server address space.

    :ivar TypeId:

class AddReferencesRequest(FrozenClass):

    '''

    Adds one or more references to the server address space.

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar RequestHeader:

    :vartype RequestHeader: RequestHeader

    :ivar Parameters:

    :vartype Parameters: AddReferencesParameters

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('RequestHeader', 'RequestHeader'),

        ('Parameters', 'AddReferencesParameters'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.AddReferencesRequest_Encoding_DefaultBinary)

        self.RequestHeader = RequestHeader()

        self.Parameters = AddReferencesParameters()

        self._freeze = True

    def __str__(self):

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

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

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

    __repr__ = __str__

class AddReferencesResponse(FrozenClass):

    def __str__(self):

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

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

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

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

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

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

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

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

    __repr__ = __str__

class DataTypeAttributes(FrozenClass):

    '''

    The attributes for a data 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

    '''

    ua_types = [

        ('SpecifiedAttributes', 'UInt32'),

        ('DisplayName', 'LocalizedText'),

    :ivar Description:

    :vartype Description: LocalizedText

    :ivar WriteMask:

    :vartype WriteMask: UInt32

    :ivar UserWriteMask:

    :vartype UserWriteMask: UInt32

    :ivar IsAbstract:

    :vartype IsAbstract: Boolean

    '''

    ua_types = [

        ('SpecifiedAttributes', 'UInt32'),

        ('DisplayName', 'LocalizedText'),

        ('Description', 'LocalizedText'),

        ('WriteMask', 'UInt32'),

        ('UserWriteMask', 'UInt32'),

        ('IsAbstract', 'Boolean'),

               ]

    def __init__(self):

        self.SpecifiedAttributes = 0

        self.DisplayName = LocalizedText()

        self.Description = LocalizedText()

        self.WriteMask = 0

        self.UserWriteMask = 0

        self.IsAbstract = True

        self._freeze = True

    def __str__(self):

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

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

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

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

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

    :vartype DataType: NodeId

    :ivar ValueRank:

    :vartype ValueRank: Int32

    :ivar ArrayDimensions:

    :vartype ArrayDimensions: UInt32

    :ivar AccessLevel:

    :vartype AccessLevel: Byte

    :ivar UserAccessLevel:

    :vartype UserAccessLevel: Byte

    :ivar MinimumSamplingInterval:

    :vartype MinimumSamplingInterval: Double

    :ivar Historizing:

    :vartype Historizing: Boolean

    '''

    ua_types = [

        ('SpecifiedAttributes', 'UInt32'),

        ('DisplayName', 'LocalizedText'),

        ('Description', 'LocalizedText'),

        ('WriteMask', 'UInt32'),

        ('UserWriteMask', 'UInt32'),

        ('Value', 'Variant'),

        ('DataType', 'NodeId'),

        ('ValueRank', 'Int32'),

        ('ArrayDimensions', 'ListOfUInt32'),

        ('AccessLevel', 'Byte'),

        ('UserAccessLevel', 'Byte'),

        ('MinimumSamplingInterval', 'Double'),

        ('Historizing', 'Boolean'),

               ]

    def __init__(self):

        self.SpecifiedAttributes = 0

        self.DisplayName = LocalizedText()

    def __init__(self):

        self.PublishedData = []

        self._freeze = True

    def __str__(self):

        return 'PublishedDataItemsDataType(' + 'PublishedData:' + str(self.PublishedData) + ')'

    __repr__ = __str__

class PublishedEventsDataType(FrozenClass):

    '''

    :ivar EventNotifier:

    :vartype EventNotifier: NodeId

    :ivar SelectedFields:

    :vartype SelectedFields: SimpleAttributeOperand

    :ivar Filter:

    :vartype Filter: ContentFilter

    '''

    ua_types = [

        ('EventNotifier', 'NodeId'),

        ('SelectedFields', 'ListOfSimpleAttributeOperand'),

        ('Filter', 'ContentFilter'),

               ]

    def __init__(self):

        self.EventNotifier = NodeId()

        self.SelectedFields = []

        self.Filter = ContentFilter()

        self._freeze = True

    def __str__(self):

        ('SimpleDataTypes', 'ListOfSimpleTypeDescription'),

               ]

    def __init__(self):

        self.Namespaces = []

        self.StructureDataTypes = []

        self.EnumDataTypes = []

        self.SimpleDataTypes = []

        self._freeze = True

    def __str__(self):

        return 'DataTypeSchemaHeader(' + 'Namespaces:' + str(self.Namespaces) + ', ' + \

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

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

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

    __repr__ = __str__

class DataTypeDescription(FrozenClass):

    '''

    :ivar DataTypeId:

    :vartype DataTypeId: NodeId

    :ivar Name:

    :vartype Name: QualifiedName

    '''

    ua_types = [

        ('DataTypeId', 'NodeId'),

        ('Name', 'QualifiedName'),

               ]

    def __init__(self):

        self.DataTypeId = NodeId()