node-opcua-address-space 2.51.0

package/dist/source/interfaces/state_machine/ua_state_machine_type.d.ts

@@ -0,0 +1,222 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { DateTime, UInt32 } from "node-opcua-basic-types";
+import { LocalizedText } from "node-opcua-data-model";
+import { DataType } from "node-opcua-variant";
+import { UAProperty, InstantiateObjectOptions, UAObject, UAObjectType, UAReferenceType, UAVariableTypeT } from "node-opcua-address-space-base";
+import { UAInitialState, UAInitialState_Base, UAState, UAState_Base, UAStateMachine_Base, UATransition_Base, UATransitionEvent_Base } from "node-opcua-nodeset-ua";
+import { UATransitionEx } from "./ua_transition_ex";
+export declare type UtcTime = DateTime;
+export interface NonHierarchicalReferences extends UAReferenceType {
+}
+export interface UAStateVariableType extends UAVariableTypeT<LocalizedText, DataType.LocalizedText> {
+    isAbstract: false;
+}
+export interface StateB {
+    stateNumber: UAProperty<UInt32, DataType.UInt32>;
+}
+export interface UAStateType extends UAState_Base, UAObjectType {
+}
+export interface UATransitionType extends UATransition_Base, UAObjectType {
+}
+/**
+ * Initial State Type
+ *
+ * The InitialStateType is a subtype of the StateType and is formally defined in Table B.8.
+ * An Object of the InitialStateType represents the State that a FiniteStateMachine enters
+ * when it is activated.
+ *
+ * Each FiniteStateMachine can have at most one State of type InitialStateType, but
+ * a FiniteStateMachine does not have to have a State of this type.
+ *
+ * A SubStateMachine goes into its initial state whenever the parent state is entered. However, a
+ * state machine may define a transition that goes directly to a state of the SubStateMachine. In
+ * this case the SubStateMachine goes into that State instead of the initial State. The two
+ * scenarios are illustrated in Figure B.4. The transition from State5 to State6 causes the
+ * SubStateMachine to go into the initial State (State7), however, the transition from State4 to
+ * State8 causes the parent machine to go to State6 and the SubStateMachine will go to State8.
+ *
+ * If no initial state for a SubStateMachine exists and the State having the SubStateMachine is
+ * entered directly, then the State of the SubStateMachine is server-specific.
+ */
+export interface UAInitialStateType extends UAInitialState_Base, UAStateType {
+}
+/**
+ * ToState Reference Type
+ *
+ * The ToState ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to the ending State the
+ * Transition connects.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode of this ReferenceType shall be an Object of the ObjectType
+ * StateType or one of its subtypes.
+ *
+ * References of this ReferenceType may be only exposed uni-directional. Sometimes this is
+ * required, for example, if a Transition points to a State of a sub-machine.
+ */
+export interface ToStateReferenceType extends NonHierarchicalReferences {
+}
+/**
+ *
+ * FromState Reference Type
+ *
+ * The FromState ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to the starting State the
+ * Transition connects.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode of this ReferenceType shall be an Object of the ObjectType
+ * StateType or one of its subtypes.
+ */
+export interface FromStateReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * HasCause
+ * The HasCause ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to something that causes the
+ * Transition. In this annex we only define Methods as Causes. However, the ReferenceType is
+ * not restricted to point to Methods. The referenced Methods can, but do not have to point to a
+ * Method of the StateMachineType. For example, it is allowed to point to a server-wide restart
+ * Method leading the state machine to go into its initial state.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode can be of any NodeClass
+ */
+export interface HasCauseReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * HasEffect ReferenceType
+ *
+ * The HasEffect ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ * The semantic of this ReferenceType is to point form a Transition to something that will be
+ * effected when the Transition is triggered. In this annex we only define EventTypes as Effects.
+ *
+ * However, the ReferenceType is not restricted to point to EventTypes.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode can be of any NodeClass.
+ */
+export interface HasEffectReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * The HasSubStateMachine ReferenceType is a concrete ReferenceType and can be used
+ * directly. It is a subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point from a State to an instance of
+ * StateMachineType which represents the sub-states for the State.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType StateType.
+ *
+ * The TargetNode shall be an Object of the ObjectType StateMachineType or one of its subtypes.
+ *
+ * Each Object can be the TargetNode of at most one HasSubStateMachine Reference.
+ *
+ * The SourceNode (the state) and the TargetNode (the SubStateMachine) shall belong to the
+ * same StateMachine, that is, both shall be referenced from the same Object of type
+ * StateMachineType using a HasComponent Reference or a subtype of HasComponent.
+ */
+export interface HasSubStateMachine extends NonHierarchicalReferences {
+}
+/**
+ * The TransitionEventType is a subtype of the BaseEventType. It can be used to generate an
+ * Event identifying that a Transition of a StateMachine was triggered.
+ *
+ * The TransitionEventType inherits the Properties of the BaseEventType.
+ *
+ * The inherited Property SourceNode shall be filled with the NodeId of the StateMachine instance
+ * where the Transition occurs. If the Transition occurs in a SubStateMachine, then the NodeId of
+ * the SubStateMachine has to be used. If the Transition occurs between a StateMachine and a
+ * SubStateMachine, then the NodeId of the StateMachine has to be used, independent of the
+ * direction of the Transition.
+ */
+export interface UATransitionEventType extends UATransitionEvent_Base, UAObjectType {
+}
+export declare type TransitionSelector = (transitions: UATransitionEx[], fromState: UAState, toState: UAState) => UATransitionEx | null;
+/**
+ * State Machine type
+ *
+ * StateMachines produce Events which may include the current state of a StateMachine. In that
+ * case Servers shall provide all the optional Properties of the StateVariableType in the Event,
+ * even if they are not provided on the instances in the address space.
+ */
+/**
+ * StateMachineType
+ *
+ * The StateMachineType is the base ObjectType for all StateMachineTypes. It defines a single
+ * Variable which represents the current state of the machine.
+ * An instance of this ObjectType shall generate an Event whenever a significant state change occurs.
+ * The Server decides which state changes are significant. Servers shall use the GeneratesEvent
+ * ReferenceType to indicate which Event(s) could be produced by the StateMachine.
+ *
+ * Subtypes may add Methods which affect the state of the machine. The Executable Attribute is
+ * used to indicate whether the Method is valid given the current state of the machine. The
+ * generation of AuditEvents for Methods is defined in Part 4. A StateMachine may not be active.
+ *
+ * In this case, the CurrentState and LastTransition Variables shall have a status equal to
+ * BadStateNotActive (see Table B.17).
+ *
+ * Subtypes may add components which are instances of StateMachineTypes. These components
+ * are considered to be sub-states of the StateMachine. SubStateMachines are only active when
+ * the parent machine is in an appropriate state.
+ * Events produced by SubStateMachines may be suppressed by the parent machine. In some
+ * cases, the parent machine will produce a single Event that reflects changes in multiple
+ * SubStateMachines
+ */
+export interface UAStateMachineHelper {
+    readonly initialState: UAInitialState | null;
+    readonly states: UAState[];
+    readonly transitions: UATransitionEx[];
+    currentStateNode: UAState | null;
+    /**
+     * return all state nodes associated with this state machine
+     */
+    getStates(): UAState[];
+    /**
+     * return all state to state transition node associated with this state machine
+     */
+    getTransitions(): UATransitionEx[];
+    /**
+     * return the state Node by Name
+     * @param name
+     */
+    getStateByName(name: string): UAState | null;
+    /**
+     * returns true if there is a valid transition from currentStateNode to toStateNode
+     * @param toStateNode
+     */
+    isValidTransition(toStateNode: UAState | string, predicate?: TransitionSelector): boolean;
+    /**
+     * try to find the valid transition between fromState Node to toState Node
+     * @param fromStateNode
+     * @param toStateNode
+     */
+    findTransitionNode(fromStateNode: UAState, toStateNode: UAState, predicate?: TransitionSelector): UATransitionEx | null;
+    /**
+     * return the current state as string
+     */
+    getCurrentState(): string | null;
+    /**
+     * change the current state
+     *
+     * note:
+     *  - a transition from currentState to toState node must exists
+     * - a TransitionEventType event will be raised
+     * @param toStateNode
+     */
+    setState(toStateNode: UAState | string | null, predicate?: TransitionSelector): void;
+}
+export interface UAStateMachineEx extends UAObject, UAStateMachineHelper, UAStateMachine_Base {
+}
+export interface UAStateMachineType extends UAObjectType, UAStateMachineHelper, UAStateMachine_Base {
+    instantiate(options: InstantiateObjectOptions): UAStateMachineEx;
+}
+export declare function promoteToStateMachine(node: UAObject): UAStateMachineEx;

