opcua-webapi-ts 1.0.19

package/dist/cjs/common/structure/UaHistoryEvent.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaHistoryEvent = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const mapper_1 = require("../mapper");
+const nodes_1 = require("../nodes");
+class UaHistoryEvent {
+    constructor(events) {
+        this._events = events;
+    }
+    get events() {
+        return this._events;
+    }
+    toStruct() {
+        let events = [];
+        for (let item of this._events) {
+            let eventFields = [];
+            for (let item2 of item.eventFields) {
+                eventFields.push(mapper_1.UaPayloadMapper.variantToWebApi(item2));
+            }
+            let fieldList = { EventFields: eventFields };
+            events.push(fieldList);
+        }
+        let historyEvent = { Events: events };
+        return historyEvent;
+    }
+    static fromStruct(historyEvent) {
+        try {
+            let events = [];
+            if (historyEvent.Events) {
+                for (let item of historyEvent.Events) {
+                    if (undefined == item.EventFields)
+                        continue;
+                    let eventFields = [];
+                    for (let item2 of item.EventFields) {
+                        eventFields.push(mapper_1.UaPayloadMapper.variantFromWebApi(item2));
+                    }
+                    events.push(new types_1.UaHistoryEventFieldList(eventFields));
+                }
+            }
+            return new UaHistoryEvent(events);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaHistoryEvent.dataTypeId, (0, opcua_webapi_1.HistoryEventToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaHistoryEvent.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let historyEvent = (0, opcua_webapi_1.HistoryEventFromJSON)(extensionObject.body);
+        return UaHistoryEvent.fromStruct(historyEvent);
+    }
+}
+exports.UaHistoryEvent = UaHistoryEvent;
+UaHistoryEvent.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.HistoryEvent);

package/dist/cjs/common/structure/UaLiteralOperand.d.ts

@@ -0,0 +1,12 @@
+import { LiteralOperand } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId, UaVariant } from "../types";
+export declare class UaLiteralOperand {
+    static dataTypeId: UaNodeId;
+    private _value;
+    constructor(value: UaVariant);
+    get value(): UaVariant;
+    toStruct(): LiteralOperand;
+    static fromStruct(operand: LiteralOperand): UaLiteralOperand | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaLiteralOperand | null;
+}

