node-opcua-address-space 2.76.1 → 2.76.2

package/dist/src/data_access/add_dataItem_stuff.d.ts

@@ -1,11 +1,11 @@
-/**
- * @module node-opcua-address-space.DataAccess
- */
-import { UAVariable, ModellingRuleType } from "node-opcua-address-space-base";
-interface add_dataItem_stuffOptions {
-    definition?: string;
-    valuePrecision?: number;
-    modellingRule?: ModellingRuleType;
-}
-export declare function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_stuffOptions): void;
-export {};
+/**
+ * @module node-opcua-address-space.DataAccess
+ */
+import { UAVariable, ModellingRuleType } from "node-opcua-address-space-base";
+interface add_dataItem_stuffOptions {
+    definition?: string;
+    valuePrecision?: number;
+    modellingRule?: ModellingRuleType;
+}
+export declare function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_stuffOptions): void;
+export {};

package/dist/src/data_access/add_dataItem_stuff.js

@@ -1,62 +1,62 @@
-"use strict";
-/**
- * @module node-opcua-address-space.DataAccess
- */
-// Release 1.02  5  OPC Unified Architecture, Part 8
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.add_dataItem_stuff = void 0;
-// HasProperty  Variable  Definition  String  PropertyType  Optional
-// HasProperty  Variable  ValuePrecision  Double  PropertyType  Optional
-// Clients may read or write  DataItems, or monitor them for value changes. The services needed for
-// these  operations are specified in  Part  4. Changes are defined as a change in status (quality) or a
-// change in value that exceeds a client - defined range called a  Deadband. To detect the value change,
-// the difference between the current value and   the last reported value is compared to the  Deadband.
-// Definition   is a vendor - specific, human readable string that specifies how the value of this  DataItem  is
-// calculated.  Definition  is non - localized and will often contain an equation that can be parsed by
-// certain clients.
-//    Example:    Definition ::= “(TempA – 25) + TempB”
-// ValuePrecision  specifies  the maximum precision that the server can maintain for the item   based on
-// restrictions in the target environment.
-// ValuePrecision  can be used for the following  DataTypes:
-//   * For Float and Double values  it specifies   the number of   digits after the decimal place.
-//   * For DateTime values it indicates the minimum time difference in nanoseconds. For example,
-//     a ValuePrecision of 20   000  000 defines a precision of 20 ms.
-//     The  ValuePrecision  Property  is an approximation that is intended to prov ide guidance to a  Client. A
-//     Server  is expected to silently round any value with more precision that it supports. This implies that
-//     a  Client  may encounter cases where the value read back from a  Server  differs from the value that it
-//     wrote to the Server. This   difference shall be no more than the difference suggested by this  Property
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const definition_Description = "Definition  is a vendor - specific," + " human readable string that specifies how the value of this  DataItem  is calculated.";
-const valuePrecision_Description = "";
-function add_dataItem_stuff(variable, options) {
-    const addressSpace = variable.addressSpace;
-    const namespace = addressSpace.getNamespace(variable.nodeId.namespace);
-    if (Object.prototype.hasOwnProperty.call(options, "definition") && options.definition !== undefined) {
-        namespace.addVariable({
-            browseName: { name: "Definition", namespaceIndex: 0 },
-            dataType: "String",
-            description: definition_Description,
-            minimumSamplingInterval: 0,
-            modellingRule: options.modellingRule ? "Mandatory" : undefined,
-            propertyOf: variable,
-            typeDefinition: "PropertyType",
-            value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.String, value: options.definition })
-        });
-    }
-    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision") && options.valuePrecision !== undefined) {
-        (0, node_opcua_assert_1.assert)(typeof options.valuePrecision === "number");
-        namespace.addVariable({
-            browseName: { name: "ValuePrecision", namespaceIndex: 0 },
-            dataType: "Double",
-            description: valuePrecision_Description,
-            minimumSamplingInterval: 0,
-            modellingRule: options.modellingRule ? "Mandatory" : undefined,
-            propertyOf: variable,
-            typeDefinition: "PropertyType",
-            value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Double, value: options.valuePrecision })
-        });
-    }
-}
-exports.add_dataItem_stuff = add_dataItem_stuff;
+"use strict";
+/**
+ * @module node-opcua-address-space.DataAccess
+ */
+// Release 1.02  5  OPC Unified Architecture, Part 8
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add_dataItem_stuff = void 0;
+// HasProperty  Variable  Definition  String  PropertyType  Optional
+// HasProperty  Variable  ValuePrecision  Double  PropertyType  Optional
+// Clients may read or write  DataItems, or monitor them for value changes. The services needed for
+// these  operations are specified in  Part  4. Changes are defined as a change in status (quality) or a
+// change in value that exceeds a client - defined range called a  Deadband. To detect the value change,
+// the difference between the current value and   the last reported value is compared to the  Deadband.
+// Definition   is a vendor - specific, human readable string that specifies how the value of this  DataItem  is
+// calculated.  Definition  is non - localized and will often contain an equation that can be parsed by
+// certain clients.
+//    Example:    Definition ::= “(TempA – 25) + TempB”
+// ValuePrecision  specifies  the maximum precision that the server can maintain for the item   based on
+// restrictions in the target environment.
+// ValuePrecision  can be used for the following  DataTypes:
+//   * For Float and Double values  it specifies   the number of   digits after the decimal place.
+//   * For DateTime values it indicates the minimum time difference in nanoseconds. For example,
+//     a ValuePrecision of 20   000  000 defines a precision of 20 ms.
+//     The  ValuePrecision  Property  is an approximation that is intended to prov ide guidance to a  Client. A
+//     Server  is expected to silently round any value with more precision that it supports. This implies that
+//     a  Client  may encounter cases where the value read back from a  Server  differs from the value that it
+//     wrote to the Server. This   difference shall be no more than the difference suggested by this  Property
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const definition_Description = "Definition  is a vendor - specific," + " human readable string that specifies how the value of this  DataItem  is calculated.";
+const valuePrecision_Description = "";
+function add_dataItem_stuff(variable, options) {
+    const addressSpace = variable.addressSpace;
+    const namespace = addressSpace.getNamespace(variable.nodeId.namespace);
+    if (Object.prototype.hasOwnProperty.call(options, "definition") && options.definition !== undefined) {
+        namespace.addVariable({
+            browseName: { name: "Definition", namespaceIndex: 0 },
+            dataType: "String",
+            description: definition_Description,
+            minimumSamplingInterval: 0,
+            modellingRule: options.modellingRule ? "Mandatory" : undefined,
+            propertyOf: variable,
+            typeDefinition: "PropertyType",
+            value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.String, value: options.definition })
+        });
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision") && options.valuePrecision !== undefined) {
+        (0, node_opcua_assert_1.assert)(typeof options.valuePrecision === "number");
+        namespace.addVariable({
+            browseName: { name: "ValuePrecision", namespaceIndex: 0 },
+            dataType: "Double",
+            description: valuePrecision_Description,
+            minimumSamplingInterval: 0,
+            modellingRule: options.modellingRule ? "Mandatory" : undefined,
+            propertyOf: variable,
+            typeDefinition: "PropertyType",
+            value: new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.Double, value: options.valuePrecision })
+        });
+    }
+}
+exports.add_dataItem_stuff = add_dataItem_stuff;
 //# sourceMappingURL=add_dataItem_stuff.js.map