package/dist/source/interfaces/state_machine/ua_state_machine_type.js

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

package/dist/source/interfaces/state_machine/ua_state_machine_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_state_machine_type.js","sourceRoot":"","sources":["../../../../source/interfaces/state_machine/ua_state_machine_type.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/state_machine/ua_state_variable.d.ts

@@ -0,0 +1,29 @@
+import { LocalizedText, QualifiedName } from "node-opcua-data-model";
+import { DataType } from "node-opcua-variant";
+import { UAVariable, UAVariableT } from "../../address_space_ts";
+export interface _UAStateVariable {
+    id: UAVariable;
+    /**
+     *  effective display name
+     *
+     *  contains a human readable name for the current state of the state
+     *  machine after taking the state of any SubStateMachines in account. There is no rule specified
+     *  for which state or sub-state should be used. It is up to the Server and will depend on the
+     *  semantics of the StateMachineType
+     */
+    readonly effectiveDisplayName?: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    readonly name?: UAVariableT<QualifiedName, DataType.QualifiedName>;
+    /**
+     * number is an integer which uniquely identifies the current state within the StateMachineType
+     */
+    readonly number?: UAVariableT<number, DataType.UInt32>;
+}
+export interface UAStateVariable extends UAVariable, _UAStateVariable {
+}
+/**
+ * The StateVariableType is the base VariableType for Variables that store the current state of a
+ * StateMachine as a human readable name.
+ */
+export interface UAStateVariableT<T, DT extends DataType> extends UAVariableT<T, DT>, _UAStateVariable {
+    id: UAVariableT<any, DataType>;
+}

