opcua-webapi-ts 1.0.19

package/dist/common/nodes/UaVariableType.d.ts

@@ -0,0 +1,14 @@
+import { NodeClass } from "opcua-webapi";
+import { UaLocalizedText, UaNodeId } from "../types";
+import { UaDefintionNode, UaVariable } from ".";
+export declare class UaVariableType extends UaDefintionNode {
+    private _dataType;
+    private _valueRank;
+    constructor(nodeId: UaNodeId, browseName: string, displayName: UaLocalizedText, isAbstract: boolean, dataType: UaNodeId, valueRank: number);
+    get nodeClass(): NodeClass;
+    get dataType(): UaNodeId;
+    get valueRank(): number;
+    addMember(node: UaVariable): void;
+    get variableMembers(): Array<UaVariable>;
+    toJson(): any;
+}

package/dist/common/nodes/UaVariableType.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaVariableType = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+class UaVariableType extends _1.UaDefintionNode {
+    constructor(nodeId, browseName, displayName, isAbstract, dataType, valueRank) {
+        super(nodeId, browseName, displayName, isAbstract);
+        this._dataType = dataType;
+        this._valueRank = valueRank;
+    }
+    get nodeClass() {
+        return opcua_webapi_1.NodeClass.VariableType;
+    }
+    get dataType() {
+        return this._dataType;
+    }
+    get valueRank() {
+        return this._valueRank;
+    }
+    addMember(node) {
+        this._children.push(node);
+    }
+    get variableMembers() {
+        let ret = [];
+        for (let item of this._children) {
+            ret.push(item);
+        }
+        return ret;
+    }
+    toJson() {
+        let children = [];
+        for (let item of this._children) {
+            if (item.nodeClass != opcua_webapi_1.NodeClass.Variable)
+                continue;
+            children.push(item.toJson());
+        }
+        let ret = {
+            nodeId: this._nodeId.toString(),
+            nodeClass: opcua_webapi_1.NodeClass.VariableType,
+            name: this._browseName,
+            displayName: this._displayName.text,
+            description: (this._description) ? this._description.text : undefined,
+            isAbstract: this._isAbstract,
+            children: (children.length != 0) ? children : undefined
+        };
+        return ret;
+    }
+}
+exports.UaVariableType = UaVariableType;

package/dist/common/nodes/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./Identifiers";
+export * from "./UaNode";
+export * from "./UaObjectType";
+export * from "./UaVariableType";
+export * from "./UaDataType";
+export * from "./UaReferenceType";
+export * from "./UaAttributes";
+export * from "./UaObject";
+export * from "./UaVariable";
+export * from "./UaMethod";

package/dist/common/nodes/index.js

@@ -0,0 +1,26 @@
+"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("./Identifiers"), exports);
+__exportStar(require("./UaNode"), exports);
+__exportStar(require("./UaObjectType"), exports);
+__exportStar(require("./UaVariableType"), exports);
+__exportStar(require("./UaDataType"), exports);
+__exportStar(require("./UaReferenceType"), exports);
+__exportStar(require("./UaAttributes"), exports);
+__exportStar(require("./UaObject"), exports);
+__exportStar(require("./UaVariable"), exports);
+__exportStar(require("./UaMethod"), exports);

package/dist/common/structure/UaArgument.d.ts

@@ -0,0 +1,19 @@
+import { Argument } from "opcua-webapi";
+import { UaExtensionObject, UaLocalizedText, UaNodeId } from "../types";
+export declare class UaArgument {
+    static dataTypeId: UaNodeId;
+    private _name;
+    private _dataType;
+    private _valueRank;
+    private _description;
+    constructor(name: string, dataType: UaNodeId, valueRank?: number | null, description?: UaLocalizedText | null);
+    get name(): string;
+    get dataType(): UaNodeId;
+    get valueRank(): number;
+    get description(): UaLocalizedText | null;
+    toStruct(): Argument;
+    static fromStruct(argument: Argument): UaArgument | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaArgument | null;
+    toJson(): any;
+}

