opcua-webapi-ts 1.0.19

package/dist/common/types/UaStatusCode.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extraStatusCodeBits = exports.UaStatusCode = void 0;
+exports.makeUaStatusCode = makeUaStatusCode;
+const opcua_webapi_1 = require("opcua-webapi");
+class UaStatusCode {
+    constructor(code) {
+        this._code = (code) ? code : opcua_webapi_1.StatusCodes.Good;
+    }
+    get value() {
+        return this._code;
+    }
+    get name() {
+        if (null == UaStatusCode._codesDictionary) {
+            UaStatusCode._codesDictionary = new Map;
+            for (const key in opcua_webapi_1.StatusCodes) {
+                const value = opcua_webapi_1.StatusCodes[key];
+                UaStatusCode._codesDictionary.set(value, key);
+            }
+        }
+        let name = UaStatusCode._codesDictionary.get(this._code);
+        return (name) ? name : "";
+    }
+    toString() {
+        return this.name + " (0x" + this.value.toString(16).toUpperCase() + ")";
+    }
+    checkBit(mask) {
+        return (this.value & mask) === mask;
+    }
+    /** returns true if the overflow bit is set */
+    get hasOverflowBit() {
+        return this.checkBit(exports.extraStatusCodeBits.Overflow);
+    }
+    /** returns true if the semanticChange bit is set */
+    get hasSemanticChangedBit() {
+        return this.checkBit(exports.extraStatusCodeBits.SemanticChanged);
+    }
+    /** returns true if the structureChange bit is set */
+    get hasStructureChangedBit() {
+        return this.checkBit(exports.extraStatusCodeBits.StructureChanged);
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    isGood() {
+        return this.value < 0x10000000;
+    }
+    isNotGood() {
+        return !this.isGood();
+    }
+    isBad() {
+        return this.value >= 0x80000000;
+    }
+    isUncertain() {
+        return (this.value < 0x80000000 && this.value >= 0x10000000);
+    }
+}
+exports.UaStatusCode = UaStatusCode;
+UaStatusCode._codesDictionary = null;
+exports.extraStatusCodeBits = {
+    StructureChanged: 0x1 << 15,
+    SemanticChanged: 0x1 << 14,
+    InfoTypeDataValue: 0x1 << 10, // 0x0400,
+    LimitLow: 0x1 << 8,
+    LimitHigh: 0x2 << 8,
+    LimitConstant: 0x3 << 8,
+    Overflow: 0x1 << 7, // 1 << 7
+    HistorianCalculated: 0x1 << 0,
+    HistorianInterpolated: 0x2 << 0,
+    HistorianPartial: 0x1 << 2,
+    HistorianExtraData: 0x1 << 3,
+    HistorianMultiValue: 0x1 << 4
+};
+function makeUaStatusCode(code) {
+    return new UaStatusCode(code);
+}

package/dist/common/types/UaTypes.d.ts

@@ -0,0 +1,12 @@
+import { UaArgument } from "../structure";
+import { UaLocalizedText } from "./UaLocalizedText";
+export type UaMethodArguments = {
+    inputArguments: Array<UaArgument>;
+    outputArguments: Array<UaArgument>;
+};
+export type UaApplicationDescriptor = {
+    urls: Array<string>;
+    applicationUri: string;
+    applicationName: UaLocalizedText;
+    productUri: string;
+};

package/dist/common/types/UaTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/types/UaVariant.d.ts

@@ -0,0 +1,89 @@
+import { UaStatusCode, UaNodeId, UaLocalizedText, UaExpandedNodeId, UaExtensionObject } from ".";
+export declare class UaVariant {
+    private _value;
+    private _type;
+    private _arrayType;
+    get value(): any;
+    get type(): UaVariantType;
+    get arrayType(): UaArrayType;
+    isScalar(): boolean;
+    isArray(): boolean;
+    isNull(): boolean;
+    toBoolean(): boolean | null;
+    toNumber(): number | null;
+    toString(): string | null;
+    toDateTime(): Date | null;
+    toNodeId(): UaNodeId | null;
+    toExpandedNodeId(): UaExpandedNodeId | null;
+    toStatusCode(): UaStatusCode | null;
+    toLocalizedText(): UaLocalizedText | null;
+    toExtensionObject(): UaExtensionObject | null;
+    toBooleans(): Array<boolean> | null;
+    toNumbers(): Array<number> | null;
+    toStrings(): Array<string> | null;
+    toDateTimes(): Array<Date> | null;
+    toNodeIds(): Array<UaNodeId> | null;
+    toExpandedNodeIds(): Array<UaExpandedNodeId> | null;
+    toStatusCodes(): Array<UaStatusCode> | null;
+    toLocalizedTexts(): Array<UaLocalizedText> | null;
+    toExtensionObjects(): Array<UaExtensionObject> | null;
+    static null(): UaVariant;
+    static boolean(value: boolean): UaVariant;
+    static integer(value: number, type?: UaVariantType): UaVariant;
+    static float(value: number): UaVariant;
+    static double(value: number): UaVariant;
+    static string(value: string): UaVariant;
+    static dateTime(value: Date): UaVariant;
+    static guid(value: string): UaVariant;
+    static byteString(value: string): UaVariant;
+    static nodeId(value: UaNodeId): UaVariant;
+    static expandedNodeId(value: UaExpandedNodeId): UaVariant;
+    static statusCode(value: UaStatusCode): UaVariant;
+    static qualifiedName(value: string): UaVariant;
+    static localizedText(value: UaLocalizedText): UaVariant;
+    static extensionObject(value: UaExtensionObject): UaVariant;
+    static booleans(value: Array<boolean>): UaVariant;
+    static integers(value: Array<number>, type?: UaVariantType): UaVariant;
+    static floats(value: Array<number>): UaVariant;
+    static doubles(value: Array<number>): UaVariant;
+    static strings(value: Array<string>): UaVariant;
+    static dateTimes(value: Array<Date>): UaVariant;
+    static guids(value: Array<string>): UaVariant;
+    static byteStrings(value: Array<string>): UaVariant;
+    static nodeIds(value: Array<UaNodeId>): UaVariant;
+    static expandedNodeIds(value: Array<UaExpandedNodeId>): UaVariant;
+    static statusCodes(value: Array<UaStatusCode>): UaVariant;
+    static qualifiedNames(value: Array<string>): UaVariant;
+    static localizedTexts(value: Array<UaLocalizedText>): UaVariant;
+    static extensionObjects(value: Array<UaExtensionObject>): UaVariant;
+}
+export declare enum UaVariantType {
+    Null = 0,
+    Boolean = 1,
+    SByte = 2,
+    Byte = 3,
+    Int16 = 4,
+    UInt16 = 5,
+    Int32 = 6,
+    UInt32 = 7,
+    Int64 = 8,
+    UInt64 = 9,
+    Float = 10,
+    Double = 11,
+    String = 12,
+    DateTime = 13,
+    Guid = 14,
+    ByteString = 15,
+    XmlElement = 16,
+    NodeId = 17,
+    ExpandedNodeId = 18,
+    StatusCode = 19,
+    QualifiedName = 20,
+    LocalizedText = 21,
+    ExtensionObject = 22
+}
+export declare enum UaArrayType {
+    Scalar = 0,
+    Array = 1,
+    Matrix = 2
+}

package/dist/common/types/UaVariant.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UaArrayType = exports.UaVariantType = exports.UaVariant = void 0;
+const opcua_webapi_1 = require("opcua-webapi");
+const _1 = require(".");
+class UaVariant {
+    constructor() {
+        this._value = null;
+        this._type = UaVariantType.Null;
+        this._arrayType = UaArrayType.Scalar;
+    }
+    get value() {
+        return this._value;
+    }
+    get type() {
+        return this._type;
+    }
+    get arrayType() {
+        return this._arrayType;
+    }
+    isScalar() {
+        return (UaArrayType.Scalar == this._arrayType) ? true : false;
+    }
+    isArray() {
+        return (UaArrayType.Array == this._arrayType) ? true : false;
+    }
+    isNull() {
+        return (UaVariantType.Null == this._type) ? true : false;
+    }
+    toBoolean() {
+        if (this._type == UaVariantType.Boolean &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toNumber() {
+        if (this._type >= UaVariantType.SByte &&
+            this._type <= UaVariantType.Double &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toString() {
+        if (this._arrayType != UaArrayType.Scalar)
+            return null;
+        if (this._type == UaVariantType.String ||
+            this._type == UaVariantType.ByteString ||
+            this._type == UaVariantType.QualifiedName ||
+            this._type == UaVariantType.Guid)
+            return this._value;
+        return null;
+    }
+    toDateTime() {
+        if (this._type == UaVariantType.DateTime &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toNodeId() {
+        if (this._type == UaVariantType.NodeId &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toExpandedNodeId() {
+        if (this._type == UaVariantType.ExpandedNodeId &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toStatusCode() {
+        if (this._type == UaVariantType.StatusCode &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toLocalizedText() {
+        if (this._type == UaVariantType.LocalizedText &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toExtensionObject() {
+        if (this._type == UaVariantType.ExtensionObject &&
+            this._arrayType == UaArrayType.Scalar)
+            return this._value;
+        return null;
+    }
+    toBooleans() {
+        if (this._type == UaVariantType.Boolean &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toNumbers() {
+        if (this._type >= UaVariantType.SByte &&
+            this._type <= UaVariantType.Double &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toStrings() {
+        if (this._arrayType != UaArrayType.Array && this._arrayType != UaArrayType.Matrix)
+            return null;
+        if (this._type == UaVariantType.String ||
+            this._type == UaVariantType.ByteString ||
+            this._type == UaVariantType.QualifiedName ||
+            this._type == UaVariantType.Guid)
+            return this._value;
+        return null;
+    }
+    toDateTimes() {
+        if (this._type == UaVariantType.DateTime &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toNodeIds() {
+        if (this._type == UaVariantType.NodeId &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toExpandedNodeIds() {
+        if (this._type == UaVariantType.ExpandedNodeId &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toStatusCodes() {
+        if (this._type == UaVariantType.StatusCode &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toLocalizedTexts() {
+        if (this._type == UaVariantType.LocalizedText &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    toExtensionObjects() {
+        if (this._type == UaVariantType.ExtensionObject &&
+            (this._arrayType == UaArrayType.Array || this._arrayType == UaArrayType.Matrix))
+            return this._value;
+        return null;
+    }
+    static null() {
+        return new UaVariant();
+    }
+    static boolean(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Boolean;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static integer(value, type) {
+        if (type && UaVariantType.SByte > type && UaVariantType.UInt64 < type)
+            throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadTypeMismatch));
+        let val = new UaVariant();
+        val._type = (type) ? type : UaVariantType.Int32;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static float(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Float;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static double(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Double;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static string(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.String;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static dateTime(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.DateTime;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static guid(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Guid;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static byteString(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ByteString;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static nodeId(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.NodeId;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static expandedNodeId(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ExpandedNodeId;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static statusCode(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.StatusCode;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static qualifiedName(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.QualifiedName;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static localizedText(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.LocalizedText;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static extensionObject(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ExtensionObject;
+        val._value = value;
+        val._arrayType = UaArrayType.Scalar;
+        return val;
+    }
+    static booleans(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Boolean;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static integers(value, type) {
+        if (type && UaVariantType.SByte > type && UaVariantType.UInt64 < type)
+            throw new _1.UaError((0, _1.makeUaStatusCode)(opcua_webapi_1.StatusCodes.BadTypeMismatch));
+        let val = new UaVariant();
+        val._type = (type) ? type : UaVariantType.Int32;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static floats(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Float;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static doubles(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Double;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static strings(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.String;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static dateTimes(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.DateTime;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static guids(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.Guid;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static byteStrings(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ByteString;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static nodeIds(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.NodeId;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static expandedNodeIds(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ExpandedNodeId;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static statusCodes(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.StatusCode;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static qualifiedNames(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.QualifiedName;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static localizedTexts(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.LocalizedText;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+    static extensionObjects(value) {
+        let val = new UaVariant();
+        val._type = UaVariantType.ExtensionObject;
+        val._value = value;
+        val._arrayType = UaArrayType.Array;
+        return val;
+    }
+}
+exports.UaVariant = UaVariant;
+var UaVariantType;
+(function (UaVariantType) {
+    UaVariantType[UaVariantType["Null"] = 0] = "Null";
+    UaVariantType[UaVariantType["Boolean"] = 1] = "Boolean";
+    UaVariantType[UaVariantType["SByte"] = 2] = "SByte";
+    UaVariantType[UaVariantType["Byte"] = 3] = "Byte";
+    UaVariantType[UaVariantType["Int16"] = 4] = "Int16";
+    UaVariantType[UaVariantType["UInt16"] = 5] = "UInt16";
+    UaVariantType[UaVariantType["Int32"] = 6] = "Int32";
+    UaVariantType[UaVariantType["UInt32"] = 7] = "UInt32";
+    UaVariantType[UaVariantType["Int64"] = 8] = "Int64";
+    UaVariantType[UaVariantType["UInt64"] = 9] = "UInt64";
+    UaVariantType[UaVariantType["Float"] = 10] = "Float";
+    UaVariantType[UaVariantType["Double"] = 11] = "Double";
+    UaVariantType[UaVariantType["String"] = 12] = "String";
+    UaVariantType[UaVariantType["DateTime"] = 13] = "DateTime";
+    UaVariantType[UaVariantType["Guid"] = 14] = "Guid";
+    UaVariantType[UaVariantType["ByteString"] = 15] = "ByteString";
+    UaVariantType[UaVariantType["XmlElement"] = 16] = "XmlElement";
+    UaVariantType[UaVariantType["NodeId"] = 17] = "NodeId";
+    UaVariantType[UaVariantType["ExpandedNodeId"] = 18] = "ExpandedNodeId";
+    UaVariantType[UaVariantType["StatusCode"] = 19] = "StatusCode";
+    UaVariantType[UaVariantType["QualifiedName"] = 20] = "QualifiedName";
+    UaVariantType[UaVariantType["LocalizedText"] = 21] = "LocalizedText";
+    UaVariantType[UaVariantType["ExtensionObject"] = 22] = "ExtensionObject";
+})(UaVariantType || (exports.UaVariantType = UaVariantType = {}));
+var UaArrayType;
+(function (UaArrayType) {
+    UaArrayType[UaArrayType["Scalar"] = 0] = "Scalar";
+    UaArrayType[UaArrayType["Array"] = 1] = "Array";
+    UaArrayType[UaArrayType["Matrix"] = 2] = "Matrix";
+})(UaArrayType || (exports.UaArrayType = UaArrayType = {}));

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

@@ -0,0 +1,17 @@
+export * from "./UaTypes";
+export * from "./UaDataValue";
+export * from "./UaError";
+export * from "./UaExpandedNodeId";
+export * from "./UaExtensionObject";
+export * from "./UaHistoryDataResult";
+export * from "./UaHistoryEventFieldList";
+export * from "./UaHistoryEventResult";
+export * from "./UaLocalizedText";
+export * from "./UaLink";
+export * from "./UaNodeId";
+export * from "./UaQuery";
+export * from "./UaQueryFilter";
+export * from "./UaRequestPatameters";
+export * from "./UaServiceTypes";
+export * from "./UaStatusCode";
+export * from "./UaVariant";

package/dist/common/types/index.js

@@ -0,0 +1,33 @@
+"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("./UaTypes"), exports);
+__exportStar(require("./UaDataValue"), exports);
+__exportStar(require("./UaError"), exports);
+__exportStar(require("./UaExpandedNodeId"), exports);
+__exportStar(require("./UaExtensionObject"), exports);
+__exportStar(require("./UaHistoryDataResult"), exports);
+__exportStar(require("./UaHistoryEventFieldList"), exports);
+__exportStar(require("./UaHistoryEventResult"), exports);
+__exportStar(require("./UaLocalizedText"), exports);
+__exportStar(require("./UaLink"), exports);
+__exportStar(require("./UaNodeId"), exports);
+__exportStar(require("./UaQuery"), exports);
+__exportStar(require("./UaQueryFilter"), exports);
+__exportStar(require("./UaRequestPatameters"), exports);
+__exportStar(require("./UaServiceTypes"), exports);
+__exportStar(require("./UaStatusCode"), exports);
+__exportStar(require("./UaVariant"), exports);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./common";

package/dist/index.js

@@ -0,0 +1,18 @@
+"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("./client"), exports);
+__exportStar(require("./common"), exports);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "opcua-webapi-ts",
+  "version": "1.0.19",
+  "description": "Provides OPC UA WebAPI wrapper and client based on opcua-webapi-typescript",
+  "author": "DingYan",
+  "main": "./dist/cjs/index.js",
+  "typings": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "prepare": "npm run build",
+    "dev": "ts-node-dev --no-notify --respawn --transpile-only test/test"
+  },
+  "dependencies": {
+    "opcua-webapi": "^1.504.2"
+  },
+  "devDependencies": {
+    "typescript": "^4.0 || ^5.0"
+  }
+}