node-opcua-types 2.70.3 → 2.72.1

package/source/_generated_opcua_types.ts

@@ -1,4 +1,4 @@
-// --------- This code has been automatically generated !!! 2022-06-11T07:26:23.946Z
+// --------- This code has been automatically generated !!! 2022-07-12T11:52:31.681Z
 /**
  * @module node-opcua-types
  */
@@ -83,13 +83,6 @@ import {
     VariantOptions
 } from "node-opcua-variant";
 
-export class DataTypeDefinition extends BaseUAObject {
-    constructor(options: any) {
-        options = options; // do not remove
-        super();
-    }
-}
-
 // --------------------------------------------------------------------------------------------
 const schemaEUInformation = buildStructuredType({
     name: "EUInformation",
@@ -8423,19 +8416,69 @@ DataTypeDescription.schema.encodingDefaultBinary = DataTypeDescription.encodingD
 DataTypeDescription.schema.encodingDefaultXml = DataTypeDescription.encodingDefaultXml;
 DataTypeDescription.schema.encodingDefaultJson = DataTypeDescription.encodingDefaultJson;
 registerClassDefinition( DataTypeDescription.dataTypeNodeId, "DataTypeDescription", DataTypeDescription);
+// --------------------------------------------------------------------------------------------
+const schemaDataTypeDefinition = buildStructuredType({
+    name: "DataTypeDefinition",
+
+    baseType: "ExtensionObject",
+    fields: [
+    ]
+});
+export interface DataTypeDefinitionOptions {
+}
+export class DataTypeDefinition extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaDataTypeDefinition; }
+    public static possibleFields: string[] = [
+          
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(97, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(121, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(14797, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(15063, 0);
+
+    constructor(options?: DataTypeDefinitionOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+              return;
+        }
+        const schema = DataTypeDefinition.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as DataTypeDefinitionOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+    }
+    public get schema(): StructuredTypeSchema { return schemaDataTypeDefinition; }
+}
+DataTypeDefinition.schema.dataTypeNodeId = DataTypeDefinition.dataTypeNodeId;
+DataTypeDefinition.schema.encodingDefaultBinary = DataTypeDefinition.encodingDefaultBinary;
+DataTypeDefinition.schema.encodingDefaultXml = DataTypeDefinition.encodingDefaultXml;
+DataTypeDefinition.schema.encodingDefaultJson = DataTypeDefinition.encodingDefaultJson;
+registerClassDefinition( DataTypeDefinition.dataTypeNodeId, "DataTypeDefinition", DataTypeDefinition);
 
 // --------------------------------------------------------------------------------------------
 export enum StructureType {
     Structure = 0,
     StructureWithOptionalFields = 1,
     Union = 2,
+    StructureWithSubtypedValues = 3,
+    UnionWithSubtypedValues = 4,
     Invalid = 4294967295
 }
 const schemaStructureType = {
     enumValues: StructureType,
     flaggable: false,
     minValue: 0,
-    maxValue: 2,
+    maxValue: 4,
     name: "StructureType"
 };
 function decodeStructureType(stream: BinaryStream, _value?: StructureType): StructureType {
@@ -10966,6 +11009,198 @@ DatagramConnectionTransportDataType.schema.encodingDefaultXml = DatagramConnecti
 DatagramConnectionTransportDataType.schema.encodingDefaultJson = DatagramConnectionTransportDataType.encodingDefaultJson;
 registerClassDefinition( DatagramConnectionTransportDataType.dataTypeNodeId, "DatagramConnectionTransportDataType", DatagramConnectionTransportDataType);
 // --------------------------------------------------------------------------------------------
+const schemaDatagramConnectionTransport2DataType = buildStructuredType({
+    name: "DatagramConnectionTransport2DataType",
+
+    baseType: "DatagramConnectionTransportDataType",
+    fields: [
+        {
+            name: "discoveryAnnounceRate",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "discoveryMaxMessageSize",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "qosCategory",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "datagramQos",
+
+            fieldType: "ExtensionObject",
+            isArray: true
+        },
+    ]
+});
+export interface DatagramConnectionTransport2DataTypeOptions extends DatagramConnectionTransportDataTypeOptions {
+    discoveryAnnounceRate?: UInt32 ;
+    discoveryMaxMessageSize?: UInt32 ;
+    qosCategory?: UAString ;
+    datagramQos?: (ExtensionObject | null)[] | null;
+}
+export class DatagramConnectionTransport2DataType extends DatagramConnectionTransportDataType {
+    public static get schema(): StructuredTypeSchema { return schemaDatagramConnectionTransport2DataType; }
+    public static possibleFields: string[] = [
+          "discoveryAnnounceRate",
+           "discoveryMaxMessageSize",
+           "qosCategory",
+           "datagramQos"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23612, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23864, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23932, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24000, 0);
+    public discoveryAnnounceRate: UInt32;
+    public discoveryMaxMessageSize: UInt32;
+    public qosCategory: UAString;
+    public datagramQos: (ExtensionObject | null)[] | null;
+
+    constructor(options?: DatagramConnectionTransport2DataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.discoveryAnnounceRate = 0;
+            this.discoveryMaxMessageSize = 0;
+            this.qosCategory = null;
+            this.datagramQos = []
+              return;
+        }
+        const schema = DatagramConnectionTransport2DataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as DatagramConnectionTransport2DataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.discoveryAnnounceRate = initialize_field(schema.fields[0], options?.discoveryAnnounceRate);
+        this.discoveryMaxMessageSize = initialize_field(schema.fields[1], options?.discoveryMaxMessageSize);
+        this.qosCategory = initialize_field(schema.fields[2], options?.qosCategory);
+        this.datagramQos = initialize_field_array(schema.fields[3], options?.datagramQos);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUInt32(this.discoveryAnnounceRate, stream);
+        encodeUInt32(this.discoveryMaxMessageSize, stream);
+        encodeUAString(this.qosCategory, stream);
+        encodeArray(this.datagramQos, stream, encodeExtensionObject);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.discoveryAnnounceRate = decodeUInt32(stream, this.discoveryAnnounceRate);
+        this.discoveryMaxMessageSize = decodeUInt32(stream, this.discoveryMaxMessageSize);
+        this.qosCategory = decodeUAString(stream, this.qosCategory);
+        this.datagramQos = decodeArray(stream, decodeExtensionObject);
+    }
+    public get schema(): StructuredTypeSchema { return schemaDatagramConnectionTransport2DataType; }
+}
+DatagramConnectionTransport2DataType.schema.dataTypeNodeId = DatagramConnectionTransport2DataType.dataTypeNodeId;
+DatagramConnectionTransport2DataType.schema.encodingDefaultBinary = DatagramConnectionTransport2DataType.encodingDefaultBinary;
+DatagramConnectionTransport2DataType.schema.encodingDefaultXml = DatagramConnectionTransport2DataType.encodingDefaultXml;
+DatagramConnectionTransport2DataType.schema.encodingDefaultJson = DatagramConnectionTransport2DataType.encodingDefaultJson;
+registerClassDefinition( DatagramConnectionTransport2DataType.dataTypeNodeId, "DatagramConnectionTransport2DataType", DatagramConnectionTransport2DataType);
+// --------------------------------------------------------------------------------------------
+const schemaDatagramDataSetReaderTransportDataType = buildStructuredType({
+    name: "DatagramDataSetReaderTransportDataType",
+
+    baseType: "DataSetReaderTransportDataType",
+    fields: [
+        {
+            name: "address",
+
+            fieldType: "ExtensionObject",
+        },
+        {
+            name: "qosCategory",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "datagramQos",
+
+            fieldType: "ExtensionObject",
+            isArray: true
+        },
+        {
+            name: "topic",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface DatagramDataSetReaderTransportDataTypeOptions extends DataSetReaderTransportDataTypeOptions {
+    address?: (ExtensionObject | null);
+    qosCategory?: UAString ;
+    datagramQos?: (ExtensionObject | null)[] | null;
+    topic?: UAString ;
+}
+export class DatagramDataSetReaderTransportDataType extends DataSetReaderTransportDataType {
+    public static get schema(): StructuredTypeSchema { return schemaDatagramDataSetReaderTransportDataType; }
+    public static possibleFields: string[] = [
+          "address",
+           "qosCategory",
+           "datagramQos",
+           "topic"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23614, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23866, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23934, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24002, 0);
+    public address: (ExtensionObject | null);
+    public qosCategory: UAString;
+    public datagramQos: (ExtensionObject | null)[] | null;
+    public topic: UAString;
+
+    constructor(options?: DatagramDataSetReaderTransportDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.address = null;
+            this.qosCategory = null;
+            this.datagramQos = []
+            this.topic = null;
+              return;
+        }
+        const schema = DatagramDataSetReaderTransportDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as DatagramDataSetReaderTransportDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.address = initialize_field(schema.fields[0], options?.address);
+        this.qosCategory = initialize_field(schema.fields[1], options?.qosCategory);
+        this.datagramQos = initialize_field_array(schema.fields[2], options?.datagramQos);
+        this.topic = initialize_field(schema.fields[3], options?.topic);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeExtensionObject(this.address, stream);
+        encodeUAString(this.qosCategory, stream);
+        encodeArray(this.datagramQos, stream, encodeExtensionObject);
+        encodeUAString(this.topic, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.address = decodeExtensionObject(stream, this.address);
+        this.qosCategory = decodeUAString(stream, this.qosCategory);
+        this.datagramQos = decodeArray(stream, decodeExtensionObject);
+        this.topic = decodeUAString(stream, this.topic);
+    }
+    public get schema(): StructuredTypeSchema { return schemaDatagramDataSetReaderTransportDataType; }
+}
+DatagramDataSetReaderTransportDataType.schema.dataTypeNodeId = DatagramDataSetReaderTransportDataType.dataTypeNodeId;
+DatagramDataSetReaderTransportDataType.schema.encodingDefaultBinary = DatagramDataSetReaderTransportDataType.encodingDefaultBinary;
+DatagramDataSetReaderTransportDataType.schema.encodingDefaultXml = DatagramDataSetReaderTransportDataType.encodingDefaultXml;
+DatagramDataSetReaderTransportDataType.schema.encodingDefaultJson = DatagramDataSetReaderTransportDataType.encodingDefaultJson;
+registerClassDefinition( DatagramDataSetReaderTransportDataType.dataTypeNodeId, "DatagramDataSetReaderTransportDataType", DatagramDataSetReaderTransportDataType);
+// --------------------------------------------------------------------------------------------
 const schemaDatagramWriterGroupTransportDataType = buildStructuredType({
     name: "DatagramWriterGroupTransportDataType",
 
@@ -11037,6 +11272,114 @@ DatagramWriterGroupTransportDataType.schema.encodingDefaultXml = DatagramWriterG
 DatagramWriterGroupTransportDataType.schema.encodingDefaultJson = DatagramWriterGroupTransportDataType.encodingDefaultJson;
 registerClassDefinition( DatagramWriterGroupTransportDataType.dataTypeNodeId, "DatagramWriterGroupTransportDataType", DatagramWriterGroupTransportDataType);
 // --------------------------------------------------------------------------------------------
+const schemaDatagramWriterGroupTransport2DataType = buildStructuredType({
+    name: "DatagramWriterGroupTransport2DataType",
+
+    baseType: "DatagramWriterGroupTransportDataType",
+    fields: [
+        {
+            name: "address",
+
+            fieldType: "ExtensionObject",
+        },
+        {
+            name: "qosCategory",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "datagramQos",
+
+            fieldType: "ExtensionObject",
+            isArray: true
+        },
+        {
+            name: "discoveryAnnounceRate",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "topic",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface DatagramWriterGroupTransport2DataTypeOptions extends DatagramWriterGroupTransportDataTypeOptions {
+    address?: (ExtensionObject | null);
+    qosCategory?: UAString ;
+    datagramQos?: (ExtensionObject | null)[] | null;
+    discoveryAnnounceRate?: UInt32 ;
+    topic?: UAString ;
+}
+export class DatagramWriterGroupTransport2DataType extends DatagramWriterGroupTransportDataType {
+    public static get schema(): StructuredTypeSchema { return schemaDatagramWriterGroupTransport2DataType; }
+    public static possibleFields: string[] = [
+          "address",
+           "qosCategory",
+           "datagramQos",
+           "discoveryAnnounceRate",
+           "topic"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23613, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23865, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23933, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24001, 0);
+    public address: (ExtensionObject | null);
+    public qosCategory: UAString;
+    public datagramQos: (ExtensionObject | null)[] | null;
+    public discoveryAnnounceRate: UInt32;
+    public topic: UAString;
+
+    constructor(options?: DatagramWriterGroupTransport2DataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.address = null;
+            this.qosCategory = null;
+            this.datagramQos = []
+            this.discoveryAnnounceRate = 0;
+            this.topic = null;
+              return;
+        }
+        const schema = DatagramWriterGroupTransport2DataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as DatagramWriterGroupTransport2DataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.address = initialize_field(schema.fields[0], options?.address);
+        this.qosCategory = initialize_field(schema.fields[1], options?.qosCategory);
+        this.datagramQos = initialize_field_array(schema.fields[2], options?.datagramQos);
+        this.discoveryAnnounceRate = initialize_field(schema.fields[3], options?.discoveryAnnounceRate);
+        this.topic = initialize_field(schema.fields[4], options?.topic);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeExtensionObject(this.address, stream);
+        encodeUAString(this.qosCategory, stream);
+        encodeArray(this.datagramQos, stream, encodeExtensionObject);
+        encodeUInt32(this.discoveryAnnounceRate, stream);
+        encodeUAString(this.topic, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.address = decodeExtensionObject(stream, this.address);
+        this.qosCategory = decodeUAString(stream, this.qosCategory);
+        this.datagramQos = decodeArray(stream, decodeExtensionObject);
+        this.discoveryAnnounceRate = decodeUInt32(stream, this.discoveryAnnounceRate);
+        this.topic = decodeUAString(stream, this.topic);
+    }
+    public get schema(): StructuredTypeSchema { return schemaDatagramWriterGroupTransport2DataType; }
+}
+DatagramWriterGroupTransport2DataType.schema.dataTypeNodeId = DatagramWriterGroupTransport2DataType.dataTypeNodeId;
+DatagramWriterGroupTransport2DataType.schema.encodingDefaultBinary = DatagramWriterGroupTransport2DataType.encodingDefaultBinary;
+DatagramWriterGroupTransport2DataType.schema.encodingDefaultXml = DatagramWriterGroupTransport2DataType.encodingDefaultXml;
+DatagramWriterGroupTransport2DataType.schema.encodingDefaultJson = DatagramWriterGroupTransport2DataType.encodingDefaultJson;
+registerClassDefinition( DatagramWriterGroupTransport2DataType.dataTypeNodeId, "DatagramWriterGroupTransport2DataType", DatagramWriterGroupTransport2DataType);
+// --------------------------------------------------------------------------------------------
 const schemaDecimalDataType = buildStructuredType({
     name: "DecimalDataType",
 
@@ -15151,13 +15494,15 @@ export enum IdentityCriteriaType {
     GroupId = 4,
     Anonymous = 5,
     AuthenticatedUser = 6,
+    Application = 7,
+    X509Subject = 8,
     Invalid = 4294967295
 }
 const schemaIdentityCriteriaType = {
     enumValues: IdentityCriteriaType,
     flaggable: false,
-    minValue: 1,
-    maxValue: 6,
+    minValue: NaN,
+    maxValue: NaN,
     name: "IdentityCriteriaType"
 };
 function decodeIdentityCriteriaType(stream: BinaryStream, _value?: IdentityCriteriaType): IdentityCriteriaType {
@@ -15403,7 +15748,10 @@ export enum JsonDataSetMessageContentMask {
     MetaDataVersion = 2,
     SequenceNumber = 4,
     Timestamp = 8,
-    Status = 16
+    Status = 16,
+    MessageType = 32,
+    DataSetWriterName = 64,
+    ReversibleFieldEncoding = 128
 }
 const schemaJsonDataSetMessageContentMask = {
     enumValues: JsonDataSetMessageContentMask,
@@ -18094,103 +18442,269 @@ ParsingResult.schema.encodingDefaultXml = ParsingResult.encodingDefaultXml;
 ParsingResult.schema.encodingDefaultJson = ParsingResult.encodingDefaultJson;
 registerClassDefinition( ParsingResult.dataTypeNodeId, "ParsingResult", ParsingResult);
 // --------------------------------------------------------------------------------------------
-const schemaStatusResult = buildStructuredType({
-    name: "StatusResult",
+const schemaPortableNodeId = buildStructuredType({
+    name: "PortableNodeId",
 
     baseType: "ExtensionObject",
     fields: [
         {
-            name: "statusCode",
+            name: "namespaceUri",
 
-            fieldType: "StatusCode",
+            fieldType: "UAString",
         },
         {
-            name: "diagnosticInfo",
+            name: "identifier",
 
-            fieldType: "DiagnosticInfo",
+            fieldType: "NodeId",
         },
     ]
 });
-export interface StatusResultOptions {
-    statusCode?: StatusCode ;
-    diagnosticInfo?: (DiagnosticInfo | null);
+export interface PortableNodeIdOptions {
+    namespaceUri?: UAString ;
+    identifier?: (NodeIdLike | null);
 }
-export class StatusResult extends ExtensionObject {
-    public static get schema(): StructuredTypeSchema { return schemaStatusResult; }
+export class PortableNodeId extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPortableNodeId; }
     public static possibleFields: string[] = [
-          "statusCode",
-           "diagnosticInfo"
+          "namespaceUri",
+           "identifier"
     ];
-    public static dataTypeNodeId = makeExpandedNodeId(299, 0);
-    public static encodingDefaultBinary = makeExpandedNodeId(301, 0);
-    public static encodingDefaultXml = makeExpandedNodeId(300, 0);
-    public static encodingDefaultJson = makeExpandedNodeId(15371, 0);
-    public statusCode: StatusCode;
-    public diagnosticInfo: (DiagnosticInfo | null);
+    public static dataTypeNodeId = makeExpandedNodeId(24106, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(24109, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(24121, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24133, 0);
+    public namespaceUri: UAString;
+    public identifier: NodeId;
 
-    constructor(options?: StatusResultOptions | null) {
+    constructor(options?: PortableNodeIdOptions | null) {
 
         super(options);
 
         if (options === null) {
-            this.statusCode = StatusCodes.Good;
-            this.diagnosticInfo = null;
+            this.namespaceUri = null;
+            this.identifier = new NodeId(null);
               return;
         }
-        const schema = StatusResult.schema;
-        options = (schema.constructHook ? schema.constructHook(options) as StatusResultOptions: options ) || {};
+        const schema = PortableNodeId.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PortableNodeIdOptions: options ) || {};
         /* istanbul ignore next */
         if (parameters.debugSchemaHelper) {
             check_options_correctness_against_schema(this, schema, options);
         }
-        this.statusCode = initialize_field(schema.fields[0], options?.statusCode);
-        this.diagnosticInfo = initialize_field(schema.fields[1], options?.diagnosticInfo);
+        this.namespaceUri = initialize_field(schema.fields[0], options?.namespaceUri);
+        this.identifier = initialize_field(schema.fields[1], options?.identifier);
     }
      public encode(stream: OutputBinaryStream): void {
         /* NEEDED */ super.encode(stream);
-        encodeStatusCode(this.statusCode, stream);
-        encodeDiagnosticInfo(this.diagnosticInfo, stream);
+        encodeUAString(this.namespaceUri, stream);
+        encodeNodeId(this.identifier, stream);
     }
     public decode(stream: BinaryStream): void {
         // call base class implementation first
         /* NEEDED !!! */ super.decode(stream);
-        this.statusCode = decodeStatusCode(stream, this.statusCode);
-        this.diagnosticInfo = decodeDiagnosticInfo(stream, this.diagnosticInfo);
+        this.namespaceUri = decodeUAString(stream, this.namespaceUri);
+        this.identifier = decodeNodeId(stream, this.identifier);
     }
-    public get schema(): StructuredTypeSchema { return schemaStatusResult; }
+    public get schema(): StructuredTypeSchema { return schemaPortableNodeId; }
 }
-StatusResult.schema.dataTypeNodeId = StatusResult.dataTypeNodeId;
-StatusResult.schema.encodingDefaultBinary = StatusResult.encodingDefaultBinary;
-StatusResult.schema.encodingDefaultXml = StatusResult.encodingDefaultXml;
-StatusResult.schema.encodingDefaultJson = StatusResult.encodingDefaultJson;
-registerClassDefinition( StatusResult.dataTypeNodeId, "StatusResult", StatusResult);
+PortableNodeId.schema.dataTypeNodeId = PortableNodeId.dataTypeNodeId;
+PortableNodeId.schema.encodingDefaultBinary = PortableNodeId.encodingDefaultBinary;
+PortableNodeId.schema.encodingDefaultXml = PortableNodeId.encodingDefaultXml;
+PortableNodeId.schema.encodingDefaultJson = PortableNodeId.encodingDefaultJson;
+registerClassDefinition( PortableNodeId.dataTypeNodeId, "PortableNodeId", PortableNodeId);
 // --------------------------------------------------------------------------------------------
-const schemaProgramDiagnostic2DataType = buildStructuredType({
-    name: "ProgramDiagnostic2DataType",
+const schemaPortableQualifiedName = buildStructuredType({
+    name: "PortableQualifiedName",
 
     baseType: "ExtensionObject",
     fields: [
         {
-            name: "createSessionId",
+            name: "namespaceUri",
 
-            fieldType: "NodeId",
+            fieldType: "UAString",
         },
         {
-            name: "createClientName",
+            name: "name",
 
             fieldType: "UAString",
         },
-        {
-            name: "invocationCreationTime",
+    ]
+});
+export interface PortableQualifiedNameOptions {
+    namespaceUri?: UAString ;
+    name?: UAString ;
+}
+export class PortableQualifiedName extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPortableQualifiedName; }
+    public static possibleFields: string[] = [
+          "namespaceUri",
+           "name"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(24105, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(24108, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(24120, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24132, 0);
+    public namespaceUri: UAString;
+    public name: UAString;
 
-            fieldType: "DateTime",
-        },
-        {
-            name: "lastTransitionTime",
+    constructor(options?: PortableQualifiedNameOptions | null) {
 
-            fieldType: "DateTime",
-        },
-        {
+        super(options);
+
+        if (options === null) {
+            this.namespaceUri = null;
+            this.name = null;
+              return;
+        }
+        const schema = PortableQualifiedName.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PortableQualifiedNameOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.namespaceUri = initialize_field(schema.fields[0], options?.namespaceUri);
+        this.name = initialize_field(schema.fields[1], options?.name);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.namespaceUri, stream);
+        encodeUAString(this.name, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.namespaceUri = decodeUAString(stream, this.namespaceUri);
+        this.name = decodeUAString(stream, this.name);
+    }
+    public get schema(): StructuredTypeSchema { return schemaPortableQualifiedName; }
+}
+PortableQualifiedName.schema.dataTypeNodeId = PortableQualifiedName.dataTypeNodeId;
+PortableQualifiedName.schema.encodingDefaultBinary = PortableQualifiedName.encodingDefaultBinary;
+PortableQualifiedName.schema.encodingDefaultXml = PortableQualifiedName.encodingDefaultXml;
+PortableQualifiedName.schema.encodingDefaultJson = PortableQualifiedName.encodingDefaultJson;
+registerClassDefinition( PortableQualifiedName.dataTypeNodeId, "PortableQualifiedName", PortableQualifiedName);
+// --------------------------------------------------------------------------------------------
+const schemaPriorityMappingEntryType = buildStructuredType({
+    name: "PriorityMappingEntryType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "mappingUri",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "priorityLabel",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "priorityValue_PCP",
+
+            fieldType: "Byte",
+        },
+        {
+            name: "priorityValue_DSCP",
+
+            fieldType: "UInt32",
+        },
+    ]
+});
+export interface PriorityMappingEntryTypeOptions {
+    mappingUri?: UAString ;
+    priorityLabel?: UAString ;
+    priorityValue_PCP?: Byte ;
+    priorityValue_DSCP?: UInt32 ;
+}
+export class PriorityMappingEntryType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPriorityMappingEntryType; }
+    public static possibleFields: string[] = [
+          "mappingUri",
+           "priorityLabel",
+           "priorityValue_PCP",
+           "priorityValue_DSCP"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(25220, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(25239, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(25243, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(25247, 0);
+    public mappingUri: UAString;
+    public priorityLabel: UAString;
+    public priorityValue_PCP: Byte;
+    public priorityValue_DSCP: UInt32;
+
+    constructor(options?: PriorityMappingEntryTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.mappingUri = null;
+            this.priorityLabel = null;
+            this.priorityValue_PCP = 0;
+            this.priorityValue_DSCP = 0;
+              return;
+        }
+        const schema = PriorityMappingEntryType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PriorityMappingEntryTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.mappingUri = initialize_field(schema.fields[0], options?.mappingUri);
+        this.priorityLabel = initialize_field(schema.fields[1], options?.priorityLabel);
+        this.priorityValue_PCP = initialize_field(schema.fields[2], options?.priorityValue_PCP);
+        this.priorityValue_DSCP = initialize_field(schema.fields[3], options?.priorityValue_DSCP);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.mappingUri, stream);
+        encodeUAString(this.priorityLabel, stream);
+        encodeByte(this.priorityValue_PCP, stream);
+        encodeUInt32(this.priorityValue_DSCP, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.mappingUri = decodeUAString(stream, this.mappingUri);
+        this.priorityLabel = decodeUAString(stream, this.priorityLabel);
+        this.priorityValue_PCP = decodeByte(stream, this.priorityValue_PCP);
+        this.priorityValue_DSCP = decodeUInt32(stream, this.priorityValue_DSCP);
+    }
+    public get schema(): StructuredTypeSchema { return schemaPriorityMappingEntryType; }
+}
+PriorityMappingEntryType.schema.dataTypeNodeId = PriorityMappingEntryType.dataTypeNodeId;
+PriorityMappingEntryType.schema.encodingDefaultBinary = PriorityMappingEntryType.encodingDefaultBinary;
+PriorityMappingEntryType.schema.encodingDefaultXml = PriorityMappingEntryType.encodingDefaultXml;
+PriorityMappingEntryType.schema.encodingDefaultJson = PriorityMappingEntryType.encodingDefaultJson;
+registerClassDefinition( PriorityMappingEntryType.dataTypeNodeId, "PriorityMappingEntryType", PriorityMappingEntryType);
+// --------------------------------------------------------------------------------------------
+const schemaProgramDiagnostic2DataType = buildStructuredType({
+    name: "ProgramDiagnostic2DataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "createSessionId",
+
+            fieldType: "NodeId",
+        },
+        {
+            name: "createClientName",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "invocationCreationTime",
+
+            fieldType: "DateTime",
+        },
+        {
+            name: "lastTransitionTime",
+
+            fieldType: "DateTime",
+        },
+        {
             name: "lastMethodCall",
 
             fieldType: "UAString",
@@ -18232,7 +18746,7 @@ const schemaProgramDiagnostic2DataType = buildStructuredType({
         {
             name: "lastMethodReturnStatus",
 
-            fieldType: "StatusResult",
+            fieldType: "StatusCode",
         },
     ]
 });
@@ -18248,7 +18762,7 @@ export interface ProgramDiagnostic2DataTypeOptions {
     lastMethodInputValues?: (VariantLike | null)[] | null;
     lastMethodOutputValues?: (VariantLike | null)[] | null;
     lastMethodCallTime?: DateTime ;
-    lastMethodReturnStatus?: StatusResultOptions ;
+    lastMethodReturnStatus?: StatusCode ;
 }
 export class ProgramDiagnostic2DataType extends ExtensionObject {
     public static get schema(): StructuredTypeSchema { return schemaProgramDiagnostic2DataType; }
@@ -18281,7 +18795,7 @@ export class ProgramDiagnostic2DataType extends ExtensionObject {
     public lastMethodInputValues: Variant[] | null;
     public lastMethodOutputValues: Variant[] | null;
     public lastMethodCallTime: DateTime;
-    public lastMethodReturnStatus: StatusResult;
+    public lastMethodReturnStatus: StatusCode;
 
     constructor(options?: ProgramDiagnostic2DataTypeOptions | null) {
 
@@ -18299,7 +18813,7 @@ export class ProgramDiagnostic2DataType extends ExtensionObject {
             this.lastMethodInputValues = []
             this.lastMethodOutputValues = []
             this.lastMethodCallTime = new Date();
-         this.lastMethodReturnStatus =  new StatusResult(null);
+            this.lastMethodReturnStatus = StatusCodes.Good;
               return;
         }
         const schema = ProgramDiagnostic2DataType.schema;
@@ -18327,7 +18841,7 @@ export class ProgramDiagnostic2DataType extends ExtensionObject {
         this.lastMethodInputValues = initialize_field_array(schema.fields[8], options?.lastMethodInputValues);
         this.lastMethodOutputValues = initialize_field_array(schema.fields[9], options?.lastMethodOutputValues);
         this.lastMethodCallTime = initialize_field(schema.fields[10], options?.lastMethodCallTime);
-        this.lastMethodReturnStatus  =  new StatusResult(options.lastMethodReturnStatus);
+        this.lastMethodReturnStatus = initialize_field(schema.fields[11], options?.lastMethodReturnStatus);
     }
      public encode(stream: OutputBinaryStream): void {
         /* NEEDED */ super.encode(stream);
@@ -18342,7 +18856,7 @@ export class ProgramDiagnostic2DataType extends ExtensionObject {
         encodeArray(this.lastMethodInputValues, stream, encodeVariant);
         encodeArray(this.lastMethodOutputValues, stream, encodeVariant);
         encodeDateTime(this.lastMethodCallTime, stream);
-        this.lastMethodReturnStatus.encode(stream);
+        encodeStatusCode(this.lastMethodReturnStatus, stream);
     }
     public decode(stream: BinaryStream): void {
         // call base class implementation first
@@ -18366,7 +18880,7 @@ export class ProgramDiagnostic2DataType extends ExtensionObject {
         this.lastMethodInputValues = decodeArray(stream, decodeVariant);
         this.lastMethodOutputValues = decodeArray(stream, decodeVariant);
         this.lastMethodCallTime = decodeDateTime(stream, this.lastMethodCallTime);
-        this.lastMethodReturnStatus.decode(stream);
+        this.lastMethodReturnStatus = decodeStatusCode(stream, this.lastMethodReturnStatus);
     }
     public get schema(): StructuredTypeSchema { return schemaProgramDiagnostic2DataType; }
 }
@@ -18376,6 +18890,77 @@ ProgramDiagnostic2DataType.schema.encodingDefaultXml = ProgramDiagnostic2DataTyp
 ProgramDiagnostic2DataType.schema.encodingDefaultJson = ProgramDiagnostic2DataType.encodingDefaultJson;
 registerClassDefinition( ProgramDiagnostic2DataType.dataTypeNodeId, "ProgramDiagnostic2DataType", ProgramDiagnostic2DataType);
 // --------------------------------------------------------------------------------------------
+const schemaStatusResult = buildStructuredType({
+    name: "StatusResult",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "statusCode",
+
+            fieldType: "StatusCode",
+        },
+        {
+            name: "diagnosticInfo",
+
+            fieldType: "DiagnosticInfo",
+        },
+    ]
+});
+export interface StatusResultOptions {
+    statusCode?: StatusCode ;
+    diagnosticInfo?: (DiagnosticInfo | null);
+}
+export class StatusResult extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaStatusResult; }
+    public static possibleFields: string[] = [
+          "statusCode",
+           "diagnosticInfo"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(299, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(301, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(300, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(15371, 0);
+    public statusCode: StatusCode;
+    public diagnosticInfo: (DiagnosticInfo | null);
+
+    constructor(options?: StatusResultOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.statusCode = StatusCodes.Good;
+            this.diagnosticInfo = null;
+              return;
+        }
+        const schema = StatusResult.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as StatusResultOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.statusCode = initialize_field(schema.fields[0], options?.statusCode);
+        this.diagnosticInfo = initialize_field(schema.fields[1], options?.diagnosticInfo);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeStatusCode(this.statusCode, stream);
+        encodeDiagnosticInfo(this.diagnosticInfo, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.statusCode = decodeStatusCode(stream, this.statusCode);
+        this.diagnosticInfo = decodeDiagnosticInfo(stream, this.diagnosticInfo);
+    }
+    public get schema(): StructuredTypeSchema { return schemaStatusResult; }
+}
+StatusResult.schema.dataTypeNodeId = StatusResult.dataTypeNodeId;
+StatusResult.schema.encodingDefaultBinary = StatusResult.encodingDefaultBinary;
+StatusResult.schema.encodingDefaultXml = StatusResult.encodingDefaultXml;
+StatusResult.schema.encodingDefaultJson = StatusResult.encodingDefaultJson;
+registerClassDefinition( StatusResult.dataTypeNodeId, "StatusResult", StatusResult);
+// --------------------------------------------------------------------------------------------
 const schemaProgramDiagnosticDataType = buildStructuredType({
     name: "ProgramDiagnosticDataType",
 
@@ -19289,94 +19874,983 @@ const schemaPubSubConfigurationDataType = buildStructuredType({
             isArray: true
         },
         {
-            name: "connections",
+            name: "connections",
+
+            fieldType: "PubSubConnectionDataType",
+            isArray: true
+        },
+        {
+            name: "enabled",
+
+            fieldType: "UABoolean",
+        },
+    ]
+});
+export interface PubSubConfigurationDataTypeOptions {
+    publishedDataSets?: PublishedDataSetDataTypeOptions [] | null;
+    connections?: PubSubConnectionDataTypeOptions [] | null;
+    enabled?: UABoolean ;
+}
+export class PubSubConfigurationDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPubSubConfigurationDataType; }
+    public static possibleFields: string[] = [
+          "publishedDataSets",
+           "connections",
+           "enabled"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(15530, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(21154, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(21178, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(21202, 0);
+    public publishedDataSets: PublishedDataSetDataType[] | null;
+    public connections: PubSubConnectionDataType[] | null;
+    public enabled: UABoolean;
+
+    constructor(options?: PubSubConfigurationDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+         this.publishedDataSets =  null; /* null array */
+         this.connections =  null; /* null array */
+            this.enabled = false;
+              return;
+        }
+        const schema = PubSubConfigurationDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PubSubConfigurationDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.publishedDataSets = []; // should default
+        if (options.publishedDataSets) {
+            assert(Array.isArray(options.publishedDataSets));
+            this.publishedDataSets = options.publishedDataSets.map((e: any) => new PublishedDataSetDataType(e));
+        }
+        this.connections = []; // should default
+        if (options.connections) {
+            assert(Array.isArray(options.connections));
+            this.connections = options.connections.map((e: any) => new PubSubConnectionDataType(e));
+        }
+        this.enabled = initialize_field(schema.fields[2], options?.enabled);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeArray(this.publishedDataSets, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.connections, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeUABoolean(this.enabled, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.publishedDataSets = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new PublishedDataSetDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.connections = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new PubSubConnectionDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.enabled = decodeUABoolean(stream, this.enabled);
+    }
+    public get schema(): StructuredTypeSchema { return schemaPubSubConfigurationDataType; }
+}
+PubSubConfigurationDataType.schema.dataTypeNodeId = PubSubConfigurationDataType.dataTypeNodeId;
+PubSubConfigurationDataType.schema.encodingDefaultBinary = PubSubConfigurationDataType.encodingDefaultBinary;
+PubSubConfigurationDataType.schema.encodingDefaultXml = PubSubConfigurationDataType.encodingDefaultXml;
+PubSubConfigurationDataType.schema.encodingDefaultJson = PubSubConfigurationDataType.encodingDefaultJson;
+registerClassDefinition( PubSubConfigurationDataType.dataTypeNodeId, "PubSubConfigurationDataType", PubSubConfigurationDataType);
+// --------------------------------------------------------------------------------------------
+const schemaSubscribedDataSetDataType = buildStructuredType({
+    name: "SubscribedDataSetDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+    ]
+});
+export interface SubscribedDataSetDataTypeOptions {
+}
+export class SubscribedDataSetDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaSubscribedDataSetDataType; }
+    public static possibleFields: string[] = [
+          
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(15630, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(15707, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(16010, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(16308, 0);
+
+    constructor(options?: SubscribedDataSetDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+              return;
+        }
+        const schema = SubscribedDataSetDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as SubscribedDataSetDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+    }
+    public get schema(): StructuredTypeSchema { return schemaSubscribedDataSetDataType; }
+}
+SubscribedDataSetDataType.schema.dataTypeNodeId = SubscribedDataSetDataType.dataTypeNodeId;
+SubscribedDataSetDataType.schema.encodingDefaultBinary = SubscribedDataSetDataType.encodingDefaultBinary;
+SubscribedDataSetDataType.schema.encodingDefaultXml = SubscribedDataSetDataType.encodingDefaultXml;
+SubscribedDataSetDataType.schema.encodingDefaultJson = SubscribedDataSetDataType.encodingDefaultJson;
+registerClassDefinition( SubscribedDataSetDataType.dataTypeNodeId, "SubscribedDataSetDataType", SubscribedDataSetDataType);
+// --------------------------------------------------------------------------------------------
+const schemaStandaloneSubscribedDataSetDataType = buildStructuredType({
+    name: "StandaloneSubscribedDataSetDataType",
+
+    baseType: "SubscribedDataSetDataType",
+    fields: [
+        {
+            name: "name",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "dataSetFolder",
+
+            fieldType: "UAString",
+            isArray: true
+        },
+        {
+            name: "dataSetMetaData",
+
+            fieldType: "DataSetMetaDataType",
+        },
+        {
+            name: "subscribedDataSet",
+
+            fieldType: "ExtensionObject",
+        },
+    ]
+});
+export interface StandaloneSubscribedDataSetDataTypeOptions extends SubscribedDataSetDataTypeOptions {
+    name?: UAString ;
+    dataSetFolder?: UAString [] | null;
+    dataSetMetaData?: DataSetMetaDataTypeOptions ;
+    subscribedDataSet?: (ExtensionObject | null);
+}
+export class StandaloneSubscribedDataSetDataType extends SubscribedDataSetDataType {
+    public static get schema(): StructuredTypeSchema { return schemaStandaloneSubscribedDataSetDataType; }
+    public static possibleFields: string[] = [
+          "name",
+           "dataSetFolder",
+           "dataSetMetaData",
+           "subscribedDataSet"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23600, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23852, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23920, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23988, 0);
+    public name: UAString;
+    public dataSetFolder: UAString[] | null;
+    public dataSetMetaData: DataSetMetaDataType;
+    public subscribedDataSet: (ExtensionObject | null);
+
+    constructor(options?: StandaloneSubscribedDataSetDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.name = null;
+            this.dataSetFolder = []
+         this.dataSetMetaData =  new DataSetMetaDataType(null);
+            this.subscribedDataSet = null;
+              return;
+        }
+        const schema = StandaloneSubscribedDataSetDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as StandaloneSubscribedDataSetDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.name = initialize_field(schema.fields[0], options?.name);
+        this.dataSetFolder = initialize_field_array(schema.fields[1], options?.dataSetFolder);
+        this.dataSetMetaData  =  new DataSetMetaDataType(options.dataSetMetaData);
+        this.subscribedDataSet = initialize_field(schema.fields[3], options?.subscribedDataSet);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.name, stream);
+        encodeArray(this.dataSetFolder, stream, encodeUAString);
+        this.dataSetMetaData.encode(stream);
+        encodeExtensionObject(this.subscribedDataSet, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.name = decodeUAString(stream, this.name);
+        this.dataSetFolder = decodeArray(stream, decodeUAString);
+        this.dataSetMetaData.decode(stream);
+        this.subscribedDataSet = decodeExtensionObject(stream, this.subscribedDataSet);
+    }
+    public get schema(): StructuredTypeSchema { return schemaStandaloneSubscribedDataSetDataType; }
+}
+StandaloneSubscribedDataSetDataType.schema.dataTypeNodeId = StandaloneSubscribedDataSetDataType.dataTypeNodeId;
+StandaloneSubscribedDataSetDataType.schema.encodingDefaultBinary = StandaloneSubscribedDataSetDataType.encodingDefaultBinary;
+StandaloneSubscribedDataSetDataType.schema.encodingDefaultXml = StandaloneSubscribedDataSetDataType.encodingDefaultXml;
+StandaloneSubscribedDataSetDataType.schema.encodingDefaultJson = StandaloneSubscribedDataSetDataType.encodingDefaultJson;
+registerClassDefinition( StandaloneSubscribedDataSetDataType.dataTypeNodeId, "StandaloneSubscribedDataSetDataType", StandaloneSubscribedDataSetDataType);
+// --------------------------------------------------------------------------------------------
+const schemaSecurityGroupDataType = buildStructuredType({
+    name: "SecurityGroupDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "name",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "securityGroupFolder",
+
+            fieldType: "UAString",
+            isArray: true
+        },
+        {
+            name: "keyLifetime",
+
+            fieldType: "Double",
+        },
+        {
+            name: "securityPolicyUri",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "maxFutureKeyCount",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "maxPastKeyCount",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "securityGroupId",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "rolePermissions",
+
+            fieldType: "RolePermissionType",
+            isArray: true
+        },
+        {
+            name: "groupProperties",
+
+            fieldType: "KeyValuePair",
+            isArray: true
+        },
+    ]
+});
+export interface SecurityGroupDataTypeOptions {
+    name?: UAString ;
+    securityGroupFolder?: UAString [] | null;
+    keyLifetime?: Double ;
+    securityPolicyUri?: UAString ;
+    maxFutureKeyCount?: UInt32 ;
+    maxPastKeyCount?: UInt32 ;
+    securityGroupId?: UAString ;
+    rolePermissions?: RolePermissionTypeOptions [] | null;
+    groupProperties?: KeyValuePairOptions [] | null;
+}
+export class SecurityGroupDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaSecurityGroupDataType; }
+    public static possibleFields: string[] = [
+          "name",
+           "securityGroupFolder",
+           "keyLifetime",
+           "securityPolicyUri",
+           "maxFutureKeyCount",
+           "maxPastKeyCount",
+           "securityGroupId",
+           "rolePermissions",
+           "groupProperties"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23601, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23853, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23921, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23989, 0);
+    public name: UAString;
+    public securityGroupFolder: UAString[] | null;
+    public keyLifetime: Double;
+    public securityPolicyUri: UAString;
+    public maxFutureKeyCount: UInt32;
+    public maxPastKeyCount: UInt32;
+    public securityGroupId: UAString;
+    public rolePermissions: RolePermissionType[] | null;
+    public groupProperties: KeyValuePair[] | null;
+
+    constructor(options?: SecurityGroupDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.name = null;
+            this.securityGroupFolder = []
+            this.keyLifetime = 0;
+            this.securityPolicyUri = null;
+            this.maxFutureKeyCount = 0;
+            this.maxPastKeyCount = 0;
+            this.securityGroupId = null;
+         this.rolePermissions =  null; /* null array */
+         this.groupProperties =  null; /* null array */
+              return;
+        }
+        const schema = SecurityGroupDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as SecurityGroupDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.name = initialize_field(schema.fields[0], options?.name);
+        this.securityGroupFolder = initialize_field_array(schema.fields[1], options?.securityGroupFolder);
+        this.keyLifetime = initialize_field(schema.fields[2], options?.keyLifetime);
+        this.securityPolicyUri = initialize_field(schema.fields[3], options?.securityPolicyUri);
+        this.maxFutureKeyCount = initialize_field(schema.fields[4], options?.maxFutureKeyCount);
+        this.maxPastKeyCount = initialize_field(schema.fields[5], options?.maxPastKeyCount);
+        this.securityGroupId = initialize_field(schema.fields[6], options?.securityGroupId);
+        this.rolePermissions = []; // should default
+        if (options.rolePermissions) {
+            assert(Array.isArray(options.rolePermissions));
+            this.rolePermissions = options.rolePermissions.map((e: any) => new RolePermissionType(e));
+        }
+        this.groupProperties = []; // should default
+        if (options.groupProperties) {
+            assert(Array.isArray(options.groupProperties));
+            this.groupProperties = options.groupProperties.map((e: any) => new KeyValuePair(e));
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.name, stream);
+        encodeArray(this.securityGroupFolder, stream, encodeUAString);
+        encodeDouble(this.keyLifetime, stream);
+        encodeUAString(this.securityPolicyUri, stream);
+        encodeUInt32(this.maxFutureKeyCount, stream);
+        encodeUInt32(this.maxPastKeyCount, stream);
+        encodeUAString(this.securityGroupId, stream);
+        encodeArray(this.rolePermissions, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.groupProperties, stream, (obj, stream1) => { obj.encode(stream1); });
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.name = decodeUAString(stream, this.name);
+        this.securityGroupFolder = decodeArray(stream, decodeUAString);
+        this.keyLifetime = decodeDouble(stream, this.keyLifetime);
+        this.securityPolicyUri = decodeUAString(stream, this.securityPolicyUri);
+        this.maxFutureKeyCount = decodeUInt32(stream, this.maxFutureKeyCount);
+        this.maxPastKeyCount = decodeUInt32(stream, this.maxPastKeyCount);
+        this.securityGroupId = decodeUAString(stream, this.securityGroupId);
+        this.rolePermissions = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new RolePermissionType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.groupProperties = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new KeyValuePair(null);
+            obj.decode(stream1);
+            return obj;
+        });
+    }
+    public get schema(): StructuredTypeSchema { return schemaSecurityGroupDataType; }
+}
+SecurityGroupDataType.schema.dataTypeNodeId = SecurityGroupDataType.dataTypeNodeId;
+SecurityGroupDataType.schema.encodingDefaultBinary = SecurityGroupDataType.encodingDefaultBinary;
+SecurityGroupDataType.schema.encodingDefaultXml = SecurityGroupDataType.encodingDefaultXml;
+SecurityGroupDataType.schema.encodingDefaultJson = SecurityGroupDataType.encodingDefaultJson;
+registerClassDefinition( SecurityGroupDataType.dataTypeNodeId, "SecurityGroupDataType", SecurityGroupDataType);
+// --------------------------------------------------------------------------------------------
+const schemaPubSubKeyPushTargetDataType = buildStructuredType({
+    name: "PubSubKeyPushTargetDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "applicationUri",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "pushTargetFolder",
+
+            fieldType: "UAString",
+            isArray: true
+        },
+        {
+            name: "endpointUrl",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "securityPolicyUri",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "userTokenType",
+
+            fieldType: "UserTokenPolicy",
+        },
+        {
+            name: "requestedKeyCount",
+
+            fieldType: "UInt16",
+        },
+        {
+            name: "retryInterval",
+
+            fieldType: "Double",
+        },
+        {
+            name: "pushTargetProperties",
+
+            fieldType: "KeyValuePair",
+            isArray: true
+        },
+        {
+            name: "securityGroups",
+
+            fieldType: "UAString",
+            isArray: true
+        },
+    ]
+});
+export interface PubSubKeyPushTargetDataTypeOptions {
+    applicationUri?: UAString ;
+    pushTargetFolder?: UAString [] | null;
+    endpointUrl?: UAString ;
+    securityPolicyUri?: UAString ;
+    userTokenType?: UserTokenPolicyOptions ;
+    requestedKeyCount?: UInt16 ;
+    retryInterval?: Double ;
+    pushTargetProperties?: KeyValuePairOptions [] | null;
+    securityGroups?: UAString [] | null;
+}
+export class PubSubKeyPushTargetDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPubSubKeyPushTargetDataType; }
+    public static possibleFields: string[] = [
+          "applicationUri",
+           "pushTargetFolder",
+           "endpointUrl",
+           "securityPolicyUri",
+           "userTokenType",
+           "requestedKeyCount",
+           "retryInterval",
+           "pushTargetProperties",
+           "securityGroups"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(25270, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(25530, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(25546, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(25562, 0);
+    public applicationUri: UAString;
+    public pushTargetFolder: UAString[] | null;
+    public endpointUrl: UAString;
+    public securityPolicyUri: UAString;
+    public userTokenType: UserTokenPolicy;
+    public requestedKeyCount: UInt16;
+    public retryInterval: Double;
+    public pushTargetProperties: KeyValuePair[] | null;
+    public securityGroups: UAString[] | null;
+
+    constructor(options?: PubSubKeyPushTargetDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.applicationUri = null;
+            this.pushTargetFolder = []
+            this.endpointUrl = null;
+            this.securityPolicyUri = null;
+         this.userTokenType =  new UserTokenPolicy(null);
+            this.requestedKeyCount = 0;
+            this.retryInterval = 0;
+         this.pushTargetProperties =  null; /* null array */
+            this.securityGroups = []
+              return;
+        }
+        const schema = PubSubKeyPushTargetDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PubSubKeyPushTargetDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.applicationUri = initialize_field(schema.fields[0], options?.applicationUri);
+        this.pushTargetFolder = initialize_field_array(schema.fields[1], options?.pushTargetFolder);
+        this.endpointUrl = initialize_field(schema.fields[2], options?.endpointUrl);
+        this.securityPolicyUri = initialize_field(schema.fields[3], options?.securityPolicyUri);
+        this.userTokenType  =  new UserTokenPolicy(options.userTokenType);
+        this.requestedKeyCount = initialize_field(schema.fields[5], options?.requestedKeyCount);
+        this.retryInterval = initialize_field(schema.fields[6], options?.retryInterval);
+        this.pushTargetProperties = []; // should default
+        if (options.pushTargetProperties) {
+            assert(Array.isArray(options.pushTargetProperties));
+            this.pushTargetProperties = options.pushTargetProperties.map((e: any) => new KeyValuePair(e));
+        }
+        this.securityGroups = initialize_field_array(schema.fields[8], options?.securityGroups);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.applicationUri, stream);
+        encodeArray(this.pushTargetFolder, stream, encodeUAString);
+        encodeUAString(this.endpointUrl, stream);
+        encodeUAString(this.securityPolicyUri, stream);
+        this.userTokenType.encode(stream);
+        encodeUInt16(this.requestedKeyCount, stream);
+        encodeDouble(this.retryInterval, stream);
+        encodeArray(this.pushTargetProperties, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.securityGroups, stream, encodeUAString);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.applicationUri = decodeUAString(stream, this.applicationUri);
+        this.pushTargetFolder = decodeArray(stream, decodeUAString);
+        this.endpointUrl = decodeUAString(stream, this.endpointUrl);
+        this.securityPolicyUri = decodeUAString(stream, this.securityPolicyUri);
+        this.userTokenType.decode(stream);
+        this.requestedKeyCount = decodeUInt16(stream, this.requestedKeyCount);
+        this.retryInterval = decodeDouble(stream, this.retryInterval);
+        this.pushTargetProperties = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new KeyValuePair(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.securityGroups = decodeArray(stream, decodeUAString);
+    }
+    public get schema(): StructuredTypeSchema { return schemaPubSubKeyPushTargetDataType; }
+}
+PubSubKeyPushTargetDataType.schema.dataTypeNodeId = PubSubKeyPushTargetDataType.dataTypeNodeId;
+PubSubKeyPushTargetDataType.schema.encodingDefaultBinary = PubSubKeyPushTargetDataType.encodingDefaultBinary;
+PubSubKeyPushTargetDataType.schema.encodingDefaultXml = PubSubKeyPushTargetDataType.encodingDefaultXml;
+PubSubKeyPushTargetDataType.schema.encodingDefaultJson = PubSubKeyPushTargetDataType.encodingDefaultJson;
+registerClassDefinition( PubSubKeyPushTargetDataType.dataTypeNodeId, "PubSubKeyPushTargetDataType", PubSubKeyPushTargetDataType);
+// --------------------------------------------------------------------------------------------
+const schemaPubSubConfiguration2DataType = buildStructuredType({
+    name: "PubSubConfiguration2DataType",
+
+    baseType: "PubSubConfigurationDataType",
+    fields: [
+        {
+            name: "subscribedDataSets",
+
+            fieldType: "StandaloneSubscribedDataSetDataType",
+            isArray: true
+        },
+        {
+            name: "dataSetClasses",
+
+            fieldType: "DataSetMetaDataType",
+            isArray: true
+        },
+        {
+            name: "defaultSecurityKeyServices",
+
+            fieldType: "EndpointDescription",
+            isArray: true
+        },
+        {
+            name: "securityGroups",
+
+            fieldType: "SecurityGroupDataType",
+            isArray: true
+        },
+        {
+            name: "pubSubKeyPushTargets",
+
+            fieldType: "PubSubKeyPushTargetDataType",
+            isArray: true
+        },
+        {
+            name: "configurationVersion",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "configurationProperties",
+
+            fieldType: "KeyValuePair",
+            isArray: true
+        },
+    ]
+});
+export interface PubSubConfiguration2DataTypeOptions extends PubSubConfigurationDataTypeOptions {
+    subscribedDataSets?: StandaloneSubscribedDataSetDataTypeOptions [] | null;
+    dataSetClasses?: DataSetMetaDataTypeOptions [] | null;
+    defaultSecurityKeyServices?: EndpointDescriptionOptions [] | null;
+    securityGroups?: SecurityGroupDataTypeOptions [] | null;
+    pubSubKeyPushTargets?: PubSubKeyPushTargetDataTypeOptions [] | null;
+    configurationVersion?: UInt32 ;
+    configurationProperties?: KeyValuePairOptions [] | null;
+}
+export class PubSubConfiguration2DataType extends PubSubConfigurationDataType {
+    public static get schema(): StructuredTypeSchema { return schemaPubSubConfiguration2DataType; }
+    public static possibleFields: string[] = [
+          "subscribedDataSets",
+           "dataSetClasses",
+           "defaultSecurityKeyServices",
+           "securityGroups",
+           "pubSubKeyPushTargets",
+           "configurationVersion",
+           "configurationProperties"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23602, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23854, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23922, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23990, 0);
+    public subscribedDataSets: StandaloneSubscribedDataSetDataType[] | null;
+    public dataSetClasses: DataSetMetaDataType[] | null;
+    public defaultSecurityKeyServices: EndpointDescription[] | null;
+    public securityGroups: SecurityGroupDataType[] | null;
+    public pubSubKeyPushTargets: PubSubKeyPushTargetDataType[] | null;
+    public configurationVersion: UInt32;
+    public configurationProperties: KeyValuePair[] | null;
+
+    constructor(options?: PubSubConfiguration2DataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+         this.subscribedDataSets =  null; /* null array */
+         this.dataSetClasses =  null; /* null array */
+         this.defaultSecurityKeyServices =  null; /* null array */
+         this.securityGroups =  null; /* null array */
+         this.pubSubKeyPushTargets =  null; /* null array */
+            this.configurationVersion = 0;
+         this.configurationProperties =  null; /* null array */
+              return;
+        }
+        const schema = PubSubConfiguration2DataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PubSubConfiguration2DataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.subscribedDataSets = []; // should default
+        if (options.subscribedDataSets) {
+            assert(Array.isArray(options.subscribedDataSets));
+            this.subscribedDataSets = options.subscribedDataSets.map((e: any) => new StandaloneSubscribedDataSetDataType(e));
+        }
+        this.dataSetClasses = []; // should default
+        if (options.dataSetClasses) {
+            assert(Array.isArray(options.dataSetClasses));
+            this.dataSetClasses = options.dataSetClasses.map((e: any) => new DataSetMetaDataType(e));
+        }
+        this.defaultSecurityKeyServices = []; // should default
+        if (options.defaultSecurityKeyServices) {
+            assert(Array.isArray(options.defaultSecurityKeyServices));
+            this.defaultSecurityKeyServices = options.defaultSecurityKeyServices.map((e: any) => new EndpointDescription(e));
+        }
+        this.securityGroups = []; // should default
+        if (options.securityGroups) {
+            assert(Array.isArray(options.securityGroups));
+            this.securityGroups = options.securityGroups.map((e: any) => new SecurityGroupDataType(e));
+        }
+        this.pubSubKeyPushTargets = []; // should default
+        if (options.pubSubKeyPushTargets) {
+            assert(Array.isArray(options.pubSubKeyPushTargets));
+            this.pubSubKeyPushTargets = options.pubSubKeyPushTargets.map((e: any) => new PubSubKeyPushTargetDataType(e));
+        }
+        this.configurationVersion = initialize_field(schema.fields[5], options?.configurationVersion);
+        this.configurationProperties = []; // should default
+        if (options.configurationProperties) {
+            assert(Array.isArray(options.configurationProperties));
+            this.configurationProperties = options.configurationProperties.map((e: any) => new KeyValuePair(e));
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeArray(this.subscribedDataSets, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.dataSetClasses, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.defaultSecurityKeyServices, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.securityGroups, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeArray(this.pubSubKeyPushTargets, stream, (obj, stream1) => { obj.encode(stream1); });
+        encodeUInt32(this.configurationVersion, stream);
+        encodeArray(this.configurationProperties, stream, (obj, stream1) => { obj.encode(stream1); });
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.subscribedDataSets = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new StandaloneSubscribedDataSetDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.dataSetClasses = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new DataSetMetaDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.defaultSecurityKeyServices = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new EndpointDescription(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.securityGroups = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new SecurityGroupDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.pubSubKeyPushTargets = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new PubSubKeyPushTargetDataType(null);
+            obj.decode(stream1);
+            return obj;
+        });
+        this.configurationVersion = decodeUInt32(stream, this.configurationVersion);
+        this.configurationProperties = decodeArray(stream, (stream1: BinaryStream) => {
+            const obj = new KeyValuePair(null);
+            obj.decode(stream1);
+            return obj;
+        });
+    }
+    public get schema(): StructuredTypeSchema { return schemaPubSubConfiguration2DataType; }
+}
+PubSubConfiguration2DataType.schema.dataTypeNodeId = PubSubConfiguration2DataType.dataTypeNodeId;
+PubSubConfiguration2DataType.schema.encodingDefaultBinary = PubSubConfiguration2DataType.encodingDefaultBinary;
+PubSubConfiguration2DataType.schema.encodingDefaultXml = PubSubConfiguration2DataType.encodingDefaultXml;
+PubSubConfiguration2DataType.schema.encodingDefaultJson = PubSubConfiguration2DataType.encodingDefaultJson;
+registerClassDefinition( PubSubConfiguration2DataType.dataTypeNodeId, "PubSubConfiguration2DataType", PubSubConfiguration2DataType);
+
+// --------------------------------------------------------------------------------------------
+export enum PubSubConfigurationRefMask {
+    None = 0,
+    ElementAdd = 1,
+    ElementMatch = 2,
+    ElementModify = 4,
+    ElementRemove = 8,
+    ReferenceWriter = 16,
+    ReferenceReader = 32,
+    ReferenceWriterGroup = 64,
+    ReferenceReaderGroup = 128,
+    ReferenceConnection = 256,
+    ReferencePubDataset = 512,
+    ReferenceSubDataset = 1024,
+    ReferenceSecurityGroup = 2048,
+    ReferencePushTarget = 4096
+}
+const schemaPubSubConfigurationRefMask = {
+    enumValues: PubSubConfigurationRefMask,
+    flaggable: true,
+    name: "PubSubConfigurationRefMask"
+};
+function decodePubSubConfigurationRefMask(stream: BinaryStream, _value?: PubSubConfigurationRefMask): PubSubConfigurationRefMask {
+    return  stream.readUInt32() as PubSubConfigurationRefMask;
+}
+function encodePubSubConfigurationRefMask(value: PubSubConfigurationRefMask, stream: OutputBinaryStream): void {
+    stream.writeUInt32(value);
+}
+export const _enumerationPubSubConfigurationRefMask = registerEnumeration(schemaPubSubConfigurationRefMask);
+assert(_enumerationPubSubConfigurationRefMask.isFlaggable ===  true);
+// --------------------------------------------------------------------------------------------
+const schemaPubSubConfigurationRefDataType = buildStructuredType({
+    name: "PubSubConfigurationRefDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "configurationMask",
+
+            fieldType: "PubSubConfigurationRefMask",
+        },
+        {
+            name: "elementIndex",
+
+            fieldType: "UInt16",
+        },
+        {
+            name: "connectionIndex",
+
+            fieldType: "UInt16",
+        },
+        {
+            name: "groupIndex",
+
+            fieldType: "UInt16",
+        },
+    ]
+});
+export interface PubSubConfigurationRefDataTypeOptions {
+    configurationMask?: PubSubConfigurationRefMask;
+    elementIndex?: UInt16 ;
+    connectionIndex?: UInt16 ;
+    groupIndex?: UInt16 ;
+}
+export class PubSubConfigurationRefDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPubSubConfigurationRefDataType; }
+    public static possibleFields: string[] = [
+          "configurationMask",
+           "elementIndex",
+           "connectionIndex",
+           "groupIndex"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(25519, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(25531, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(25547, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(25563, 0);
+    public configurationMask: PubSubConfigurationRefMask;
+    public elementIndex: UInt16;
+    public connectionIndex: UInt16;
+    public groupIndex: UInt16;
+
+    constructor(options?: PubSubConfigurationRefDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+             this.configurationMask =  0 as  PubSubConfigurationRefMask;
+            this.elementIndex = 0;
+            this.connectionIndex = 0;
+            this.groupIndex = 0;
+              return;
+        }
+        const schema = PubSubConfigurationRefDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PubSubConfigurationRefDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.configurationMask = this.setConfigurationMask(initialize_field(schema.fields[0], options?.configurationMask));
+        this.elementIndex = initialize_field(schema.fields[1], options?.elementIndex);
+        this.connectionIndex = initialize_field(schema.fields[2], options?.connectionIndex);
+        this.groupIndex = initialize_field(schema.fields[3], options?.groupIndex);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodePubSubConfigurationRefMask(this.configurationMask, stream);
+        encodeUInt16(this.elementIndex, stream);
+        encodeUInt16(this.connectionIndex, stream);
+        encodeUInt16(this.groupIndex, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.configurationMask = decodePubSubConfigurationRefMask(stream, this.configurationMask);
+        this.elementIndex = decodeUInt16(stream, this.elementIndex);
+        this.connectionIndex = decodeUInt16(stream, this.connectionIndex);
+        this.groupIndex = decodeUInt16(stream, this.groupIndex);
+    }
+
+    // Define Enumeration setters
+    public setConfigurationMask(value: any): PubSubConfigurationRefMask {
+        const coercedValue = _enumerationPubSubConfigurationRefMask.get(value);
+        /* istanbul ignore next */
+        if (coercedValue === undefined || coercedValue === null) {
+           throw new Error("value cannot be coerced to PubSubConfigurationRefMask :" + value);
+        }
+        this.configurationMask = coercedValue.value as PubSubConfigurationRefMask;
+        return this.configurationMask;
+    }
+    public get schema(): StructuredTypeSchema { return schemaPubSubConfigurationRefDataType; }
+}
+PubSubConfigurationRefDataType.schema.dataTypeNodeId = PubSubConfigurationRefDataType.dataTypeNodeId;
+PubSubConfigurationRefDataType.schema.encodingDefaultBinary = PubSubConfigurationRefDataType.encodingDefaultBinary;
+PubSubConfigurationRefDataType.schema.encodingDefaultXml = PubSubConfigurationRefDataType.encodingDefaultXml;
+PubSubConfigurationRefDataType.schema.encodingDefaultJson = PubSubConfigurationRefDataType.encodingDefaultJson;
+registerClassDefinition( PubSubConfigurationRefDataType.dataTypeNodeId, "PubSubConfigurationRefDataType", PubSubConfigurationRefDataType);
+// --------------------------------------------------------------------------------------------
+const schemaPubSubConfigurationValueDataType = buildStructuredType({
+    name: "PubSubConfigurationValueDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "configurationElement",
+
+            fieldType: "PubSubConfigurationRefDataType",
+        },
+        {
+            name: "name",
 
-            fieldType: "PubSubConnectionDataType",
-            isArray: true
+            fieldType: "UAString",
         },
         {
-            name: "enabled",
+            name: "identifier",
 
-            fieldType: "UABoolean",
+            fieldType: "Variant",
         },
     ]
 });
-export interface PubSubConfigurationDataTypeOptions {
-    publishedDataSets?: PublishedDataSetDataTypeOptions [] | null;
-    connections?: PubSubConnectionDataTypeOptions [] | null;
-    enabled?: UABoolean ;
+export interface PubSubConfigurationValueDataTypeOptions {
+    configurationElement?: PubSubConfigurationRefDataTypeOptions ;
+    name?: UAString ;
+    identifier?: (VariantLike | null);
 }
-export class PubSubConfigurationDataType extends ExtensionObject {
-    public static get schema(): StructuredTypeSchema { return schemaPubSubConfigurationDataType; }
+export class PubSubConfigurationValueDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaPubSubConfigurationValueDataType; }
     public static possibleFields: string[] = [
-          "publishedDataSets",
-           "connections",
-           "enabled"
+          "configurationElement",
+           "name",
+           "identifier"
     ];
-    public static dataTypeNodeId = makeExpandedNodeId(15530, 0);
-    public static encodingDefaultBinary = makeExpandedNodeId(21154, 0);
-    public static encodingDefaultXml = makeExpandedNodeId(21178, 0);
-    public static encodingDefaultJson = makeExpandedNodeId(21202, 0);
-    public publishedDataSets: PublishedDataSetDataType[] | null;
-    public connections: PubSubConnectionDataType[] | null;
-    public enabled: UABoolean;
+    public static dataTypeNodeId = makeExpandedNodeId(25520, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(25532, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(25548, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(25564, 0);
+    public configurationElement: PubSubConfigurationRefDataType;
+    public name: UAString;
+    public identifier: Variant;
 
-    constructor(options?: PubSubConfigurationDataTypeOptions | null) {
+    constructor(options?: PubSubConfigurationValueDataTypeOptions | null) {
 
         super(options);
 
         if (options === null) {
-         this.publishedDataSets =  null; /* null array */
-         this.connections =  null; /* null array */
-            this.enabled = false;
+         this.configurationElement =  new PubSubConfigurationRefDataType(null);
+            this.name = null;
+            this.identifier = new Variant(null);
               return;
         }
-        const schema = PubSubConfigurationDataType.schema;
-        options = (schema.constructHook ? schema.constructHook(options) as PubSubConfigurationDataTypeOptions: options ) || {};
+        const schema = PubSubConfigurationValueDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PubSubConfigurationValueDataTypeOptions: options ) || {};
         /* istanbul ignore next */
         if (parameters.debugSchemaHelper) {
             check_options_correctness_against_schema(this, schema, options);
         }
-        this.publishedDataSets = []; // should default
-        if (options.publishedDataSets) {
-            assert(Array.isArray(options.publishedDataSets));
-            this.publishedDataSets = options.publishedDataSets.map((e: any) => new PublishedDataSetDataType(e));
-        }
-        this.connections = []; // should default
-        if (options.connections) {
-            assert(Array.isArray(options.connections));
-            this.connections = options.connections.map((e: any) => new PubSubConnectionDataType(e));
-        }
-        this.enabled = initialize_field(schema.fields[2], options?.enabled);
+        this.configurationElement  =  new PubSubConfigurationRefDataType(options.configurationElement);
+        this.name = initialize_field(schema.fields[1], options?.name);
+        this.identifier = initialize_field(schema.fields[2], options?.identifier);
     }
      public encode(stream: OutputBinaryStream): void {
         /* NEEDED */ super.encode(stream);
-        encodeArray(this.publishedDataSets, stream, (obj, stream1) => { obj.encode(stream1); });
-        encodeArray(this.connections, stream, (obj, stream1) => { obj.encode(stream1); });
-        encodeUABoolean(this.enabled, stream);
+        this.configurationElement.encode(stream);
+        encodeUAString(this.name, stream);
+        encodeVariant(this.identifier, stream);
     }
     public decode(stream: BinaryStream): void {
         // call base class implementation first
         /* NEEDED !!! */ super.decode(stream);
-        this.publishedDataSets = decodeArray(stream, (stream1: BinaryStream) => {
-            const obj = new PublishedDataSetDataType(null);
-            obj.decode(stream1);
-            return obj;
-        });
-        this.connections = decodeArray(stream, (stream1: BinaryStream) => {
-            const obj = new PubSubConnectionDataType(null);
-            obj.decode(stream1);
-            return obj;
-        });
-        this.enabled = decodeUABoolean(stream, this.enabled);
+        this.configurationElement.decode(stream);
+        this.name = decodeUAString(stream, this.name);
+        this.identifier = decodeVariant(stream, this.identifier);
     }
-    public get schema(): StructuredTypeSchema { return schemaPubSubConfigurationDataType; }
+    public get schema(): StructuredTypeSchema { return schemaPubSubConfigurationValueDataType; }
 }
-PubSubConfigurationDataType.schema.dataTypeNodeId = PubSubConfigurationDataType.dataTypeNodeId;
-PubSubConfigurationDataType.schema.encodingDefaultBinary = PubSubConfigurationDataType.encodingDefaultBinary;
-PubSubConfigurationDataType.schema.encodingDefaultXml = PubSubConfigurationDataType.encodingDefaultXml;
-PubSubConfigurationDataType.schema.encodingDefaultJson = PubSubConfigurationDataType.encodingDefaultJson;
-registerClassDefinition( PubSubConfigurationDataType.dataTypeNodeId, "PubSubConfigurationDataType", PubSubConfigurationDataType);
+PubSubConfigurationValueDataType.schema.dataTypeNodeId = PubSubConfigurationValueDataType.dataTypeNodeId;
+PubSubConfigurationValueDataType.schema.encodingDefaultBinary = PubSubConfigurationValueDataType.encodingDefaultBinary;
+PubSubConfigurationValueDataType.schema.encodingDefaultXml = PubSubConfigurationValueDataType.encodingDefaultXml;
+PubSubConfigurationValueDataType.schema.encodingDefaultJson = PubSubConfigurationValueDataType.encodingDefaultJson;
+registerClassDefinition( PubSubConfigurationValueDataType.dataTypeNodeId, "PubSubConfigurationValueDataType", PubSubConfigurationValueDataType);
 // --------------------------------------------------------------------------------------------
 const schemaSubscriptionAcknowledgement = buildStructuredType({
     name: "SubscriptionAcknowledgement",
@@ -19923,6 +21397,65 @@ PublishedDataItemsDataType.schema.encodingDefaultXml = PublishedDataItemsDataTyp
 PublishedDataItemsDataType.schema.encodingDefaultJson = PublishedDataItemsDataType.encodingDefaultJson;
 registerClassDefinition( PublishedDataItemsDataType.dataTypeNodeId, "PublishedDataItemsDataType", PublishedDataItemsDataType);
 // --------------------------------------------------------------------------------------------
+const schemaPublishedDataSetCustomSourceDataType = buildStructuredType({
+    name: "PublishedDataSetCustomSourceDataType",
+
+    baseType: "PublishedDataSetSourceDataType",
+    fields: [
+        {
+            name: "cyclicDataSet",
+
+            fieldType: "UABoolean",
+        },
+    ]
+});
+export interface PublishedDataSetCustomSourceDataTypeOptions extends PublishedDataSetSourceDataTypeOptions {
+    cyclicDataSet?: UABoolean ;
+}
+export class PublishedDataSetCustomSourceDataType extends PublishedDataSetSourceDataType {
+    public static get schema(): StructuredTypeSchema { return schemaPublishedDataSetCustomSourceDataType; }
+    public static possibleFields: string[] = [
+          "cyclicDataSet"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(25269, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(25529, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(25545, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(25561, 0);
+    public cyclicDataSet: UABoolean;
+
+    constructor(options?: PublishedDataSetCustomSourceDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.cyclicDataSet = false;
+              return;
+        }
+        const schema = PublishedDataSetCustomSourceDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as PublishedDataSetCustomSourceDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.cyclicDataSet = initialize_field(schema.fields[0], options?.cyclicDataSet);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUABoolean(this.cyclicDataSet, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.cyclicDataSet = decodeUABoolean(stream, this.cyclicDataSet);
+    }
+    public get schema(): StructuredTypeSchema { return schemaPublishedDataSetCustomSourceDataType; }
+}
+PublishedDataSetCustomSourceDataType.schema.dataTypeNodeId = PublishedDataSetCustomSourceDataType.dataTypeNodeId;
+PublishedDataSetCustomSourceDataType.schema.encodingDefaultBinary = PublishedDataSetCustomSourceDataType.encodingDefaultBinary;
+PublishedDataSetCustomSourceDataType.schema.encodingDefaultXml = PublishedDataSetCustomSourceDataType.encodingDefaultXml;
+PublishedDataSetCustomSourceDataType.schema.encodingDefaultJson = PublishedDataSetCustomSourceDataType.encodingDefaultJson;
+registerClassDefinition( PublishedDataSetCustomSourceDataType.dataTypeNodeId, "PublishedDataSetCustomSourceDataType", PublishedDataSetCustomSourceDataType);
+// --------------------------------------------------------------------------------------------
 const schemaPublishedEventsDataType = buildStructuredType({
     name: "PublishedEventsDataType",
 
@@ -20015,6 +21548,54 @@ PublishedEventsDataType.schema.encodingDefaultXml = PublishedEventsDataType.enco
 PublishedEventsDataType.schema.encodingDefaultJson = PublishedEventsDataType.encodingDefaultJson;
 registerClassDefinition( PublishedEventsDataType.dataTypeNodeId, "PublishedEventsDataType", PublishedEventsDataType);
 // --------------------------------------------------------------------------------------------
+const schemaQosDataType = buildStructuredType({
+    name: "QosDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+    ]
+});
+export interface QosDataTypeOptions {
+}
+export class QosDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaQosDataType; }
+    public static possibleFields: string[] = [
+          
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23603, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23855, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23923, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23991, 0);
+
+    constructor(options?: QosDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+              return;
+        }
+        const schema = QosDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as QosDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+    }
+    public get schema(): StructuredTypeSchema { return schemaQosDataType; }
+}
+QosDataType.schema.dataTypeNodeId = QosDataType.dataTypeNodeId;
+QosDataType.schema.encodingDefaultBinary = QosDataType.encodingDefaultBinary;
+QosDataType.schema.encodingDefaultXml = QosDataType.encodingDefaultXml;
+QosDataType.schema.encodingDefaultJson = QosDataType.encodingDefaultJson;
+registerClassDefinition( QosDataType.dataTypeNodeId, "QosDataType", QosDataType);
+// --------------------------------------------------------------------------------------------
 const schemaQueryDataSet = buildStructuredType({
     name: "QueryDataSet",
 
@@ -21348,6 +22929,113 @@ ReaderGroupTransportDataType.schema.encodingDefaultBinary = ReaderGroupTransport
 ReaderGroupTransportDataType.schema.encodingDefaultXml = ReaderGroupTransportDataType.encodingDefaultXml;
 ReaderGroupTransportDataType.schema.encodingDefaultJson = ReaderGroupTransportDataType.encodingDefaultJson;
 registerClassDefinition( ReaderGroupTransportDataType.dataTypeNodeId, "ReaderGroupTransportDataType", ReaderGroupTransportDataType);
+// --------------------------------------------------------------------------------------------
+const schemaReceiveQosDataType = buildStructuredType({
+    name: "ReceiveQosDataType",
+
+    baseType: "QosDataType",
+    fields: [
+    ]
+});
+export interface ReceiveQosDataTypeOptions extends QosDataTypeOptions {
+}
+export class ReceiveQosDataType extends QosDataType {
+    public static get schema(): StructuredTypeSchema { return schemaReceiveQosDataType; }
+    public static possibleFields: string[] = [
+          
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23608, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23860, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23928, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23996, 0);
+
+    constructor(options?: ReceiveQosDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+              return;
+        }
+        const schema = ReceiveQosDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as ReceiveQosDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+    }
+    public get schema(): StructuredTypeSchema { return schemaReceiveQosDataType; }
+}
+ReceiveQosDataType.schema.dataTypeNodeId = ReceiveQosDataType.dataTypeNodeId;
+ReceiveQosDataType.schema.encodingDefaultBinary = ReceiveQosDataType.encodingDefaultBinary;
+ReceiveQosDataType.schema.encodingDefaultXml = ReceiveQosDataType.encodingDefaultXml;
+ReceiveQosDataType.schema.encodingDefaultJson = ReceiveQosDataType.encodingDefaultJson;
+registerClassDefinition( ReceiveQosDataType.dataTypeNodeId, "ReceiveQosDataType", ReceiveQosDataType);
+// --------------------------------------------------------------------------------------------
+const schemaReceiveQosPriorityDataType = buildStructuredType({
+    name: "ReceiveQosPriorityDataType",
+
+    baseType: "ReceiveQosDataType",
+    fields: [
+        {
+            name: "priorityLabel",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface ReceiveQosPriorityDataTypeOptions extends ReceiveQosDataTypeOptions {
+    priorityLabel?: UAString ;
+}
+export class ReceiveQosPriorityDataType extends ReceiveQosDataType {
+    public static get schema(): StructuredTypeSchema { return schemaReceiveQosPriorityDataType; }
+    public static possibleFields: string[] = [
+          "priorityLabel"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23609, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23861, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23929, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23997, 0);
+    public priorityLabel: UAString;
+
+    constructor(options?: ReceiveQosPriorityDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.priorityLabel = null;
+              return;
+        }
+        const schema = ReceiveQosPriorityDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as ReceiveQosPriorityDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.priorityLabel = initialize_field(schema.fields[0], options?.priorityLabel);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.priorityLabel, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.priorityLabel = decodeUAString(stream, this.priorityLabel);
+    }
+    public get schema(): StructuredTypeSchema { return schemaReceiveQosPriorityDataType; }
+}
+ReceiveQosPriorityDataType.schema.dataTypeNodeId = ReceiveQosPriorityDataType.dataTypeNodeId;
+ReceiveQosPriorityDataType.schema.encodingDefaultBinary = ReceiveQosPriorityDataType.encodingDefaultBinary;
+ReceiveQosPriorityDataType.schema.encodingDefaultXml = ReceiveQosPriorityDataType.encodingDefaultXml;
+ReceiveQosPriorityDataType.schema.encodingDefaultJson = ReceiveQosPriorityDataType.encodingDefaultJson;
+registerClassDefinition( ReceiveQosPriorityDataType.dataTypeNodeId, "ReceiveQosPriorityDataType", ReceiveQosPriorityDataType);
 
 // --------------------------------------------------------------------------------------------
 export enum ServerState {
@@ -24530,54 +26218,113 @@ export class SetTriggeringResponse extends ExtensionObject {
     public removeResults: StatusCode[] | null;
     public removeDiagnosticInfos: (DiagnosticInfo | null)[] | null;
 
-    constructor(options?: SetTriggeringResponseOptions | null) {
+    constructor(options?: SetTriggeringResponseOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+         this.responseHeader =  new ResponseHeader(null);
+            this.addResults = []
+            this.addDiagnosticInfos = []
+            this.removeResults = []
+            this.removeDiagnosticInfos = []
+              return;
+        }
+        const schema = SetTriggeringResponse.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as SetTriggeringResponseOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.responseHeader  =  new ResponseHeader(options.responseHeader);
+        this.addResults = initialize_field_array(schema.fields[1], options?.addResults);
+        this.addDiagnosticInfos = initialize_field_array(schema.fields[2], options?.addDiagnosticInfos);
+        this.removeResults = initialize_field_array(schema.fields[3], options?.removeResults);
+        this.removeDiagnosticInfos = initialize_field_array(schema.fields[4], options?.removeDiagnosticInfos);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        this.responseHeader.encode(stream);
+        encodeArray(this.addResults, stream, encodeStatusCode);
+        encodeArray(this.addDiagnosticInfos, stream, encodeDiagnosticInfo);
+        encodeArray(this.removeResults, stream, encodeStatusCode);
+        encodeArray(this.removeDiagnosticInfos, stream, encodeDiagnosticInfo);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.responseHeader.decode(stream);
+        this.addResults = decodeArray(stream, decodeStatusCode);
+        this.addDiagnosticInfos = decodeArray(stream, decodeDiagnosticInfo);
+        this.removeResults = decodeArray(stream, decodeStatusCode);
+        this.removeDiagnosticInfos = decodeArray(stream, decodeDiagnosticInfo);
+    }
+    public get schema(): StructuredTypeSchema { return schemaSetTriggeringResponse; }
+}
+SetTriggeringResponse.schema.dataTypeNodeId = SetTriggeringResponse.dataTypeNodeId;
+SetTriggeringResponse.schema.encodingDefaultBinary = SetTriggeringResponse.encodingDefaultBinary;
+SetTriggeringResponse.schema.encodingDefaultXml = SetTriggeringResponse.encodingDefaultXml;
+SetTriggeringResponse.schema.encodingDefaultJson = SetTriggeringResponse.encodingDefaultJson;
+registerClassDefinition( SetTriggeringResponse.dataTypeNodeId, "SetTriggeringResponse", SetTriggeringResponse);
+// --------------------------------------------------------------------------------------------
+const schemaStandaloneSubscribedDataSetRefDataType = buildStructuredType({
+    name: "StandaloneSubscribedDataSetRefDataType",
+
+    baseType: "SubscribedDataSetDataType",
+    fields: [
+        {
+            name: "dataSetName",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface StandaloneSubscribedDataSetRefDataTypeOptions extends SubscribedDataSetDataTypeOptions {
+    dataSetName?: UAString ;
+}
+export class StandaloneSubscribedDataSetRefDataType extends SubscribedDataSetDataType {
+    public static get schema(): StructuredTypeSchema { return schemaStandaloneSubscribedDataSetRefDataType; }
+    public static possibleFields: string[] = [
+          "dataSetName"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23599, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23851, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23919, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23987, 0);
+    public dataSetName: UAString;
+
+    constructor(options?: StandaloneSubscribedDataSetRefDataTypeOptions | null) {
 
         super(options);
 
         if (options === null) {
-         this.responseHeader =  new ResponseHeader(null);
-            this.addResults = []
-            this.addDiagnosticInfos = []
-            this.removeResults = []
-            this.removeDiagnosticInfos = []
+            this.dataSetName = null;
               return;
         }
-        const schema = SetTriggeringResponse.schema;
-        options = (schema.constructHook ? schema.constructHook(options) as SetTriggeringResponseOptions: options ) || {};
+        const schema = StandaloneSubscribedDataSetRefDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as StandaloneSubscribedDataSetRefDataTypeOptions: options ) || {};
         /* istanbul ignore next */
         if (parameters.debugSchemaHelper) {
             check_options_correctness_against_schema(this, schema, options);
         }
-        this.responseHeader  =  new ResponseHeader(options.responseHeader);
-        this.addResults = initialize_field_array(schema.fields[1], options?.addResults);
-        this.addDiagnosticInfos = initialize_field_array(schema.fields[2], options?.addDiagnosticInfos);
-        this.removeResults = initialize_field_array(schema.fields[3], options?.removeResults);
-        this.removeDiagnosticInfos = initialize_field_array(schema.fields[4], options?.removeDiagnosticInfos);
+        this.dataSetName = initialize_field(schema.fields[0], options?.dataSetName);
     }
      public encode(stream: OutputBinaryStream): void {
         /* NEEDED */ super.encode(stream);
-        this.responseHeader.encode(stream);
-        encodeArray(this.addResults, stream, encodeStatusCode);
-        encodeArray(this.addDiagnosticInfos, stream, encodeDiagnosticInfo);
-        encodeArray(this.removeResults, stream, encodeStatusCode);
-        encodeArray(this.removeDiagnosticInfos, stream, encodeDiagnosticInfo);
+        encodeUAString(this.dataSetName, stream);
     }
     public decode(stream: BinaryStream): void {
         // call base class implementation first
         /* NEEDED !!! */ super.decode(stream);
-        this.responseHeader.decode(stream);
-        this.addResults = decodeArray(stream, decodeStatusCode);
-        this.addDiagnosticInfos = decodeArray(stream, decodeDiagnosticInfo);
-        this.removeResults = decodeArray(stream, decodeStatusCode);
-        this.removeDiagnosticInfos = decodeArray(stream, decodeDiagnosticInfo);
+        this.dataSetName = decodeUAString(stream, this.dataSetName);
     }
-    public get schema(): StructuredTypeSchema { return schemaSetTriggeringResponse; }
+    public get schema(): StructuredTypeSchema { return schemaStandaloneSubscribedDataSetRefDataType; }
 }
-SetTriggeringResponse.schema.dataTypeNodeId = SetTriggeringResponse.dataTypeNodeId;
-SetTriggeringResponse.schema.encodingDefaultBinary = SetTriggeringResponse.encodingDefaultBinary;
-SetTriggeringResponse.schema.encodingDefaultXml = SetTriggeringResponse.encodingDefaultXml;
-SetTriggeringResponse.schema.encodingDefaultJson = SetTriggeringResponse.encodingDefaultJson;
-registerClassDefinition( SetTriggeringResponse.dataTypeNodeId, "SetTriggeringResponse", SetTriggeringResponse);
+StandaloneSubscribedDataSetRefDataType.schema.dataTypeNodeId = StandaloneSubscribedDataSetRefDataType.dataTypeNodeId;
+StandaloneSubscribedDataSetRefDataType.schema.encodingDefaultBinary = StandaloneSubscribedDataSetRefDataType.encodingDefaultBinary;
+StandaloneSubscribedDataSetRefDataType.schema.encodingDefaultXml = StandaloneSubscribedDataSetRefDataType.encodingDefaultXml;
+StandaloneSubscribedDataSetRefDataType.schema.encodingDefaultJson = StandaloneSubscribedDataSetRefDataType.encodingDefaultJson;
+registerClassDefinition( StandaloneSubscribedDataSetRefDataType.dataTypeNodeId, "StandaloneSubscribedDataSetRefDataType", StandaloneSubscribedDataSetRefDataType);
 // --------------------------------------------------------------------------------------------
 const schemaStatusChangeNotification = buildStructuredType({
     name: "StatusChangeNotification",
@@ -24650,54 +26397,6 @@ StatusChangeNotification.schema.encodingDefaultXml = StatusChangeNotification.en
 StatusChangeNotification.schema.encodingDefaultJson = StatusChangeNotification.encodingDefaultJson;
 registerClassDefinition( StatusChangeNotification.dataTypeNodeId, "StatusChangeNotification", StatusChangeNotification);
 // --------------------------------------------------------------------------------------------
-const schemaSubscribedDataSetDataType = buildStructuredType({
-    name: "SubscribedDataSetDataType",
-
-    baseType: "ExtensionObject",
-    fields: [
-    ]
-});
-export interface SubscribedDataSetDataTypeOptions {
-}
-export class SubscribedDataSetDataType extends ExtensionObject {
-    public static get schema(): StructuredTypeSchema { return schemaSubscribedDataSetDataType; }
-    public static possibleFields: string[] = [
-          
-    ];
-    public static dataTypeNodeId = makeExpandedNodeId(15630, 0);
-    public static encodingDefaultBinary = makeExpandedNodeId(15707, 0);
-    public static encodingDefaultXml = makeExpandedNodeId(16010, 0);
-    public static encodingDefaultJson = makeExpandedNodeId(16308, 0);
-
-    constructor(options?: SubscribedDataSetDataTypeOptions | null) {
-
-        super(options);
-
-        if (options === null) {
-              return;
-        }
-        const schema = SubscribedDataSetDataType.schema;
-        options = (schema.constructHook ? schema.constructHook(options) as SubscribedDataSetDataTypeOptions: options ) || {};
-        /* istanbul ignore next */
-        if (parameters.debugSchemaHelper) {
-            check_options_correctness_against_schema(this, schema, options);
-        }
-    }
-     public encode(stream: OutputBinaryStream): void {
-        /* NEEDED */ super.encode(stream);
-    }
-    public decode(stream: BinaryStream): void {
-        // call base class implementation first
-        /* NEEDED !!! */ super.decode(stream);
-    }
-    public get schema(): StructuredTypeSchema { return schemaSubscribedDataSetDataType; }
-}
-SubscribedDataSetDataType.schema.dataTypeNodeId = SubscribedDataSetDataType.dataTypeNodeId;
-SubscribedDataSetDataType.schema.encodingDefaultBinary = SubscribedDataSetDataType.encodingDefaultBinary;
-SubscribedDataSetDataType.schema.encodingDefaultXml = SubscribedDataSetDataType.encodingDefaultXml;
-SubscribedDataSetDataType.schema.encodingDefaultJson = SubscribedDataSetDataType.encodingDefaultJson;
-registerClassDefinition( SubscribedDataSetDataType.dataTypeNodeId, "SubscribedDataSetDataType", SubscribedDataSetDataType);
-// --------------------------------------------------------------------------------------------
 const schemaSubscribedDataSetMirrorDataType = buildStructuredType({
     name: "SubscribedDataSetMirrorDataType",
 
@@ -26126,6 +27825,113 @@ TranslateBrowsePathsToNodeIdsResponse.schema.encodingDefaultXml = TranslateBrows
 TranslateBrowsePathsToNodeIdsResponse.schema.encodingDefaultJson = TranslateBrowsePathsToNodeIdsResponse.encodingDefaultJson;
 registerClassDefinition( TranslateBrowsePathsToNodeIdsResponse.dataTypeNodeId, "TranslateBrowsePathsToNodeIdsResponse", TranslateBrowsePathsToNodeIdsResponse);
 // --------------------------------------------------------------------------------------------
+const schemaTransmitQosDataType = buildStructuredType({
+    name: "TransmitQosDataType",
+
+    baseType: "QosDataType",
+    fields: [
+    ]
+});
+export interface TransmitQosDataTypeOptions extends QosDataTypeOptions {
+}
+export class TransmitQosDataType extends QosDataType {
+    public static get schema(): StructuredTypeSchema { return schemaTransmitQosDataType; }
+    public static possibleFields: string[] = [
+          
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23604, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23856, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23924, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23992, 0);
+
+    constructor(options?: TransmitQosDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+              return;
+        }
+        const schema = TransmitQosDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as TransmitQosDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+    }
+    public get schema(): StructuredTypeSchema { return schemaTransmitQosDataType; }
+}
+TransmitQosDataType.schema.dataTypeNodeId = TransmitQosDataType.dataTypeNodeId;
+TransmitQosDataType.schema.encodingDefaultBinary = TransmitQosDataType.encodingDefaultBinary;
+TransmitQosDataType.schema.encodingDefaultXml = TransmitQosDataType.encodingDefaultXml;
+TransmitQosDataType.schema.encodingDefaultJson = TransmitQosDataType.encodingDefaultJson;
+registerClassDefinition( TransmitQosDataType.dataTypeNodeId, "TransmitQosDataType", TransmitQosDataType);
+// --------------------------------------------------------------------------------------------
+const schemaTransmitQosPriorityDataType = buildStructuredType({
+    name: "TransmitQosPriorityDataType",
+
+    baseType: "TransmitQosDataType",
+    fields: [
+        {
+            name: "priorityLabel",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface TransmitQosPriorityDataTypeOptions extends TransmitQosDataTypeOptions {
+    priorityLabel?: UAString ;
+}
+export class TransmitQosPriorityDataType extends TransmitQosDataType {
+    public static get schema(): StructuredTypeSchema { return schemaTransmitQosPriorityDataType; }
+    public static possibleFields: string[] = [
+          "priorityLabel"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(23605, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(23857, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(23925, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(23993, 0);
+    public priorityLabel: UAString;
+
+    constructor(options?: TransmitQosPriorityDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.priorityLabel = null;
+              return;
+        }
+        const schema = TransmitQosPriorityDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as TransmitQosPriorityDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.priorityLabel = initialize_field(schema.fields[0], options?.priorityLabel);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.priorityLabel, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.priorityLabel = decodeUAString(stream, this.priorityLabel);
+    }
+    public get schema(): StructuredTypeSchema { return schemaTransmitQosPriorityDataType; }
+}
+TransmitQosPriorityDataType.schema.dataTypeNodeId = TransmitQosPriorityDataType.dataTypeNodeId;
+TransmitQosPriorityDataType.schema.encodingDefaultBinary = TransmitQosPriorityDataType.encodingDefaultBinary;
+TransmitQosPriorityDataType.schema.encodingDefaultXml = TransmitQosPriorityDataType.encodingDefaultXml;
+TransmitQosPriorityDataType.schema.encodingDefaultJson = TransmitQosPriorityDataType.encodingDefaultJson;
+registerClassDefinition( TransmitQosPriorityDataType.dataTypeNodeId, "TransmitQosPriorityDataType", TransmitQosPriorityDataType);
+// --------------------------------------------------------------------------------------------
 const schemaTrustListDataType = buildStructuredType({
     name: "TrustListDataType",
 
@@ -26994,6 +28800,77 @@ UnregisterNodesResponse.schema.encodingDefaultBinary = UnregisterNodesResponse.e
 UnregisterNodesResponse.schema.encodingDefaultXml = UnregisterNodesResponse.encodingDefaultXml;
 UnregisterNodesResponse.schema.encodingDefaultJson = UnregisterNodesResponse.encodingDefaultJson;
 registerClassDefinition( UnregisterNodesResponse.dataTypeNodeId, "UnregisterNodesResponse", UnregisterNodesResponse);
+// --------------------------------------------------------------------------------------------
+const schemaUnsignedRationalNumber = buildStructuredType({
+    name: "UnsignedRationalNumber",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "numerator",
+
+            fieldType: "UInt32",
+        },
+        {
+            name: "denominator",
+
+            fieldType: "UInt32",
+        },
+    ]
+});
+export interface UnsignedRationalNumberOptions {
+    numerator?: UInt32 ;
+    denominator?: UInt32 ;
+}
+export class UnsignedRationalNumber extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaUnsignedRationalNumber; }
+    public static possibleFields: string[] = [
+          "numerator",
+           "denominator"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(24107, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(24110, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(24122, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24134, 0);
+    public numerator: UInt32;
+    public denominator: UInt32;
+
+    constructor(options?: UnsignedRationalNumberOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.numerator = 0;
+            this.denominator = 0;
+              return;
+        }
+        const schema = UnsignedRationalNumber.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as UnsignedRationalNumberOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.numerator = initialize_field(schema.fields[0], options?.numerator);
+        this.denominator = initialize_field(schema.fields[1], options?.denominator);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUInt32(this.numerator, stream);
+        encodeUInt32(this.denominator, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.numerator = decodeUInt32(stream, this.numerator);
+        this.denominator = decodeUInt32(stream, this.denominator);
+    }
+    public get schema(): StructuredTypeSchema { return schemaUnsignedRationalNumber; }
+}
+UnsignedRationalNumber.schema.dataTypeNodeId = UnsignedRationalNumber.dataTypeNodeId;
+UnsignedRationalNumber.schema.encodingDefaultBinary = UnsignedRationalNumber.encodingDefaultBinary;
+UnsignedRationalNumber.schema.encodingDefaultXml = UnsignedRationalNumber.encodingDefaultXml;
+UnsignedRationalNumber.schema.encodingDefaultJson = UnsignedRationalNumber.encodingDefaultJson;
+registerClassDefinition( UnsignedRationalNumber.dataTypeNodeId, "UnsignedRationalNumber", UnsignedRationalNumber);
 
 // --------------------------------------------------------------------------------------------
 export enum PerformUpdateType {
@@ -27289,6 +29166,122 @@ UpdateStructureDataDetails.schema.encodingDefaultBinary = UpdateStructureDataDet
 UpdateStructureDataDetails.schema.encodingDefaultXml = UpdateStructureDataDetails.encodingDefaultXml;
 UpdateStructureDataDetails.schema.encodingDefaultJson = UpdateStructureDataDetails.encodingDefaultJson;
 registerClassDefinition( UpdateStructureDataDetails.dataTypeNodeId, "UpdateStructureDataDetails", UpdateStructureDataDetails);
+
+// --------------------------------------------------------------------------------------------
+export enum UserConfigurationMask {
+    None = 0,
+    NoDelete = 1,
+    Disabled = 2,
+    NoChangeByUser = 4,
+    MustChangePassword = 8
+}
+const schemaUserConfigurationMask = {
+    enumValues: UserConfigurationMask,
+    flaggable: true,
+    name: "UserConfigurationMask"
+};
+function decodeUserConfigurationMask(stream: BinaryStream, _value?: UserConfigurationMask): UserConfigurationMask {
+    return  stream.readUInt32() as UserConfigurationMask;
+}
+function encodeUserConfigurationMask(value: UserConfigurationMask, stream: OutputBinaryStream): void {
+    stream.writeUInt32(value);
+}
+export const _enumerationUserConfigurationMask = registerEnumeration(schemaUserConfigurationMask);
+assert(_enumerationUserConfigurationMask.isFlaggable ===  true);
+// --------------------------------------------------------------------------------------------
+const schemaUserManagementDataType = buildStructuredType({
+    name: "UserManagementDataType",
+
+    baseType: "ExtensionObject",
+    fields: [
+        {
+            name: "userName",
+
+            fieldType: "UAString",
+        },
+        {
+            name: "userConfiguration",
+
+            fieldType: "UserConfigurationMask",
+        },
+        {
+            name: "description",
+
+            fieldType: "UAString",
+        },
+    ]
+});
+export interface UserManagementDataTypeOptions {
+    userName?: UAString ;
+    userConfiguration?: UserConfigurationMask;
+    description?: UAString ;
+}
+export class UserManagementDataType extends ExtensionObject {
+    public static get schema(): StructuredTypeSchema { return schemaUserManagementDataType; }
+    public static possibleFields: string[] = [
+          "userName",
+           "userConfiguration",
+           "description"
+    ];
+    public static dataTypeNodeId = makeExpandedNodeId(24281, 0);
+    public static encodingDefaultBinary = makeExpandedNodeId(24292, 0);
+    public static encodingDefaultXml = makeExpandedNodeId(24296, 0);
+    public static encodingDefaultJson = makeExpandedNodeId(24300, 0);
+    public userName: UAString;
+    public userConfiguration: UserConfigurationMask;
+    public description: UAString;
+
+    constructor(options?: UserManagementDataTypeOptions | null) {
+
+        super(options);
+
+        if (options === null) {
+            this.userName = null;
+             this.userConfiguration =  0 as  UserConfigurationMask;
+            this.description = null;
+              return;
+        }
+        const schema = UserManagementDataType.schema;
+        options = (schema.constructHook ? schema.constructHook(options) as UserManagementDataTypeOptions: options ) || {};
+        /* istanbul ignore next */
+        if (parameters.debugSchemaHelper) {
+            check_options_correctness_against_schema(this, schema, options);
+        }
+        this.userName = initialize_field(schema.fields[0], options?.userName);
+        this.userConfiguration = this.setUserConfiguration(initialize_field(schema.fields[1], options?.userConfiguration));
+        this.description = initialize_field(schema.fields[2], options?.description);
+    }
+     public encode(stream: OutputBinaryStream): void {
+        /* NEEDED */ super.encode(stream);
+        encodeUAString(this.userName, stream);
+        encodeUserConfigurationMask(this.userConfiguration, stream);
+        encodeUAString(this.description, stream);
+    }
+    public decode(stream: BinaryStream): void {
+        // call base class implementation first
+        /* NEEDED !!! */ super.decode(stream);
+        this.userName = decodeUAString(stream, this.userName);
+        this.userConfiguration = decodeUserConfigurationMask(stream, this.userConfiguration);
+        this.description = decodeUAString(stream, this.description);
+    }
+
+    // Define Enumeration setters
+    public setUserConfiguration(value: any): UserConfigurationMask {
+        const coercedValue = _enumerationUserConfigurationMask.get(value);
+        /* istanbul ignore next */
+        if (coercedValue === undefined || coercedValue === null) {
+           throw new Error("value cannot be coerced to UserConfigurationMask :" + value);
+        }
+        this.userConfiguration = coercedValue.value as UserConfigurationMask;
+        return this.userConfiguration;
+    }
+    public get schema(): StructuredTypeSchema { return schemaUserManagementDataType; }
+}
+UserManagementDataType.schema.dataTypeNodeId = UserManagementDataType.dataTypeNodeId;
+UserManagementDataType.schema.encodingDefaultBinary = UserManagementDataType.encodingDefaultBinary;
+UserManagementDataType.schema.encodingDefaultXml = UserManagementDataType.encodingDefaultXml;
+UserManagementDataType.schema.encodingDefaultJson = UserManagementDataType.encodingDefaultJson;
+registerClassDefinition( UserManagementDataType.dataTypeNodeId, "UserManagementDataType", UserManagementDataType);
 // --------------------------------------------------------------------------------------------
 const schemaUserNameIdentityToken = buildStructuredType({
     name: "UserNameIdentityToken",