package/dist/common/structure/UaArgument.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaArgument = 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 UaArgument {
+    constructor(name, dataType, valueRank, description) {
+        this._name = name;
+        this._dataType = dataType;
+        this._valueRank = (undefined != valueRank) ? valueRank : -1;
+        this._description = (description) ? description : null;
+    }
+    get name() {
+        return this._name;
+    }
+    get dataType() {
+        return this._dataType;
+    }
+    get valueRank() {
+        return this._valueRank;
+    }
+    get description() {
+        return this._description;
+    }
+    toStruct() {
+        let argument = {
+            Name: this._name,
+            DataType: this._dataType.toString(),
+            ValueRank: this._valueRank,
+            Description: (this._description) ? mapper_1.UaPayloadMapper.localizedTextToWebApi(this._description) : undefined
+        };
+        return argument;
+    }
+    static fromStruct(argument) {
+        let name = (typeof argument.Name === "string") ? argument.Name : null;
+        let dataTypeId = (0, types_1.parseUaNodeIdOrNull)(argument.DataType);
+        let valueRank = (typeof argument.ValueRank === "number") ? argument.ValueRank : -1;
+        let description = (argument.Description) ? mapper_1.UaPayloadMapper.localizedTextFromWebApi(argument.Description) : null;
+        if (null == dataTypeId || null == name)
+            return null;
+        return new UaArgument(name, dataTypeId, valueRank, description);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaArgument.dataTypeId, (0, opcua_webapi_1.ArgumentToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaArgument.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let argument = (0, opcua_webapi_1.ArgumentFromJSON)(extensionObject.body);
+        return UaArgument.fromStruct(argument);
+    }
+    toJson() {
+        let ret = {
+            name: this._name,
+            dataType: this._dataType.toString(),
+            valueRank: this._valueRank,
+            description: (this._description) ? this._description.text : undefined
+        };
+        return ret;
+    }
+}
+exports.UaArgument = UaArgument;
+UaArgument.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.Argument);

package/dist/common/structure/UaContentFilter.d.ts

@@ -0,0 +1,13 @@
+import { ContentFilter } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+import { UaContentFilterElement } from "./UaContentFilterElement";
+export declare class UaContentFilter {
+    static dataTypeId: UaNodeId;
+    private _elements;
+    constructor(elements: Array<UaContentFilterElement>);
+    get elements(): Array<UaContentFilterElement>;
+    toStruct(): ContentFilter;
+    static fromStruct(filter: ContentFilter): UaContentFilter | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaContentFilter | null;
+}

package/dist/common/structure/UaContentFilter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaContentFilter = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+const UaContentFilterElement_1 = require("./UaContentFilterElement");
+class UaContentFilter {
+    constructor(elements) {
+        this._elements = elements;
+    }
+    get elements() {
+        return this._elements;
+    }
+    toStruct() {
+        let elements = [];
+        for (let item of this._elements) {
+            elements.push(item.toStruct());
+        }
+        let contentFilter = {
+            Elements: elements
+        };
+        return contentFilter;
+    }
+    static fromStruct(filter) {
+        if (null == filter.Elements)
+            return null;
+        let elements = [];
+        for (let item of filter.Elements) {
+            let element = UaContentFilterElement_1.UaContentFilterElement.fromStruct(item);
+            if (null == element)
+                return null;
+            elements.push(element);
+        }
+        return new UaContentFilter(elements);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaContentFilter.dataTypeId, (0, opcua_webapi_1.ContentFilterToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaContentFilter.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let filter = (0, opcua_webapi_1.ContentFilterFromJSON)(extensionObject.body);
+        return UaContentFilter.fromStruct(filter);
+    }
+}
+exports.UaContentFilter = UaContentFilter;
+UaContentFilter.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ContentFilter);

package/dist/common/structure/UaContentFilterElement.d.ts

@@ -0,0 +1,12 @@
+import { ContentFilterElement } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaContentFilterElement {
+    static dataTypeId: UaNodeId;
+    private _operands;
+    private _operator;
+    constructor(operands: Array<UaExtensionObject>, operator: number);
+    get operands(): Array<UaExtensionObject>;
+    get operator(): number;
+    toStruct(): ContentFilterElement;
+    static fromStruct(element: ContentFilterElement): UaContentFilterElement | null;
+}