package/dist/src/data_access/check_variant_compatibility_ua_analog_item.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/src/data_access/check_variant_compatibility_ua_analog_item.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * @module node-opcua-address-space.DataAccess
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const ua_variable_impl_1 = require("../ua_variable_impl");
-function validate_value_range(range, variant) {
-    if (variant.value < range.low || variant.value > range.high) {
-        return false;
-    }
-    return true;
-}
-function checkVariantCompatibilityUAAnalogItem(value) {
-    (0, node_opcua_assert_1.assert)(value instanceof node_opcua_variant_1.Variant);
-    // test dataType
-    if (!this._validate_DataType(value.dataType)) {
-        return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
-    }
-    const analogItem = this;
-    // AnalogDataItem
-    if (analogItem.instrumentRange) {
-        if (!validate_value_range(analogItem.instrumentRange.readValue().value.value, value)) {
-            return node_opcua_status_code_1.StatusCodes.BadOutOfRange;
-        }
-    }
-    return node_opcua_status_code_1.StatusCodes.Good;
-}
-/**
- * extend default checkVariantCompatibility on base class with this one
- */
-ua_variable_impl_1.UAVariableImpl.prototype.checkVariantCompatibility = checkVariantCompatibilityUAAnalogItem;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @module node-opcua-address-space.DataAccess
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const ua_variable_impl_1 = require("../ua_variable_impl");
+function validate_value_range(range, variant) {
+    if (variant.value < range.low || variant.value > range.high) {
+        return false;
+    }
+    return true;
+}
+function checkVariantCompatibilityUAAnalogItem(value) {
+    (0, node_opcua_assert_1.assert)(value instanceof node_opcua_variant_1.Variant);
+    // test dataType
+    if (!this._validate_DataType(value.dataType)) {
+        return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+    }
+    const analogItem = this;
+    // AnalogDataItem
+    if (analogItem.instrumentRange) {
+        if (!validate_value_range(analogItem.instrumentRange.readValue().value.value, value)) {
+            return node_opcua_status_code_1.StatusCodes.BadOutOfRange;
+        }
+    }
+    return node_opcua_status_code_1.StatusCodes.Good;
+}
+/**
+ * extend default checkVariantCompatibility on base class with this one
+ */
+ua_variable_impl_1.UAVariableImpl.prototype.checkVariantCompatibility = checkVariantCompatibilityUAAnalogItem;
 //# sourceMappingURL=check_variant_compatibility_ua_analog_item.js.map