package/dist/source/interfaces/state_machine/ua_state_variable.js

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

package/dist/source/interfaces/state_machine/ua_state_variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_state_variable.js","sourceRoot":"","sources":["../../../../source/interfaces/state_machine/ua_state_variable.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/state_machine/ua_transition_ex.d.ts

@@ -0,0 +1,6 @@
+import { BaseNode } from "node-opcua-address-space-base";
+import { UATransition } from "node-opcua-nodeset-ua";
+export interface UATransitionEx extends UATransition {
+    get toStateNode(): BaseNode | null;
+    get fromStateNode(): BaseNode | null;
+}

package/dist/source/interfaces/state_machine/ua_transition_ex.js

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

package/dist/source/interfaces/state_machine/ua_transition_ex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_transition_ex.js","sourceRoot":"","sources":["../../../../source/interfaces/state_machine/ua_transition_ex.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/state_machine/ua_two_state_variable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { LocalizedText } from "node-opcua-data-model";
+import { DataType } from "node-opcua-variant";
+import { UAVariableT } from "../../address_space_ts";
+import { UAStateVariableT, UAStateVariable } from "./ua_state_variable";
+/**
+ * @see https://reference.opcfoundation.org/v104/Core/docs/Part9/5.2/
+ * @see https://reference.opcfoundation.org/v104/Core/VariableTypes/TwoStateVariableType/
+ * @see https://reference.opcfoundation.org/v104/Core/ReferenceTypes/HasFalseSubState/
+ */
+export declare interface UATwoStateVariable extends UAStateVariableT<LocalizedText, DataType.LocalizedText> {
+    readonly id: UAVariableT<boolean, DataType.Boolean>;
+    readonly falseState?: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    readonly trueState?: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    readonly effectiveTransitionTime?: UAVariableT<Date, DataType.DateTime>;
+    readonly transitionTime?: UAVariableT<Date, DataType.DateTime>;
+    readonly isFalseSubStateOf: UAStateVariable | null;
+    readonly isTrueSubStateOf: UAStateVariable | null;
+    setValue(boolValue: boolean): void;
+    getValue(): boolean;
+    getValueAsString(): string;
+    getFalseSubStates(): UAStateVariable[];
+    getTrueSubStates(): UAStateVariable[];
+}