package/dist/common/structure/UaContentFilterElement.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaContentFilterElement = void 0;
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+const mapper_1 = require("../mapper");
+class UaContentFilterElement {
+    constructor(operands, operator) {
+        this._operands = operands;
+        this._operator = operator;
+    }
+    get operands() {
+        return this._operands;
+    }
+    get operator() {
+        return this.operator;
+    }
+    toStruct() {
+        let filterOperands = [];
+        for (let item of this._operands) {
+            filterOperands.push(mapper_1.UaPayloadMapper.extensionObjectToWebApi(item));
+        }
+        let element = {
+            FilterOperands: filterOperands,
+            FilterOperator: this._operator
+        };
+        return element;
+    }
+    static fromStruct(element) {
+        if (undefined == element.FilterOperands || undefined == element.FilterOperator)
+            return null;
+        let operands = [];
+        for (let item of element.FilterOperands) {
+            let operand = mapper_1.UaPayloadMapper.extensionObjectFromWebApi(item);
+            if (null == operand)
+                return null;
+            operands.push(operand);
+        }
+        return new UaContentFilterElement(operands, element.FilterOperator);
+    }
+}
+exports.UaContentFilterElement = UaContentFilterElement;
+UaContentFilterElement.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ContentFilterElement);

package/dist/common/structure/UaEUInformation.d.ts

@@ -0,0 +1,18 @@
+import { EUInformation } from "opcua-webapi";
+import { UaExtensionObject, UaLocalizedText, UaNodeId } from "../types";
+export declare class UaEUInformation {
+    static dataTypeId: UaNodeId;
+    private _unitId;
+    private _displayName;
+    private _description;
+    private _namespaceUri;
+    constructor(unitId: number, displayName: UaLocalizedText, description?: UaLocalizedText | null, namespaceUri?: string | null);
+    get unitId(): number;
+    get displayName(): UaLocalizedText | null;
+    get description(): UaLocalizedText | null;
+    get namespaceUri(): string | null;
+    toStruct(): EUInformation;
+    static fromStruct(euInformation: EUInformation): UaEUInformation | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaEUInformation | null;
+}