package/dist/cjs/common/structure/UaLiteralOperand.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaLiteralOperand = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const mapper_1 = require("../mapper");
+const nodes_1 = require("../nodes");
+class UaLiteralOperand {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    toStruct() {
+        let operand = {
+            Value: mapper_1.UaPayloadMapper.variantToWebApi(this._value)
+        };
+        return operand;
+    }
+    static fromStruct(operand) {
+        if (null == operand.Value)
+            return null;
+        try {
+            let value = mapper_1.UaPayloadMapper.variantFromWebApi(operand.Value);
+            return new UaLiteralOperand(value);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaLiteralOperand.dataTypeId, (0, opcua_webapi_1.LiteralOperandToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaLiteralOperand.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let operand = (0, opcua_webapi_1.LiteralOperandFromJSON)(extensionObject.body);
+        return UaLiteralOperand.fromStruct(operand);
+    }
+}
+exports.UaLiteralOperand = UaLiteralOperand;
+UaLiteralOperand.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.LiteralOperand);

package/dist/cjs/common/structure/UaRange.d.ts

@@ -0,0 +1,14 @@
+import { Range } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaRange {
+    static dataTypeId: UaNodeId;
+    private _low;
+    private _high;
+    constructor(low: number | null, high: number | null);
+    get low(): number | null;
+    get high(): number | null;
+    toStruct(): Range;
+    static fromStruct(range: Range): UaRange | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaRange | null;
+}

package/dist/cjs/common/structure/UaRange.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaRange = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+class UaRange {
+    constructor(low, high) {
+        this._low = (low) ? low : Number.MIN_SAFE_INTEGER;
+        this._high = (high) ? high : Number.MAX_SAFE_INTEGER;
+        if (this._high < this._low) {
+            let tmp = this._high;
+            this._low = this._high;
+            this._high = tmp;
+        }
+    }
+    get low() {
+        return this._low;
+    }
+    get high() {
+        return this._high;
+    }
+    toStruct() {
+        let range = {
+            Low: this._low,
+            High: this._high
+        };
+        return range;
+    }
+    static fromStruct(range) {
+        return new UaRange(range.Low, range.High);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaRange.dataTypeId, (0, opcua_webapi_1.RangeToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaRange.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let range = (0, opcua_webapi_1.RangeFromJSON)(extensionObject.body);
+        return UaRange.fromStruct(range);
+    }
+}
+exports.UaRange = UaRange;
+UaRange.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.Range);

package/dist/cjs/common/structure/UaReadAtTimeDetails.d.ts

@@ -0,0 +1,14 @@
+import { ReadAtTimeDetails } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaReadAtTimeDetails {
+    static dataTypeId: UaNodeId;
+    private _reqTimes;
+    private _useSimpleBounds;
+    constructor(reqTimes: Array<Date>, useSimpleBounds?: boolean | null);
+    get reqTimes(): Date[];
+    get useSimpleBounds(): boolean;
+    toStruct(): ReadAtTimeDetails;
+    static fromStruct(details: ReadAtTimeDetails): UaReadAtTimeDetails | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaReadAtTimeDetails | null;
+}

package/dist/cjs/common/structure/UaReadAtTimeDetails.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaReadAtTimeDetails = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+class UaReadAtTimeDetails {
+    constructor(reqTimes, useSimpleBounds) {
+        this._reqTimes = reqTimes;
+        this._useSimpleBounds = (useSimpleBounds) ? true : false;
+    }
+    get reqTimes() {
+        return this._reqTimes;
+    }
+    get useSimpleBounds() {
+        return this._useSimpleBounds;
+    }
+    toStruct() {
+        let details = {
+            ReqTimes: this.reqTimes,
+            UseSimpleBounds: this.useSimpleBounds
+        };
+        return details;
+    }
+    static fromStruct(details) {
+        if (!details.ReqTimes)
+            return null;
+        return new UaReadAtTimeDetails(details.ReqTimes, details.UseSimpleBounds);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaReadAtTimeDetails.dataTypeId, (0, opcua_webapi_1.ReadAtTimeDetailsToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaReadAtTimeDetails.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let details = (0, opcua_webapi_1.ReadAtTimeDetailsFromJSON)(extensionObject.body);
+        return UaReadAtTimeDetails.fromStruct(details);
+    }
+}
+exports.UaReadAtTimeDetails = UaReadAtTimeDetails;
+UaReadAtTimeDetails.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ReadAtTimeDetails);

package/dist/cjs/common/structure/UaReadEventDetails.d.ts

@@ -0,0 +1,19 @@
+import { ReadEventDetails } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+import { UaEventFilter } from ".";
+export declare class UaReadEventDetails {
+    static dataTypeId: UaNodeId;
+    private _startTime;
+    private _endTime;
+    private _filter;
+    private _numValuesPerNode;
+    constructor(startTime: Date, endTime: Date, filter: UaEventFilter, numValuesPerNode?: number);
+    get startTime(): Date;
+    get endTime(): Date;
+    get filter(): UaEventFilter;
+    get numValuesPerNode(): number;
+    toStruct(): ReadEventDetails;
+    static fromStruct(details: ReadEventDetails): UaReadEventDetails | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaReadEventDetails | null;
+}

package/dist/cjs/common/structure/UaReadEventDetails.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaReadEventDetails = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+const _1 = require(".");
+class UaReadEventDetails {
+    constructor(startTime, endTime, filter, numValuesPerNode) {
+        this._startTime = startTime;
+        this._endTime = endTime;
+        this._filter = filter;
+        this._numValuesPerNode = (numValuesPerNode && numValuesPerNode > 0) ? numValuesPerNode : 0;
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    get filter() {
+        return this._filter;
+    }
+    get numValuesPerNode() {
+        return this._numValuesPerNode;
+    }
+    toStruct() {
+        let details = {
+            StartTime: this.startTime,
+            EndTime: this.endTime,
+            Filter: this.filter.toStruct(),
+            NumValuesPerNode: this.numValuesPerNode
+        };
+        return details;
+    }
+    static fromStruct(details) {
+        if (undefined == details.StartTime || !(details.StartTime instanceof Date) ||
+            undefined == details.EndTime || !(details.EndTime instanceof Date) ||
+            undefined == details.Filter)
+            return null;
+        let filter = _1.UaEventFilter.fromStruct(details.Filter);
+        if (null == filter)
+            return null;
+        return new UaReadEventDetails(details.StartTime, details.EndTime, filter, details.NumValuesPerNode);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaReadEventDetails.dataTypeId, (0, opcua_webapi_1.ReadEventDetailsToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaReadEventDetails.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let details = (0, opcua_webapi_1.ReadEventDetailsFromJSON)(extensionObject.body);
+        return UaReadEventDetails.fromStruct(details);
+    }
+}
+exports.UaReadEventDetails = UaReadEventDetails;
+UaReadEventDetails.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ReadEventDetails);

package/dist/cjs/common/structure/UaReadRawModifiedDetails.d.ts

@@ -0,0 +1,20 @@
+import { ReadRawModifiedDetails } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaReadRawModifiedDetails {
+    static dataTypeId: UaNodeId;
+    private _startTime;
+    private _endTime;
+    private _numValuesPerNode;
+    private _returnBounds;
+    private _isReadModified;
+    constructor(startTime: Date, endTime: Date, numValuesPerNode?: number, returnBounds?: boolean | null, isReadModified?: boolean | null);
+    get startTime(): Date;
+    get endTime(): Date;
+    get numValuesPerNode(): number;
+    get returnBounds(): boolean;
+    get isReadModified(): boolean;
+    toStruct(): ReadRawModifiedDetails;
+    static fromStruct(details: ReadRawModifiedDetails): UaReadRawModifiedDetails | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaReadRawModifiedDetails | null;
+}

package/dist/cjs/common/structure/UaReadRawModifiedDetails.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaReadRawModifiedDetails = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+class UaReadRawModifiedDetails {
+    constructor(startTime, endTime, numValuesPerNode, returnBounds, isReadModified) {
+        this._startTime = startTime;
+        this._endTime = endTime;
+        this._numValuesPerNode = (numValuesPerNode > 0) ? numValuesPerNode : 0;
+        this._returnBounds = (returnBounds) ? returnBounds : null;
+        this._isReadModified = (isReadModified) ? isReadModified : null;
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    get numValuesPerNode() {
+        return this._numValuesPerNode;
+    }
+    get returnBounds() {
+        return this._returnBounds;
+    }
+    get isReadModified() {
+        return this._isReadModified;
+    }
+    toStruct() {
+        let details = {
+            StartTime: this.startTime,
+            EndTime: this.endTime,
+            NumValuesPerNode: this.numValuesPerNode,
+            ReturnBounds: this.returnBounds,
+            IsReadModified: this.isReadModified
+        };
+        return details;
+    }
+    static fromStruct(details) {
+        let startTime = details.StartTime;
+        let endTime = details.EndTime;
+        if (null == startTime || null == endTime)
+            return null;
+        return new UaReadRawModifiedDetails(startTime, endTime, details.NumValuesPerNode, details.ReturnBounds, details.IsReadModified);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaReadRawModifiedDetails.dataTypeId, (0, opcua_webapi_1.ReadRawModifiedDetailsToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaReadRawModifiedDetails.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let details = (0, opcua_webapi_1.ReadRawModifiedDetailsFromJSON)(extensionObject.body);
+        return UaReadRawModifiedDetails.fromStruct(details);
+    }
+}
+exports.UaReadRawModifiedDetails = UaReadRawModifiedDetails;
+UaReadRawModifiedDetails.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ReadRawModifiedDetails);

package/dist/cjs/common/structure/UaSimpleAttributeOperand.d.ts

@@ -0,0 +1,14 @@
+import { SimpleAttributeOperand } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaSimpleAttributeOperand {
+    static dataTypeId: UaNodeId;
+    private _browsePath;
+    private _typeDefinitionId;
+    constructor(browsePath: Array<string>, typeDefinitionId?: UaNodeId | null);
+    get browsePath(): Array<string>;
+    get typeDefinitionId(): UaNodeId;
+    toStruct(): SimpleAttributeOperand;
+    static fromStruct(operand: SimpleAttributeOperand): UaSimpleAttributeOperand | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaSimpleAttributeOperand | null;
+}

package/dist/cjs/common/structure/UaSimpleAttributeOperand.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaSimpleAttributeOperand = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+class UaSimpleAttributeOperand {
+    constructor(browsePath, typeDefinitionId) {
+        this._browsePath = browsePath;
+        this._typeDefinitionId = (typeDefinitionId) ? typeDefinitionId : types_1.UaNodeId.nullNodeId;
+    }
+    get browsePath() {
+        return this._browsePath;
+    }
+    get typeDefinitionId() {
+        return this._typeDefinitionId;
+    }
+    toStruct() {
+        let operand = {
+            BrowsePath: this._browsePath,
+            TypeDefinitionId: (!this._typeDefinitionId.isEmpty()) ? this._typeDefinitionId.toString() : undefined
+        };
+        return operand;
+    }
+    static fromStruct(operand) {
+        if (null == operand.BrowsePath)
+            return null;
+        let browsePath = operand.BrowsePath;
+        let dataTypeId = (0, types_1.parseUaNodeIdOrNull)(operand.TypeDefinitionId);
+        return new UaSimpleAttributeOperand(browsePath, dataTypeId);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaSimpleAttributeOperand.dataTypeId, (0, opcua_webapi_1.SimpleAttributeOperandToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaSimpleAttributeOperand.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let operand = (0, opcua_webapi_1.SimpleAttributeOperandFromJSON)(extensionObject.body);
+        return UaSimpleAttributeOperand.fromStruct(operand);
+    }
+}
+exports.UaSimpleAttributeOperand = UaSimpleAttributeOperand;
+UaSimpleAttributeOperand.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.SimpleAttributeOperand);

package/dist/cjs/common/structure/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./UaArgument";
+export * from "./UaContentFilter";
+export * from "./UaContentFilterElement";
+export * from "./UaElementOperand";
+export * from "./UaEnumValueType";
+export * from "./UaEUInformation";
+export * from "./UaEventFilter";
+export * from "./UaHistoryData";
+export * from "./UaHistoryEvent";
+export * from "./UaLiteralOperand";
+export * from "./UaRange";
+export * from "./UaReadAtTimeDetails";
+export * from "./UaReadEventDetails";
+export * from "./UaReadRawModifiedDetails";
+export * from "./UaSimpleAttributeOperand";

package/dist/cjs/common/structure/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./UaArgument"), exports);
+__exportStar(require("./UaContentFilter"), exports);
+__exportStar(require("./UaContentFilterElement"), exports);
+__exportStar(require("./UaElementOperand"), exports);
+__exportStar(require("./UaEnumValueType"), exports);
+__exportStar(require("./UaEUInformation"), exports);
+__exportStar(require("./UaEventFilter"), exports);
+__exportStar(require("./UaHistoryData"), exports);
+__exportStar(require("./UaHistoryEvent"), exports);
+__exportStar(require("./UaLiteralOperand"), exports);
+__exportStar(require("./UaRange"), exports);
+__exportStar(require("./UaReadAtTimeDetails"), exports);
+__exportStar(require("./UaReadEventDetails"), exports);
+__exportStar(require("./UaReadRawModifiedDetails"), exports);
+__exportStar(require("./UaSimpleAttributeOperand"), exports);

package/dist/cjs/common/types/UaDataValue.d.ts

@@ -0,0 +1,14 @@
+import { UaStatusCode } from "./UaStatusCode";
+import { UaVariant } from "./UaVariant";
+export declare class UaDataValue {
+    private _value;
+    private _statusCode;
+    private _sourceTimestamp;
+    private _serverTimestamp;
+    constructor(value: UaVariant, statusCode?: UaStatusCode, sourceTimestamp?: Date, serverTimestamp?: Date);
+    get value(): UaVariant;
+    get statusCode(): UaStatusCode;
+    get sourceTimestamp(): Date | null;
+    get serverTimestamp(): Date | null;
+    static dataValue(value: UaVariant, timeStamp?: Date): UaDataValue;
+}

package/dist/cjs/common/types/UaDataValue.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaDataValue = void 0;
+const UaStatusCode_1 = require("./UaStatusCode");
+class UaDataValue {
+    constructor(value, statusCode, sourceTimestamp, serverTimestamp) {
+        this._value = value;
+        this._statusCode = (statusCode) ? statusCode : (0, UaStatusCode_1.makeUaStatusCode)();
+        this._sourceTimestamp = (sourceTimestamp) ? sourceTimestamp : null;
+        this._serverTimestamp = (serverTimestamp) ? serverTimestamp : null;
+    }
+    get value() {
+        return this._value;
+    }
+    get statusCode() {
+        return this._statusCode;
+    }
+    get sourceTimestamp() {
+        return this._sourceTimestamp;
+    }
+    get serverTimestamp() {
+        return this._serverTimestamp;
+    }
+    static dataValue(value, timeStamp) {
+        return new UaDataValue(value, undefined, timeStamp, timeStamp);
+    }
+}
+exports.UaDataValue = UaDataValue;

package/dist/cjs/common/types/UaError.d.ts

@@ -0,0 +1,6 @@
+import { UaStatusCode } from ".";
+export declare class UaError extends Error {
+    private readonly _statusCode;
+    constructor(statusCode: UaStatusCode);
+    get statusCode(): UaStatusCode;
+}

package/dist/cjs/common/types/UaError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaError = void 0;
+class UaError extends Error {
+    constructor(statusCode) {
+        super();
+        this._statusCode = statusCode;
+        this.name = statusCode.name;
+        this.message = statusCode.name;
+    }
+    get statusCode() {
+        return this._statusCode;
+    }
+}
+exports.UaError = UaError;

package/dist/cjs/common/types/UaExpandedNodeId.d.ts

@@ -0,0 +1,15 @@
+import { UaNodeId } from ".";
+export declare class UaExpandedNodeId {
+    private _nodeId;
+    private _namespaceUri;
+    private _serverIndex;
+    constructor(nodeId: UaNodeId, namespaceUri?: string | null, serverIndex?: number);
+    get namespaceUri(): string | null;
+    get serverIndex(): number;
+    isEmpty(): boolean;
+    equal(other: UaExpandedNodeId): boolean;
+    isLocalNodeId(): boolean;
+    getNodeId(namespaceUris?: Array<string>): UaNodeId | null;
+    toString(): string;
+}
+export declare function parseUaExpandedNodeId(value: string): UaExpandedNodeId;

package/dist/cjs/common/types/UaExpandedNodeId.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaExpandedNodeId = void 0;
+exports.parseUaExpandedNodeId = parseUaExpandedNodeId;
+/**
+ * @module node-opcua-nodeid
+ */
+const _1 = require(".");
+class UaExpandedNodeId {
+    constructor(nodeId, namespaceUri, serverIndex) {
+        this._nodeId = nodeId;
+        this._namespaceUri = (namespaceUri) ? namespaceUri : null;
+        this._serverIndex = (serverIndex) ? serverIndex : 0;
+    }
+    get namespaceUri() {
+        return this._namespaceUri;
+    }
+    get serverIndex() {
+        return this._serverIndex;
+    }
+    isEmpty() {
+        return this._nodeId.isEmpty();
+    }
+    equal(other) {
+        if (!this._nodeId.equal(other._nodeId))
+            return false;
+        if (this._serverIndex !== other._serverIndex)
+            return false;
+        if (this._namespaceUri !== other._namespaceUri)
+            return false;
+        return true;
+    }
+    isLocalNodeId() {
+        return (this._namespaceUri) ? false : true;
+    }
+    getNodeId(namespaceUris) {
+        if (this.isLocalNodeId())
+            return this._nodeId;
+        // To be implemented
+        return null;
+    }
+    toString() {
+        // To be implemented  
+        return this._nodeId.toString();
+    }
+}
+exports.UaExpandedNodeId = UaExpandedNodeId;
+function parseUaExpandedNodeId(value) {
+    let nodeId = (0, _1.parseUaNodeId)(value);
+    return new UaExpandedNodeId(nodeId, null, 0);
+}

package/dist/cjs/common/types/UaExtensionObject.d.ts

@@ -0,0 +1,9 @@
+import { UaNodeId } from ".";
+export declare class UaExtensionObject {
+    private _typeId;
+    private _body;
+    constructor(typeId: UaNodeId, body: any);
+    isValid(): boolean;
+    get body(): any;
+    get typeId(): UaNodeId;
+}

package/dist/cjs/common/types/UaExtensionObject.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaExtensionObject = void 0;
+class UaExtensionObject {
+    constructor(typeId, body) {
+        this._typeId = typeId;
+        this._body = body;
+    }
+    isValid() {
+        return (this._typeId.isEmpty()) ? false : true;
+    }
+    get body() {
+        return this._body;
+    }
+    get typeId() {
+        return this._typeId;
+    }
+}
+exports.UaExtensionObject = UaExtensionObject;