package/dist/source/interfaces/state_machine/ua_two_state_variable.js

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

package/dist/source/interfaces/state_machine/ua_two_state_variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_two_state_variable.js","sourceRoot":"","sources":["../../../../source/interfaces/state_machine/ua_two_state_variable.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/subscription_diagnostics_variable.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { Byte, Double, UABoolean, UInt32 } from "node-opcua-basic-types";
+import { SubscriptionDiagnosticsDataType } from "node-opcua-types";
+import { DataType } from "node-opcua-variant";
+import { UAVariable, UAVariableT } from "../address_space_ts";
+export interface SubscriptionDiagnosticsVariable extends UAVariable {
+    $extensionObject: SubscriptionDiagnosticsDataType;
+    sessionId: UAVariable;
+    subscriptionId: UAVariableT<UInt32, DataType.UInt32>;
+    priority: UAVariableT<Byte, DataType.Byte>;
+    publishingInterval: UAVariableT<Double, DataType.Double>;
+    maxKeepAliveCount: UAVariableT<UInt32, DataType.UInt32>;
+    maxLifetimeCount: UAVariableT<UInt32, DataType.UInt32>;
+    maxNotificationsPerPublish: UAVariableT<UInt32, DataType.UInt32>;
+    publishingEnabled: UAVariableT<UABoolean, DataType.Boolean>;
+    modifyCount: UAVariableT<UInt32, DataType.UInt32>;
+    enableCount: UAVariableT<UInt32, DataType.UInt32>;
+    disableCount: UAVariableT<UInt32, DataType.UInt32>;
+    republishRequestCount: UAVariableT<UInt32, DataType.UInt32>;
+    republishMessageRequestCount: UAVariableT<UInt32, DataType.UInt32>;
+    republishMessageCount: UAVariableT<UInt32, DataType.UInt32>;
+    transferRequestCount: UAVariableT<UInt32, DataType.UInt32>;
+    transferredToAltClientCount: UAVariableT<UInt32, DataType.UInt32>;
+    transferredToSameClientCount: UAVariableT<UInt32, DataType.UInt32>;
+    publishRequestCount: UAVariableT<UInt32, DataType.UInt32>;
+    dataChangeNotificationsCount: UAVariableT<UInt32, DataType.UInt32>;
+    eventNotificationsCount: UAVariableT<UInt32, DataType.UInt32>;
+    notificationsCount: UAVariableT<UInt32, DataType.UInt32>;
+    latePublishRequestCount: UAVariableT<UInt32, DataType.UInt32>;
+    currentKeepAliveCount: UAVariableT<UInt32, DataType.UInt32>;
+    currentLifetimeCount: UAVariableT<UInt32, DataType.UInt32>;
+    unacknowledgedMessageCount: UAVariableT<UInt32, DataType.UInt32>;
+    discardedMessageCount: UAVariableT<UInt32, DataType.UInt32>;
+    monitoredItemCount: UAVariableT<UInt32, DataType.UInt32>;
+    disabledMonitoredItemCount: UAVariableT<UInt32, DataType.UInt32>;
+    monitoringQueueOverflowCount: UAVariableT<UInt32, DataType.UInt32>;
+    nextSequenceNumber: UAVariableT<UInt32, DataType.UInt32>;
+    eventQueueOverFlowCount: UAVariableT<UInt32, DataType.UInt32>;
+}

package/dist/source/interfaces/subscription_diagnostics_variable.js

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

package/dist/source/interfaces/subscription_diagnostics_variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription_diagnostics_variable.js","sourceRoot":"","sources":["../../../source/interfaces/subscription_diagnostics_variable.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/ua_authorisation_service.d.ts