package/dist/common/structure/UaEUInformation.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaEUInformation = 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 UaEUInformation {
+    constructor(unitId, displayName, description, namespaceUri) {
+        this._unitId = unitId;
+        this._displayName = displayName;
+        this._description = (description) ? description : null;
+        this._namespaceUri = (namespaceUri) ? namespaceUri : null;
+    }
+    get unitId() {
+        return this._unitId;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get description() {
+        return this._description;
+    }
+    get namespaceUri() {
+        return this._namespaceUri;
+    }
+    toStruct() {
+        let euInformation = {
+            UnitId: this._unitId,
+            DisplayName: mapper_1.UaPayloadMapper.localizedTextToWebApi(this._displayName),
+            Description: (this._description) ? mapper_1.UaPayloadMapper.localizedTextToWebApi(this._description) : undefined,
+            NamespaceUri: (this._namespaceUri) ? this._namespaceUri : undefined
+        };
+        return euInformation;
+    }
+    static fromStruct(euInformation) {
+        let unitId = (typeof euInformation.UnitId === "number") ? euInformation.UnitId : null;
+        let displayName = mapper_1.UaPayloadMapper.localizedTextFromWebApi(euInformation.DisplayName);
+        let description = (euInformation.Description) ? mapper_1.UaPayloadMapper.localizedTextFromWebApi(euInformation.Description) : null;
+        let namespaceUri = (typeof euInformation.NamespaceUri === "string") ? euInformation.NamespaceUri : null;
+        if (null == unitId || null == displayName)
+            return null;
+        return new UaEUInformation(unitId, displayName, description, namespaceUri);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaEUInformation.dataTypeId, (0, opcua_webapi_1.EUInformationToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaEUInformation.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let euInformation = (0, opcua_webapi_1.EUInformationFromJSON)(extensionObject.body);
+        return UaEUInformation.fromStruct(euInformation);
+    }
+}
+exports.UaEUInformation = UaEUInformation;
+UaEUInformation.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.EUInformation);

package/dist/common/structure/UaElementOperand.d.ts

@@ -0,0 +1,12 @@
+import { ElementOperand } from "opcua-webapi";
+import { UaExtensionObject, UaNodeId } from "../types";
+export declare class UaElementOperand {
+    static dataTypeId: UaNodeId;
+    private _index;
+    constructor(index: number);
+    get index(): number;
+    toStruct(): ElementOperand;
+    static fromStruct(operand: ElementOperand): UaElementOperand | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaElementOperand | null;
+}

package/dist/common/structure/UaElementOperand.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaElementOperand = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+class UaElementOperand {
+    constructor(index) {
+        this._index = index;
+    }
+    get index() {
+        return this._index;
+    }
+    toStruct() {
+        let operand = {
+            _Index: this._index
+        };
+        return operand;
+    }
+    static fromStruct(operand) {
+        if (null == operand._Index)
+            return null;
+        return new UaElementOperand(operand._Index);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaElementOperand.dataTypeId, (0, opcua_webapi_1.ElementOperandToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaElementOperand.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let operand = (0, opcua_webapi_1.ElementOperandFromJSON)(extensionObject.body);
+        return UaElementOperand.fromStruct(operand);
+    }
+}
+exports.UaElementOperand = UaElementOperand;
+UaElementOperand.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.ElementOperand);

package/dist/common/structure/UaEnumValueType.d.ts

@@ -0,0 +1,16 @@
+import { EnumValueType } from "opcua-webapi";
+import { UaExtensionObject, UaLocalizedText, UaNodeId } from "../types";
+export declare class UaEnumValueType {
+    static dataTypeId: UaNodeId;
+    private _value;
+    private _displayName;
+    private _description;
+    constructor(value: number, displayName: UaLocalizedText, description: UaLocalizedText);
+    get value(): number;
+    get displayName(): UaLocalizedText;
+    get description(): UaLocalizedText;
+    toStruct(): EnumValueType;
+    static fromStruct(enumValueType: EnumValueType): UaEnumValueType | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaEnumValueType | null;
+}

package/dist/common/structure/UaEnumValueType.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaEnumValueType = 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 UaEnumValueType {
+    constructor(value, displayName, description) {
+        this._value = value;
+        this._displayName = displayName;
+        this._description = description;
+    }
+    get value() {
+        return this._value;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get description() {
+        return this._description;
+    }
+    toStruct() {
+        let enumValue = {
+            Value: this._value,
+            DisplayName: mapper_1.UaPayloadMapper.localizedTextToWebApi(this._displayName),
+            Description: mapper_1.UaPayloadMapper.localizedTextToWebApi(this._description)
+        };
+        return enumValue;
+    }
+    static fromStruct(enumValueType) {
+        let value = (typeof enumValueType.Value === "number") ? enumValueType.Value : null;
+        let displayName = mapper_1.UaPayloadMapper.localizedTextFromWebApi(enumValueType.DisplayName);
+        let description = mapper_1.UaPayloadMapper.localizedTextFromWebApi(enumValueType.Description);
+        return new UaEnumValueType(value, displayName, description);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaEnumValueType.dataTypeId, (0, opcua_webapi_1.EnumValueTypeToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaEnumValueType.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let enumValueType = (0, opcua_webapi_1.EnumValueTypeFromJSON)(extensionObject.body);
+        return UaEnumValueType.fromStruct(enumValueType);
+    }
+}
+exports.UaEnumValueType = UaEnumValueType;
+UaEnumValueType.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.EnumValueType);

package/dist/common/structure/UaEventFilter.d.ts

@@ -0,0 +1,14 @@
+import { EventFilter } from "opcua-webapi";
+import { UaNodeId } from "../types";
+import { UaSimpleAttributeOperand } from "./UaSimpleAttributeOperand";
+import { UaContentFilter } from "./UaContentFilter";
+export declare class UaEventFilter {
+    static dataTypeId: UaNodeId;
+    private _selectClauses;
+    private _whereClause;
+    constructor(selectClauses: Array<UaSimpleAttributeOperand>, whereClause?: UaContentFilter | null);
+    get selectClauses(): Array<UaSimpleAttributeOperand>;
+    get whereClause(): UaContentFilter | null;
+    toStruct(): EventFilter;
+    static fromStruct(filter: EventFilter): UaEventFilter | null;
+}

package/dist/common/structure/UaEventFilter.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaEventFilter = void 0;
+const types_1 = require("../types");
+const nodes_1 = require("../nodes");
+const UaSimpleAttributeOperand_1 = require("./UaSimpleAttributeOperand");
+const UaContentFilter_1 = require("./UaContentFilter");
+class UaEventFilter {
+    constructor(selectClauses, whereClause) {
+        this._selectClauses = selectClauses;
+        this._whereClause = (whereClause) ? whereClause : null;
+    }
+    get selectClauses() {
+        return this._selectClauses;
+    }
+    get whereClause() {
+        return this._whereClause;
+    }
+    toStruct() {
+        let selectClauses = [];
+        for (let item of this._selectClauses) {
+            selectClauses.push(item.toStruct());
+        }
+        let contentFilter = (this._whereClause) ? this._whereClause.toStruct() : undefined;
+        let eventFilter = { SelectClauses: selectClauses, WhereClause: contentFilter };
+        return eventFilter;
+    }
+    static fromStruct(filter) {
+        if (undefined == filter.SelectClauses)
+            return null;
+        let selectClauses = [];
+        for (let item of filter.SelectClauses) {
+            let select = UaSimpleAttributeOperand_1.UaSimpleAttributeOperand.fromStruct(item);
+            if (null == select)
+                return null;
+            selectClauses.push(select);
+        }
+        let where = null;
+        if (undefined != filter.WhereClause) {
+            where = UaContentFilter_1.UaContentFilter.fromStruct(filter.WhereClause);
+            if (null == where)
+                return null;
+        }
+        let eventFilter = new UaEventFilter(selectClauses, where);
+        return eventFilter;
+    }
+}
+exports.UaEventFilter = UaEventFilter;
+UaEventFilter.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.EventFilter);

package/dist/common/structure/UaHistoryData.d.ts

@@ -0,0 +1,12 @@
+import { HistoryData } from "opcua-webapi";
+import { UaDataValue, UaExtensionObject, UaNodeId } from "../types";
+export declare class UaHistoryData {
+    static dataTypeId: UaNodeId;
+    private _dataValues;
+    constructor(dataValues: Array<UaDataValue>);
+    get dataValues(): Array<UaDataValue>;
+    toStruct(): HistoryData;
+    static fromStruct(historyData: HistoryData): UaHistoryData | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaHistoryData | null;
+}

package/dist/common/structure/UaHistoryData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaHistoryData = 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 UaHistoryData {
+    constructor(dataValues) {
+        this._dataValues = dataValues;
+    }
+    get dataValues() {
+        return this._dataValues;
+    }
+    toStruct() {
+        let dataValues = [];
+        for (let item of this._dataValues) {
+            dataValues.push(mapper_1.UaPayloadMapper.dataValueToWebApi(item));
+        }
+        let historyData = { DataValues: dataValues };
+        return historyData;
+    }
+    static fromStruct(historyData) {
+        let dataValues = [];
+        if (historyData.DataValues) {
+            for (let item of historyData.DataValues) {
+                dataValues.push(mapper_1.UaPayloadMapper.dataValueFromWebApi(item));
+            }
+        }
+        return new UaHistoryData(dataValues);
+    }
+    toExtensionObject() {
+        return new types_1.UaExtensionObject(UaHistoryData.dataTypeId, (0, opcua_webapi_1.HistoryDataToJSONTyped)(this.toStruct()));
+    }
+    static fromExtensionObject(extensionObject) {
+        if (!UaHistoryData.dataTypeId.equal(extensionObject.typeId))
+            return null;
+        let historyData = (0, opcua_webapi_1.HistoryDataFromJSON)(extensionObject.body);
+        return UaHistoryData.fromStruct(historyData);
+    }
+}
+exports.UaHistoryData = UaHistoryData;
+UaHistoryData.dataTypeId = new types_1.UaNodeId(nodes_1.DataTypeIds.HistoryData);

package/dist/common/structure/UaHistoryEvent.d.ts

@@ -0,0 +1,12 @@
+import { HistoryEvent } from "opcua-webapi";
+import { UaExtensionObject, UaHistoryEventFieldList, UaNodeId } from "../types";
+export declare class UaHistoryEvent {
+    static dataTypeId: UaNodeId;
+    private _events;
+    constructor(events: Array<UaHistoryEventFieldList>);
+    get events(): Array<UaHistoryEventFieldList>;
+    toStruct(): HistoryEvent;
+    static fromStruct(historyEvent: HistoryEvent): UaHistoryEvent | null;
+    toExtensionObject(): UaExtensionObject;
+    static fromExtensionObject(extensionObject: UaExtensionObject): UaHistoryEvent | null;
+}