package/dist/src/data_access/ua_multistate_discrete_impl.d.ts

@@ -1,32 +1,32 @@
-import { LocalizedText } from "node-opcua-data-model";
-import { StatusCode } from "node-opcua-status-code";
-import { DataType, Variant } from "node-opcua-variant";
-import { INamespace, UAVariable, UAProperty } from "node-opcua-address-space-base";
-import { UAMultiStateDiscrete_Base } from "node-opcua-nodeset-ua";
-import { UAVariableImpl } from "../ua_variable_impl";
-import { AddMultiStateDiscreteOptions } from "../../source/address_space_ts";
-export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
-export interface UAMultiStateDiscreteEx<T, DT extends DataType> extends UAMultiStateDiscrete_Base<T, DT> {
-    getValue(): number;
-    getValueAsString(): string;
-    getIndex(value: string): number;
-    setValue(value: string | number): void;
-    checkVariantCompatibility(value: Variant): StatusCode;
-}
-export interface UAMultiStateDiscreteImpl<T, DT extends DataType> {
-    enumStrings: UAProperty<LocalizedText[], DataType.LocalizedText>;
-}
-/**
- * @class UAMultiStateDiscrete
- */
-export declare class UAMultiStateDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateDiscreteEx<T, DT> {
-    getValue(): number;
-    getValueAsString(): string;
-    getIndex(value: string): number;
-    setValue(value: string | number): void;
-    checkVariantCompatibility(value: Variant): StatusCode;
-    _post_initialize(): void;
-    clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateDiscreteImpl<T, DT>;
-}
-export declare function promoteToMultiStateDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateDiscreteImpl<T, DT>;
-export declare function _addMultiStateDiscrete<T, DT extends DataType>(namespace: INamespace, options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteImpl<T, DT>;
+import { LocalizedText } from "node-opcua-data-model";
+import { StatusCode } from "node-opcua-status-code";
+import { DataType, Variant } from "node-opcua-variant";
+import { INamespace, UAVariable, UAProperty } from "node-opcua-address-space-base";
+import { UAMultiStateDiscrete_Base } from "node-opcua-nodeset-ua";
+import { UAVariableImpl } from "../ua_variable_impl";
+import { AddMultiStateDiscreteOptions } from "../../source/address_space_ts";
+export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
+export interface UAMultiStateDiscreteEx<T, DT extends DataType> extends UAMultiStateDiscrete_Base<T, DT> {
+    getValue(): number;
+    getValueAsString(): string;
+    getIndex(value: string): number;
+    setValue(value: string | number): void;
+    checkVariantCompatibility(value: Variant): StatusCode;
+}
+export interface UAMultiStateDiscreteImpl<T, DT extends DataType> {
+    enumStrings: UAProperty<LocalizedText[], DataType.LocalizedText>;
+}
+/**
+ * @class UAMultiStateDiscrete
+ */
+export declare class UAMultiStateDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateDiscreteEx<T, DT> {
+    getValue(): number;
+    getValueAsString(): string;
+    getIndex(value: string): number;
+    setValue(value: string | number): void;
+    checkVariantCompatibility(value: Variant): StatusCode;
+    _post_initialize(): void;
+    clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateDiscreteImpl<T, DT>;
+}
+export declare function promoteToMultiStateDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateDiscreteImpl<T, DT>;
+export declare function _addMultiStateDiscrete<T, DT extends DataType>(namespace: INamespace, options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteImpl<T, DT>;

package/dist/src/data_access/ua_multistate_discrete_impl.js

@@ -1,131 +1,131 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._addMultiStateDiscrete = exports.promoteToMultiStateDiscrete = exports.UAMultiStateDiscreteImpl = void 0;
-/**
- * @module node-opcua-address-space.DataAccess
- */
-const node_opcua_assert_1 = require("node-opcua-assert");
-const node_opcua_constants_1 = require("node-opcua-constants");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const register_node_promoter_1 = require("../../source/loader/register_node_promoter");
-const ua_variable_impl_1 = require("../ua_variable_impl");
-const add_dataItem_stuff_1 = require("./add_dataItem_stuff");
-/**
- * @class UAMultiStateDiscrete
- */
-class UAMultiStateDiscreteImpl extends ua_variable_impl_1.UAVariableImpl {
-    getValue() {
-        return this.readValue().value.value;
-    }
-    getValueAsString() {
-        const index = this.getValue();
-        const arr = this.enumStrings.readValue().value.value;
-        (0, node_opcua_assert_1.assert)(Array.isArray(arr));
-        return arr[index].text ? arr[index].text.toString() : "????";
-    }
-    getIndex(value) {
-        const arr = this.enumStrings.readValue().value.value;
-        (0, node_opcua_assert_1.assert)(Array.isArray(arr));
-        const index = arr.findIndex((a) => a.text === value);
-        return index;
-    }
-    setValue(value) {
-        if (typeof value === "string") {
-            const index = this.getIndex(value);
-            if (index < 0) {
-                throw new Error("UAMultiStateDiscrete#setValue invalid multi state value provided : " + value);
-            }
-            return this.setValue(index);
-        }
-        const arrayEnumStrings = this.enumStrings.readValue().value.value;
-        if (value >= arrayEnumStrings.length) {
-            throw new Error("UAMultiStateDiscrete#setValue BadOutOfRange " + value);
-        }
-        (0, node_opcua_assert_1.assert)(isFinite(value));
-        return this.setValueFromSource(new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.UInt32, value }));
-    }
-    checkVariantCompatibility(value) {
-        if (!this._validate_DataType(value.dataType)) {
-            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
-        }
-        if (this.enumStrings) {
-            const arrayEnumStrings = this.enumStrings.readValue().value.value;
-            // MultiStateDiscreteType
-            (0, node_opcua_assert_1.assert)(value.dataType === node_opcua_variant_1.DataType.UInt32);
-            if (value.value >= arrayEnumStrings.length) {
-                return node_opcua_status_code_1.StatusCodes.BadOutOfRange;
-            }
-        }
-        return node_opcua_status_code_1.StatusCodes.Good;
-    }
-    _post_initialize() {
-        /* empty */
-    }
-    clone(options1, optionalFilter, extraInfo) {
-        const variable1 = ua_variable_impl_1.UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
-        return promoteToMultiStateDiscrete(variable1);
-    }
-}
-exports.UAMultiStateDiscreteImpl = UAMultiStateDiscreteImpl;
-function promoteToMultiStateDiscrete(node) {
-    if (node instanceof UAMultiStateDiscreteImpl) {
-        return node; // already promoted
-    }
-    Object.setPrototypeOf(node, UAMultiStateDiscreteImpl.prototype);
-    (0, node_opcua_assert_1.assert)(node instanceof UAMultiStateDiscreteImpl, "should now  be a State Machine");
-    const _node = node;
-    _node._post_initialize();
-    (0, node_opcua_assert_1.assert)(_node.enumStrings.browseName.toString() === "EnumStrings");
-    const handler = _node.handle_semantic_changed.bind(_node);
-    _node.enumStrings.on("value_changed", handler);
-    _node.install_extra_properties();
-    return node;
-}
-exports.promoteToMultiStateDiscrete = promoteToMultiStateDiscrete;
-(0, register_node_promoter_1.registerNodePromoter)(node_opcua_constants_1.VariableTypeIds.MultiStateDiscreteType, promoteToMultiStateDiscrete);
-function _addMultiStateDiscrete(namespace, options) {
-    const addressSpace = namespace.addressSpace;
-    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(options, "enumStrings"));
-    (0, node_opcua_assert_1.assert)(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
-    const multiStateDiscreteType = addressSpace.findVariableType("MultiStateDiscreteType");
-    if (!multiStateDiscreteType) {
-        throw new Error("Cannot find MultiStateDiscreteType");
-    }
-    // todo : if options.typeDefinition is specified, check that type is SubTypeOf MultiStateDiscreteType
-    options.value = options.value === undefined ? 0 : options.value;
-    let value;
-    if (typeof options.value === "number") {
-        value = new node_opcua_variant_1.Variant({
-            dataType: node_opcua_variant_1.DataType.UInt32,
-            value: options.value
-        });
-    }
-    else {
-        value = options.value;
-    }
-    const variable = namespace.addVariable(Object.assign(Object.assign({}, options), { dataType: "Number", typeDefinition: multiStateDiscreteType.nodeId, value, valueRank: -2 }));
-    (0, add_dataItem_stuff_1.add_dataItem_stuff)(variable, options);
-    const enumStrings = options.enumStrings.map((value) => {
-        return (0, node_opcua_data_model_1.coerceLocalizedText)(value);
-    });
-    const enumStringsNode = namespace.addVariable({
-        accessLevel: "CurrentRead",
-        browseName: { name: "EnumStrings", namespaceIndex: 0 },
-        dataType: "LocalizedText",
-        minimumSamplingInterval: 0,
-        modellingRule: options.modellingRule ? "Mandatory" : undefined,
-        propertyOf: variable,
-        typeDefinition: "PropertyType",
-        userAccessLevel: "CurrentRead",
-        value: new node_opcua_variant_1.Variant({
-            arrayType: node_opcua_variant_1.VariantArrayType.Array,
-            dataType: node_opcua_variant_1.DataType.LocalizedText,
-            value: enumStrings
-        })
-    });
-    return promoteToMultiStateDiscrete(variable);
-}
-exports._addMultiStateDiscrete = _addMultiStateDiscrete;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._addMultiStateDiscrete = exports.promoteToMultiStateDiscrete = exports.UAMultiStateDiscreteImpl = void 0;
+/**
+ * @module node-opcua-address-space.DataAccess
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+const node_opcua_constants_1 = require("node-opcua-constants");
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const register_node_promoter_1 = require("../../source/loader/register_node_promoter");
+const ua_variable_impl_1 = require("../ua_variable_impl");
+const add_dataItem_stuff_1 = require("./add_dataItem_stuff");
+/**
+ * @class UAMultiStateDiscrete
+ */
+class UAMultiStateDiscreteImpl extends ua_variable_impl_1.UAVariableImpl {
+    getValue() {
+        return this.readValue().value.value;
+    }
+    getValueAsString() {
+        const index = this.getValue();
+        const arr = this.enumStrings.readValue().value.value;
+        (0, node_opcua_assert_1.assert)(Array.isArray(arr));
+        return arr[index].text ? arr[index].text.toString() : "????";
+    }
+    getIndex(value) {
+        const arr = this.enumStrings.readValue().value.value;
+        (0, node_opcua_assert_1.assert)(Array.isArray(arr));
+        const index = arr.findIndex((a) => a.text === value);
+        return index;
+    }
+    setValue(value) {
+        if (typeof value === "string") {
+            const index = this.getIndex(value);
+            if (index < 0) {
+                throw new Error("UAMultiStateDiscrete#setValue invalid multi state value provided : " + value);
+            }
+            return this.setValue(index);
+        }
+        const arrayEnumStrings = this.enumStrings.readValue().value.value;
+        if (value >= arrayEnumStrings.length) {
+            throw new Error("UAMultiStateDiscrete#setValue BadOutOfRange " + value);
+        }
+        (0, node_opcua_assert_1.assert)(isFinite(value));
+        return this.setValueFromSource(new node_opcua_variant_1.Variant({ dataType: node_opcua_variant_1.DataType.UInt32, value }));
+    }
+    checkVariantCompatibility(value) {
+        if (!this._validate_DataType(value.dataType)) {
+            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+        }
+        if (this.enumStrings) {
+            const arrayEnumStrings = this.enumStrings.readValue().value.value;
+            // MultiStateDiscreteType
+            (0, node_opcua_assert_1.assert)(value.dataType === node_opcua_variant_1.DataType.UInt32);
+            if (value.value >= arrayEnumStrings.length) {
+                return node_opcua_status_code_1.StatusCodes.BadOutOfRange;
+            }
+        }
+        return node_opcua_status_code_1.StatusCodes.Good;
+    }
+    _post_initialize() {
+        /* empty */
+    }
+    clone(options1, optionalFilter, extraInfo) {
+        const variable1 = ua_variable_impl_1.UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
+        return promoteToMultiStateDiscrete(variable1);
+    }
+}
+exports.UAMultiStateDiscreteImpl = UAMultiStateDiscreteImpl;
+function promoteToMultiStateDiscrete(node) {
+    if (node instanceof UAMultiStateDiscreteImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UAMultiStateDiscreteImpl.prototype);
+    (0, node_opcua_assert_1.assert)(node instanceof UAMultiStateDiscreteImpl, "should now  be a State Machine");
+    const _node = node;
+    _node._post_initialize();
+    (0, node_opcua_assert_1.assert)(_node.enumStrings.browseName.toString() === "EnumStrings");
+    const handler = _node.handle_semantic_changed.bind(_node);
+    _node.enumStrings.on("value_changed", handler);
+    _node.install_extra_properties();
+    return node;
+}
+exports.promoteToMultiStateDiscrete = promoteToMultiStateDiscrete;
+(0, register_node_promoter_1.registerNodePromoter)(node_opcua_constants_1.VariableTypeIds.MultiStateDiscreteType, promoteToMultiStateDiscrete);
+function _addMultiStateDiscrete(namespace, options) {
+    const addressSpace = namespace.addressSpace;
+    (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(options, "enumStrings"));
+    (0, node_opcua_assert_1.assert)(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+    const multiStateDiscreteType = addressSpace.findVariableType("MultiStateDiscreteType");
+    if (!multiStateDiscreteType) {
+        throw new Error("Cannot find MultiStateDiscreteType");
+    }
+    // todo : if options.typeDefinition is specified, check that type is SubTypeOf MultiStateDiscreteType
+    options.value = options.value === undefined ? 0 : options.value;
+    let value;
+    if (typeof options.value === "number") {
+        value = new node_opcua_variant_1.Variant({
+            dataType: node_opcua_variant_1.DataType.UInt32,
+            value: options.value
+        });
+    }
+    else {
+        value = options.value;
+    }
+    const variable = namespace.addVariable(Object.assign(Object.assign({}, options), { dataType: "Number", typeDefinition: multiStateDiscreteType.nodeId, value, valueRank: -2 }));
+    (0, add_dataItem_stuff_1.add_dataItem_stuff)(variable, options);
+    const enumStrings = options.enumStrings.map((value) => {
+        return (0, node_opcua_data_model_1.coerceLocalizedText)(value);
+    });
+    const enumStringsNode = namespace.addVariable({
+        accessLevel: "CurrentRead",
+        browseName: { name: "EnumStrings", namespaceIndex: 0 },
+        dataType: "LocalizedText",
+        minimumSamplingInterval: 0,
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        userAccessLevel: "CurrentRead",
+        value: new node_opcua_variant_1.Variant({
+            arrayType: node_opcua_variant_1.VariantArrayType.Array,
+            dataType: node_opcua_variant_1.DataType.LocalizedText,
+            value: enumStrings
+        })
+    });
+    return promoteToMultiStateDiscrete(variable);
+}
+exports._addMultiStateDiscrete = _addMultiStateDiscrete;
 //# sourceMappingURL=ua_multistate_discrete_impl.js.map

package/dist/src/data_access/ua_multistate_value_discrete.d.ts

@@ -0,0 +1,51 @@
+import { DataType, Variant } from "node-opcua-variant";
+import { Int64 } from "node-opcua-basic-types";
+import { LocalizedText, QualifiedNameLike } from "node-opcua-data-model";
+import { DataValueT } from "node-opcua-data-value";
+import { StatusCode } from "node-opcua-status-code";
+import { NumericRange } from "node-opcua-numeric-range";
+import { DTEnumValue } from "node-opcua-nodeset-ua";
+import { INamespace, UAVariable, UAProperty, ISessionContext } from "node-opcua-address-space-base";
+import { UAMultiStateValueDiscreteEx } from "../../source/interfaces/data_access/ua_multistate_value_discrete_ex";
+import { AddMultiStateValueDiscreteOptions } from "../../source/address_space_ts";
+import { UAVariableImpl } from "../ua_variable_impl";
+export interface UAMultiStateValueDiscreteImpl<T, DT extends DataType> {
+    enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
+    valueAsText: UAProperty<LocalizedText, DataType.LocalizedText>;
+    readValue(context?: ISessionContext | null, indexRange?: NumericRange, dataEncoding?: QualifiedNameLike | null): DataValueT<T, DT>;
+    readValueAsync(context: ISessionContext | null, callback?: any): any;
+}
+export declare class UAMultiStateValueDiscreteImpl<T, DT extends DataType> extends UAVariableImpl implements UAMultiStateValueDiscreteEx<T, DT> {
+    setValue(value: string | number | Int64): void;
+    getValueAsString(): string;
+    getValueAsNumber(): number;
+    checkVariantCompatibility(value: Variant): StatusCode;
+    clone<T, DT extends DataType>(options1: any, optionalFilter: any, extraInfo: any): UAMultiStateValueDiscreteImpl<T, DT>;
+    /**
+     * @private
+     */
+    _isValueInRange(value: number): boolean;
+    /**
+     *
+     * @private
+     */
+    _enumValueIndex(): any;
+    /**
+     *
+     * @private
+     */
+    _setValue(value: Int64): void;
+    /**
+     *
+     * @private
+     */
+    findValueAsText(value?: number | Int64): Variant;
+    _getDataType(): DataType;
+    /**
+     *
+     * @private
+     */
+    _post_initialize(): void;
+}
+export declare function promoteToMultiStateValueDiscrete<T, DT extends DataType>(node: UAVariable): UAMultiStateValueDiscreteImpl<T, DT>;
+export declare function _addMultiStateValueDiscrete<T, DT extends DataType>(namespace: INamespace, options: AddMultiStateValueDiscreteOptions): UAMultiStateValueDiscreteEx<T, DT>;