@@ -0,0 +1 @@
+export { UAAuthorizationServiceConfiguration } from "node-opcua-nodeset-ua";

package/dist/source/interfaces/ua_authorisation_service.js

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

package/dist/source/interfaces/ua_authorisation_service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_authorisation_service.js","sourceRoot":"","sources":["../../../source/interfaces/ua_authorisation_service.ts"],"names":[],"mappings":""}

package/dist/source/interfaces/ua_subscription_diagnostics_variable_ex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { SubscriptionDiagnosticsDataType } from "node-opcua-types";
+import { DTSubscriptionDiagnostics, UASubscriptionDiagnostics } from "node-opcua-nodeset-ua";
+export interface UASubscriptionDiagnosticsVariableEx extends UASubscriptionDiagnostics<DTSubscriptionDiagnostics> {
+    $extensionObject: SubscriptionDiagnosticsDataType;
+}

package/dist/source/interfaces/ua_subscription_diagnostics_variable_ex.js

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

package/dist/source/interfaces/ua_subscription_diagnostics_variable_ex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_subscription_diagnostics_variable_ex.js","sourceRoot":"","sources":["../../../source/interfaces/ua_subscription_diagnostics_variable_ex.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,10 @@
+import { CallbackT, ErrorCallback } from "node-opcua-status-code";
+import { IAddressSpace } from "node-opcua-address-space-base";
+/**
+ * @param addressSpace the addressSpace to populate
+ * @xmlFiles: a lis of xml files
+ * @param xmlLoader - a helper function to return the content of the xml file
+ */
+export declare function generateAddressSpaceRawCallback(addressSpace: IAddressSpace, xmlFiles: string | string[], xmlLoader: (nodeset2xmlUri: string, callback: CallbackT<string>) => void, callback?: ErrorCallback): void;
+export declare type XmlLoaderFunc = (nodeset2xmlUri: string, callback: CallbackT<string>) => void;
+export declare function generateAddressSpaceRaw(addressSpace: IAddressSpace, xmlFiles: string | string[], xmlLoader: XmlLoaderFunc): Promise<void>;

package/dist/source/loader/generateAddressSpaceRaw.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAddressSpaceRaw = exports.generateAddressSpaceRawCallback = void 0;
+const async = require("async");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const adjust_namespace_array_1 = require("../../src/nodeset_tools/adjust_namespace_array");
+const load_nodeset2_1 = require("./load_nodeset2");
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+/**
+ * @param addressSpace the addressSpace to populate
+ * @xmlFiles: a lis of xml files
+ * @param xmlLoader - a helper function to return the content of the xml file
+ */
+function generateAddressSpaceRawCallback(addressSpace, xmlFiles, xmlLoader, callback) {
+    // istanbul ignore next
+    if (!callback) {
+        throw new Error("Internal Error; :callback missing");
+    }
+    const nodesetLoader = new load_nodeset2_1.NodeSetLoader(addressSpace);
+    if (!Array.isArray(xmlFiles)) {
+        xmlFiles = [xmlFiles];
+    }
+    // read xml files in parallel
+    async.map(xmlFiles, (xmlFile, callback1) => {
+        xmlLoader(xmlFile, callback1);
+    }, (err, xmlDataArray) => {
+        if (err) {
+            callback(err);
+            return;
+        }
+        async.forEachSeries(xmlDataArray, (xmlData, callback1) => {
+            if (!xmlData) {
+                return callback1(err);
+            }
+            nodesetLoader.addNodeSet(xmlData, callback1);
+        }, (err) => {
+            nodesetLoader.terminate(() => {
+                (0, adjust_namespace_array_1.adjustNamespaceArray)(addressSpace);
+                callback();
+            });
+        });
+    });
+    // however process them in series
+}
+exports.generateAddressSpaceRawCallback = generateAddressSpaceRawCallback;
+function generateAddressSpaceRaw(addressSpace, xmlFiles, xmlLoader) {
+    const promise = new Promise((resolve, reject) => {
+        generateAddressSpaceRawCallback(addressSpace, xmlFiles, xmlLoader, (err) => {
+            if (err) {
+                return reject(err);
+            }
+            resolve();
+        });
+    });
+    return promise;
+}
+exports.generateAddressSpaceRaw = generateAddressSpaceRaw;
+//# sourceMappingURL=generateAddressSpaceRaw.js.map

