node-opcua-address-space 2.76.1 → 2.76.2

package/dist/source/loader/namespace_post_step.js

@@ -1,62 +1,62 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promoteObjectsAndVariables = exports.promoteObjectAndVariablesInNamespace = exports.g_promotableObject = void 0;
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
-exports.g_promotableObject = {};
-function parentIsObjectOrVariableType(node) {
-    var _a;
-    if (node.parent && (node.parent.nodeClass === node_opcua_data_model_1.NodeClass.VariableType || ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeClass) === node_opcua_data_model_1.NodeClass.ObjectType)) {
-        return true;
-    }
-    if (!node.parent) {
-        return false;
-    }
-    return parentIsObjectOrVariableType(node.parent);
-}
-function promoteObjectAndVariablesInNamespace(namespace) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const namespaceP = namespace;
-        for (const a of namespaceP.nodeIterator()) {
-            if (a.nodeClass === node_opcua_data_model_1.NodeClass.Object || a.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
-                // skip object & variable that belong to a ObjectType or VariableType
-                const aa = a;
-                if (aa.typeDefinition) {
-                    const promoter = exports.g_promotableObject[aa.typeDefinition.toString()];
-                    if (promoter) {
-                        if (promoter.onInstanceOnly && parentIsObjectOrVariableType(aa)) {
-                            continue;
-                        }
-                        const before = a.constructor.name;
-                        promoter.promoter(a);
-                        const after = a.constructor.name;
-                        if (doDebug) {
-                            debugLog(`promoting ${a.browseName.toString()} from ${before} to ${after}`);
-                        }
-                    }
-                }
-            }
-        }
-    });
-}
-exports.promoteObjectAndVariablesInNamespace = promoteObjectAndVariablesInNamespace;
-function promoteObjectsAndVariables(addressSpace) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const namespace of addressSpace.getNamespaceArray()) {
-            promoteObjectAndVariablesInNamespace(namespace);
-        }
-    });
-}
-exports.promoteObjectsAndVariables = promoteObjectsAndVariables;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promoteObjectsAndVariables = exports.promoteObjectAndVariablesInNamespace = exports.g_promotableObject = void 0;
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
+exports.g_promotableObject = {};
+function parentIsObjectOrVariableType(node) {
+    var _a;
+    if (node.parent && (node.parent.nodeClass === node_opcua_data_model_1.NodeClass.VariableType || ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeClass) === node_opcua_data_model_1.NodeClass.ObjectType)) {
+        return true;
+    }
+    if (!node.parent) {
+        return false;
+    }
+    return parentIsObjectOrVariableType(node.parent);
+}
+function promoteObjectAndVariablesInNamespace(namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const namespaceP = namespace;
+        for (const a of namespaceP.nodeIterator()) {
+            if (a.nodeClass === node_opcua_data_model_1.NodeClass.Object || a.nodeClass === node_opcua_data_model_1.NodeClass.Variable) {
+                // skip object & variable that belong to a ObjectType or VariableType
+                const aa = a;
+                if (aa.typeDefinition) {
+                    const promoter = exports.g_promotableObject[aa.typeDefinition.toString()];
+                    if (promoter) {
+                        if (promoter.onInstanceOnly && parentIsObjectOrVariableType(aa)) {
+                            continue;
+                        }
+                        const before = a.constructor.name;
+                        promoter.promoter(a);
+                        const after = a.constructor.name;
+                        if (doDebug) {
+                            debugLog(`promoting ${a.browseName.toString()} from ${before} to ${after}`);
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+exports.promoteObjectAndVariablesInNamespace = promoteObjectAndVariablesInNamespace;
+function promoteObjectsAndVariables(addressSpace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const namespace of addressSpace.getNamespaceArray()) {
+            promoteObjectAndVariablesInNamespace(namespace);
+        }
+    });
+}
+exports.promoteObjectsAndVariables = promoteObjectsAndVariables;
 //# sourceMappingURL=namespace_post_step.js.map

package/dist/source/loader/register_node_promoter.d.ts

@@ -1,2 +1,2 @@
-import { Promoter } from "./namespace_post_step";
-export declare function registerNodePromoter(standardNodeId: number, promoter: Promoter, applyOnTypes?: boolean): void;
+import { Promoter } from "./namespace_post_step";
+export declare function registerNodePromoter(standardNodeId: number, promoter: Promoter, applyOnTypes?: boolean): void;

package/dist/source/loader/register_node_promoter.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerNodePromoter = void 0;
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const namespace_post_step_1 = require("./namespace_post_step");
-function registerNodePromoter(standardNodeId, promoter, applyOnTypes = false) {
-    namespace_post_step_1.g_promotableObject[(0, node_opcua_nodeid_1.resolveNodeId)(standardNodeId).toString()] = { promoter, onInstanceOnly: applyOnTypes };
-}
-exports.registerNodePromoter = registerNodePromoter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNodePromoter = void 0;
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const namespace_post_step_1 = require("./namespace_post_step");
+function registerNodePromoter(standardNodeId, promoter, applyOnTypes = false) {
+    namespace_post_step_1.g_promotableObject[(0, node_opcua_nodeid_1.resolveNodeId)(standardNodeId).toString()] = { promoter, onInstanceOnly: applyOnTypes };
+}
+exports.registerNodePromoter = registerNodePromoter;
 //# sourceMappingURL=register_node_promoter.js.map

package/dist/source/namespace.d.ts

@@ -1,6 +1,6 @@
-import { INamespace } from "node-opcua-address-space-base";
-import { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
-import { INamespaceDataAccess } from "./namespace_data_access";
-import { INamespaceMachineState } from "./namespace_machine_state";
-export interface Namespace extends INamespace, INamespaceAlarmAndCondition, INamespaceDataAccess, INamespaceMachineState {
-}
+import { INamespace } from "node-opcua-address-space-base";
+import { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition";
+import { INamespaceDataAccess } from "./namespace_data_access";
+import { INamespaceMachineState } from "./namespace_machine_state";
+export interface Namespace extends INamespace, INamespaceAlarmAndCondition, INamespaceDataAccess, INamespaceMachineState {
+}

package/dist/source/namespace.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=namespace.js.map

package/dist/source/namespace_alarm_and_condition.d.ts

@@ -1,32 +1,32 @@
-import { NodeId } from "node-opcua-nodeid";
-import { UAEventType } from "node-opcua-address-space-base";
-import { VariantOptions } from "node-opcua-variant";
-import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
-import { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-import { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
-import { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
-import { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
-import { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
-import { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
-import { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
-import { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
-import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
-import { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
-import { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
-import { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
-import { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
-export interface INamespaceAlarmAndCondition {
-    instantiateCondition(conditionTypeId: UAEventType | NodeId | string, options: any, data?: Record<string, VariantOptions>): UAConditionEx;
-    instantiateAcknowledgeableCondition(conditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAcknowledgeableConditionEx;
-    instantiateAlarmCondition(alarmConditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAlarmConditionEx;
-    instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UALimitAlarmEx;
-    instantiateExclusiveLimitAlarm(exclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLimitAlarmEx;
-    instantiateExclusiveDeviationAlarm(options: InstantiateExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveDeviationAlarmEx;
-    instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateNonExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveLimitAlarmEx;
-    instantiateNonExclusiveDeviationAlarm(options: InstantiateNonExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveDeviationAlarmEx;
-    instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UADiscreteAlarmEx;
-    instantiateOffNormalAlarm(options: InstantiateOffNormalAlarmOptions, data?: Record<string, VariantOptions>): UAOffNormalAlarmEx;
-}
+import { NodeId } from "node-opcua-nodeid";
+import { UAEventType } from "node-opcua-address-space-base";
+import { VariantOptions } from "node-opcua-variant";
+import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
+import { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
+import { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
+import { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
+import { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+import { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
+import { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
+import { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
+export interface INamespaceAlarmAndCondition {
+    instantiateCondition(conditionTypeId: UAEventType | NodeId | string, options: any, data?: Record<string, VariantOptions>): UAConditionEx;
+    instantiateAcknowledgeableCondition(conditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAcknowledgeableConditionEx;
+    instantiateAlarmCondition(alarmConditionTypeId: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UAAlarmConditionEx;
+    instantiateLimitAlarm(limitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateLimitAlarmOptions, data?: Record<string, VariantOptions>): UALimitAlarmEx;
+    instantiateExclusiveLimitAlarm(exclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveLimitAlarmEx;
+    instantiateExclusiveDeviationAlarm(options: InstantiateExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UAExclusiveDeviationAlarmEx;
+    instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmTypeId: UAEventType | NodeId | string, options: InstantiateNonExclusiveLimitAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveLimitAlarmEx;
+    instantiateNonExclusiveDeviationAlarm(options: InstantiateNonExclusiveDeviationAlarmOptions, data?: Record<string, VariantOptions>): UANonExclusiveDeviationAlarmEx;
+    instantiateDiscreteAlarm(discreteAlarmType: UAEventType | NodeId | string, options: InstantiateAlarmConditionOptions, data?: Record<string, VariantOptions>): UADiscreteAlarmEx;
+    instantiateOffNormalAlarm(options: InstantiateOffNormalAlarmOptions, data?: Record<string, VariantOptions>): UAOffNormalAlarmEx;
+}

package/dist/source/namespace_alarm_and_condition.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=namespace_alarm_and_condition.js.map

package/dist/source/namespace_data_access.d.ts

@@ -1,42 +1,42 @@
-import { AddVariableOptionsWithoutValue, AddYArrayItemOptions, BindVariableOptions } from "node-opcua-address-space-base";
-import { NodeIdLike } from "node-opcua-nodeid";
-import { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
-import { EUInformation, EUInformationOptions } from "node-opcua-types";
-import { DataType, VariantArrayType } from "node-opcua-variant";
-import { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
-import { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
-import { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
-import { AddMultiStateDiscreteOptions, AddMultiStateValueDiscreteOptions, AddTwoStateDiscreteOptions, AddTwoStateVariableOptions } from "./address_space_ts";
-import { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
-import { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
-export interface AddDataItemOptions extends AddVariableOptionsWithoutValue {
-    arrayType?: VariantArrayType;
-    value?: BindVariableOptions;
-    /** @example  "(tempA -25) + tempB" */
-    definition?: string;
-    /** @example 0.5 */
-    valuePrecision?: number;
-}
-export interface AddAnalogDataItemOptions extends AddDataItemOptions {
-    value?: BindVariableOptions;
-    engineeringUnitsRange?: {
-        low: number;
-        high: number;
-    };
-    instrumentRange?: {
-        low: number;
-        high: number;
-    };
-    engineeringUnits?: EUInformationOptions | EUInformation;
-    minimumSamplingInterval?: number;
-    dataType?: string | NodeIdLike;
-}
-export interface INamespaceDataAccess {
-    addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT>;
-    addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItem<T, DT>;
-    addYArrayItem<DT extends DataType.Double | DataType.Float>(options: AddYArrayItemOptions): UAYArrayItemEx<DT>;
-    addTwoStateVariable(options: AddTwoStateVariableOptions): UATwoStateVariableEx;
-    addTwoStateDiscrete(options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx;
-    addMultiStateDiscrete<T, DT extends DataType>(options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteEx<T, DT>;
-    addMultiStateValueDiscrete<T, DT extends DataType>(options: AddMultiStateValueDiscreteOptions): UAMultiStateValueDiscreteEx<T, DT>;
-}
+import { AddVariableOptionsWithoutValue, AddYArrayItemOptions, BindVariableOptions } from "node-opcua-address-space-base";
+import { NodeIdLike } from "node-opcua-nodeid";
+import { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
+import { EUInformation, EUInformationOptions } from "node-opcua-types";
+import { DataType, VariantArrayType } from "node-opcua-variant";
+import { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
+import { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
+import { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
+import { AddMultiStateDiscreteOptions, AddMultiStateValueDiscreteOptions, AddTwoStateDiscreteOptions, AddTwoStateVariableOptions } from "./address_space_ts";
+import { UATwoStateVariableEx } from "./ua_two_state_variable_ex";
+import { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
+export interface AddDataItemOptions extends AddVariableOptionsWithoutValue {
+    arrayType?: VariantArrayType;
+    value?: BindVariableOptions;
+    /** @example  "(tempA -25) + tempB" */
+    definition?: string;
+    /** @example 0.5 */
+    valuePrecision?: number;
+}
+export interface AddAnalogDataItemOptions extends AddDataItemOptions {
+    value?: BindVariableOptions;
+    engineeringUnitsRange?: {
+        low: number;
+        high: number;
+    };
+    instrumentRange?: {
+        low: number;
+        high: number;
+    };
+    engineeringUnits?: EUInformationOptions | EUInformation;
+    minimumSamplingInterval?: number;
+    dataType?: string | NodeIdLike;
+}
+export interface INamespaceDataAccess {
+    addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT>;
+    addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItem<T, DT>;
+    addYArrayItem<DT extends DataType.Double | DataType.Float>(options: AddYArrayItemOptions): UAYArrayItemEx<DT>;
+    addTwoStateVariable(options: AddTwoStateVariableOptions): UATwoStateVariableEx;
+    addTwoStateDiscrete(options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx;
+    addMultiStateDiscrete<T, DT extends DataType>(options: AddMultiStateDiscreteOptions): UAMultiStateDiscreteEx<T, DT>;
+    addMultiStateValueDiscrete<T, DT extends DataType>(options: AddMultiStateValueDiscreteOptions): UAMultiStateValueDiscreteEx<T, DT>;
+}

package/dist/source/namespace_data_access.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=namespace_data_access.js.map

package/dist/source/namespace_machine_state.d.ts

@@ -1,7 +1,7 @@
-import { UAObject, UAObjectType } from "node-opcua-address-space-base";
-import { UAState } from "node-opcua-nodeset-ua";
-import { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
-export interface INamespaceMachineState {
-    addState(component: UAObject | UAObjectType, stateName: string, stateNumber: number, isInitialState?: boolean): UAState;
-    addTransition(component: UAObject | UAObjectType, fromState: string, toState: string, transitionNumber: number): UATransitionEx;
-}
+import { UAObject, UAObjectType } from "node-opcua-address-space-base";
+import { UAState } from "node-opcua-nodeset-ua";
+import { UATransitionEx } from "./interfaces/state_machine/ua_transition_ex";
+export interface INamespaceMachineState {
+    addState(component: UAObject | UAObjectType, stateName: string, stateNumber: number, isInitialState?: boolean): UAState;
+    addTransition(component: UAObject | UAObjectType, fromState: string, toState: string, transitionNumber: number): UATransitionEx;
+}

package/dist/source/namespace_machine_state.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=namespace_machine_state.js.map

package/dist/source/pseudo_session.d.ts

@@ -1,55 +1,55 @@
-/// <reference types="node" />
-import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
-import { ArgumentDefinition, BrowseDescriptionLike, CallMethodRequestLike, IBasicSession, MethodId, ResponseCallback } from "node-opcua-pseudo-session";
-import { BrowseResult } from "node-opcua-service-browse";
-import { CallMethodResult } from "node-opcua-service-call";
-import { BrowsePath, BrowsePathResult } from "node-opcua-service-translate-browse-path";
-import { StatusCode } from "node-opcua-status-code";
-import { WriteValueOptions, ReadValueIdOptions } from "node-opcua-types";
-import { IAddressSpace, ISessionContext } from "node-opcua-address-space-base";
-/**
- * Pseudo session is an helper object that exposes the same async methods
- * than the ClientSession. It can be used on a server address space.
- *
- * Code reused !
- * The primary benefit of this object  is that its makes advanced OPCUA
- * operations that uses browse, translate, read, write etc similar
- * whether we work inside a server or through a client session.
- *
- */
-export declare class PseudoSession implements IBasicSession {
-    requestedMaxReferencesPerNode: number;
-    private _sessionId;
-    private readonly addressSpace;
-    private readonly continuationPointManager;
-    private readonly context;
-    constructor(addressSpace: IAddressSpace, context?: ISessionContext);
-    getSessionId(): NodeId;
-    browse(nodeToBrowse: BrowseDescriptionLike, callback: ResponseCallback<BrowseResult>): void;
-    browse(nodesToBrowse: BrowseDescriptionLike[], callback: ResponseCallback<BrowseResult[]>): void;
-    browse(nodeToBrowse: BrowseDescriptionLike): Promise<BrowseResult>;
-    browse(nodesToBrowse: BrowseDescriptionLike[]): Promise<BrowseResult[]>;
-    read(nodeToRead: ReadValueIdOptions, callback: ResponseCallback<DataValue>): void;
-    read(nodesToRead: ReadValueIdOptions[], callback: ResponseCallback<DataValue[]>): void;
-    read(nodeToRead: ReadValueIdOptions): Promise<DataValue>;
-    read(nodesToRead: ReadValueIdOptions[]): Promise<DataValue[]>;
-    browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean, callback: ResponseCallback<BrowseResult>): void;
-    browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean, callback: ResponseCallback<BrowseResult[]>): void;
-    browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean): Promise<BrowseResult>;
-    browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean): Promise<BrowseResult[]>;
-    call(methodToCall: CallMethodRequestLike, callback: ResponseCallback<CallMethodResult>): void;
-    call(methodsToCall: CallMethodRequestLike[], callback: ResponseCallback<CallMethodResult[]>): void;
-    call(methodToCall: CallMethodRequestLike): Promise<CallMethodResult>;
-    call(methodsToCall: CallMethodRequestLike[]): Promise<CallMethodResult[]>;
-    getArgumentDefinition(methodId: MethodId): Promise<ArgumentDefinition>;
-    getArgumentDefinition(methodId: MethodId, callback: ResponseCallback<ArgumentDefinition>): void;
-    translateBrowsePath(browsePaths: BrowsePath[], callback: ResponseCallback<BrowsePathResult[]>): void;
-    translateBrowsePath(browsePath: BrowsePath, callback: ResponseCallback<BrowsePathResult>): void;
-    translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult>;
-    translateBrowsePath(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]>;
-    write(nodeToWrite: WriteValueOptions, callback: ResponseCallback<StatusCode>): void;
-    write(nodesToWrite: WriteValueOptions[], callback: ResponseCallback<StatusCode[]>): void;
-    write(nodeToWrite: WriteValueOptions): Promise<StatusCode>;
-    write(nodesToWrite: WriteValueOptions[]): Promise<StatusCode[]>;
-}
+/// <reference types="node" />
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { ArgumentDefinition, BrowseDescriptionLike, CallMethodRequestLike, IBasicSession, MethodId, ResponseCallback } from "node-opcua-pseudo-session";
+import { BrowseResult } from "node-opcua-service-browse";
+import { CallMethodResult } from "node-opcua-service-call";
+import { BrowsePath, BrowsePathResult } from "node-opcua-service-translate-browse-path";
+import { StatusCode } from "node-opcua-status-code";
+import { WriteValueOptions, ReadValueIdOptions } from "node-opcua-types";
+import { IAddressSpace, ISessionContext } from "node-opcua-address-space-base";
+/**
+ * Pseudo session is an helper object that exposes the same async methods
+ * than the ClientSession. It can be used on a server address space.
+ *
+ * Code reused !
+ * The primary benefit of this object  is that its makes advanced OPCUA
+ * operations that uses browse, translate, read, write etc similar
+ * whether we work inside a server or through a client session.
+ *
+ */
+export declare class PseudoSession implements IBasicSession {
+    requestedMaxReferencesPerNode: number;
+    private _sessionId;
+    private readonly addressSpace;
+    private readonly continuationPointManager;
+    private readonly context;
+    constructor(addressSpace: IAddressSpace, context?: ISessionContext);
+    getSessionId(): NodeId;
+    browse(nodeToBrowse: BrowseDescriptionLike, callback: ResponseCallback<BrowseResult>): void;
+    browse(nodesToBrowse: BrowseDescriptionLike[], callback: ResponseCallback<BrowseResult[]>): void;
+    browse(nodeToBrowse: BrowseDescriptionLike): Promise<BrowseResult>;
+    browse(nodesToBrowse: BrowseDescriptionLike[]): Promise<BrowseResult[]>;
+    read(nodeToRead: ReadValueIdOptions, callback: ResponseCallback<DataValue>): void;
+    read(nodesToRead: ReadValueIdOptions[], callback: ResponseCallback<DataValue[]>): void;
+    read(nodeToRead: ReadValueIdOptions): Promise<DataValue>;
+    read(nodesToRead: ReadValueIdOptions[]): Promise<DataValue[]>;
+    browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean, callback: ResponseCallback<BrowseResult>): void;
+    browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean, callback: ResponseCallback<BrowseResult[]>): void;
+    browseNext(continuationPoint: Buffer, releaseContinuationPoints: boolean): Promise<BrowseResult>;
+    browseNext(continuationPoints: Buffer[], releaseContinuationPoints: boolean): Promise<BrowseResult[]>;
+    call(methodToCall: CallMethodRequestLike, callback: ResponseCallback<CallMethodResult>): void;
+    call(methodsToCall: CallMethodRequestLike[], callback: ResponseCallback<CallMethodResult[]>): void;
+    call(methodToCall: CallMethodRequestLike): Promise<CallMethodResult>;
+    call(methodsToCall: CallMethodRequestLike[]): Promise<CallMethodResult[]>;
+    getArgumentDefinition(methodId: MethodId): Promise<ArgumentDefinition>;
+    getArgumentDefinition(methodId: MethodId, callback: ResponseCallback<ArgumentDefinition>): void;
+    translateBrowsePath(browsePaths: BrowsePath[], callback: ResponseCallback<BrowsePathResult[]>): void;
+    translateBrowsePath(browsePath: BrowsePath, callback: ResponseCallback<BrowsePathResult>): void;
+    translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult>;
+    translateBrowsePath(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]>;
+    write(nodeToWrite: WriteValueOptions, callback: ResponseCallback<StatusCode>): void;
+    write(nodesToWrite: WriteValueOptions[], callback: ResponseCallback<StatusCode[]>): void;
+    write(nodeToWrite: WriteValueOptions): Promise<StatusCode>;
+    write(nodesToWrite: WriteValueOptions[]): Promise<StatusCode[]>;
+}