package/dist/source/loader/generateAddressSpaceRaw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateAddressSpaceRaw.js","sourceRoot":"","sources":["../../../source/loader/generateAddressSpaceRaw.ts"],"names":[],"mappings":";;;AAAA,+BAA+B;AAC/B,uDAAiE;AAIjE,2FAAsF;AACtF,mDAAgD;AAEhD,MAAM,OAAO,GAAG,IAAA,iCAAc,EAAC,UAAU,CAAC,CAAC;AAC3C,MAAM,QAAQ,GAAG,IAAA,gCAAa,EAAC,UAAU,CAAC,CAAC;AAC3C;;;;GAIG;AACH,SAAgB,+BAA+B,CAC3C,YAA2B,EAC3B,QAA2B,EAC3B,SAAwE,EACxE,QAAwB;IAExB,uBAAuB;IACvB,IAAI,CAAC,QAAQ,EAAE;QACX,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;KACxD;IACD,MAAM,aAAa,GAAG,IAAI,6BAAa,CAAC,YAAY,CAAC,CAAC;IAEtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC1B,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC;KACzB;IAED,6BAA6B;IAC7B,KAAK,CAAC,GAAG,CACL,QAAQ,EACR,CAAC,OAAe,EAAE,SAAyD,EAAE,EAAE;QAC3E,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAClC,CAAC,EACD,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE;QAClB,IAAI,GAAG,EAAE;YACL,QAAS,CAAC,GAAG,CAAC,CAAC;YACf,OAAO;SACV;QAED,KAAK,CAAC,aAAa,CACf,YAAa,EACb,CAAC,OAA2B,EAAE,SAAgC,EAAE,EAAE;YAC9D,IAAI,CAAC,OAAO,EAAE;gBACV,OAAO,SAAS,CAAC,GAAI,CAAC,CAAC;aAC1B;YACD,aAAa,CAAC,UAAU,CAAC,OAAQ,EAAE,SAAS,CAAC,CAAC;QAClD,CAAC,EACD,CAAC,GAAkB,EAAE,EAAE;YACnB,aAAa,CAAC,SAAS,CAAC,GAAG,EAAE;gBACzB,IAAA,6CAAoB,EAAC,YAAY,CAAC,CAAC;gBACnC,QAAS,EAAE,CAAC;YAChB,CAAC,CAAC,CAAC;QACP,CAAC,CACJ,CAAC;IACN,CAAC,CACJ,CAAC;IACF,iCAAiC;AACrC,CAAC;AA9CD,0EA8CC;AAGD,SAAgB,uBAAuB,CACnC,YAA2B,EAC3B,QAA2B,EAC3B,SAAwB;IAExB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAClD,+BAA+B,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE;YACvE,IAAI,GAAG,EAAE;gBACL,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;aACtB;YACD,OAAO,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACnB,CAAC;AAdD,0DAcC"}

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

@@ -0,0 +1,13 @@
+import { IAddressSpace } from "node-opcua-address-space-base";
+import { CallbackT } from "node-opcua-basic-types";
+import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
+export declare function ensureDatatypeExtracted(addressSpace: IAddressSpace): Promise<ExtraDataTypeManager>;
+export declare function ensureDatatypeExtractedWithCallback(addressSpace: IAddressSpace, callback: CallbackT<ExtraDataTypeManager>): void;
+export declare function makeStuff(addressSpace: IAddressSpace): any;
+export declare class NodeSetLoader {
+    _s: any;
+    constructor(addressSpace: IAddressSpace);
+    addNodeSet(xmlData: string, callback: ErrorCallback): void;
+    addNodeSetAsync(xmlData: string): Promise<void>;
+    terminate(callback: ErrorCallback): void;
+}