node-opcua-address-space 2.98.0 → 2.98.2

package/dist/source/address_space_ts.d.ts

@@ -0,0 +1,118 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { Int64, UAString, UInt32 } from "node-opcua-basic-types";
+import { AttributeIds, LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { ReadRawModifiedDetails } from "node-opcua-service-history";
+import { DataType } from "node-opcua-variant";
+import { BaseNode, IAddressSpace, AddVariableOptionsWithoutValue, BindVariableOptions, UAMethod, UAVariableT, UAReference, AddBaseNodeOptions, VariableStuff, UAVariableType, UAVariable, UAObject, IVariableHistorianOptions, IVariableHistorian, UADynamicVariableArray, UAReferenceType, INamespace } from "node-opcua-address-space-base";
+import { UAFolder } from "node-opcua-nodeset-ua";
+import { MinimalistAddressSpace } from "../src/reference_impl";
+import { Namespace } from "./namespace";
+import { UARootFolder } from "./ua_root_folder";
+export declare function resolveReferenceType(addressSpace: MinimalistAddressSpace, reference: UAReference): UAReferenceType;
+export declare function resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode;
+export declare function makeAttributeEventName(attributeId: AttributeIds): string;
+export interface EnumValueTypeOptionsLike {
+    value?: Int64 | UInt32;
+    displayName?: LocalizedTextLike | null;
+    description?: LocalizedTextLike | null;
+}
+export interface AddMultiStateValueDiscreteOptions extends AddVariableOptionsWithoutValue {
+    enumValues: EnumValueTypeOptionsLike[] | {
+        [key: string]: number;
+    };
+    value?: UInt32 | Int64 | BindVariableOptions;
+}
+export declare enum EUEngineeringUnit {
+    degree_celsius = 0
+}
+export interface AddMultiStateDiscreteOptions extends AddBaseNodeOptions, VariableStuff {
+    enumStrings: string[];
+    typeDefinition?: string | NodeId | UAVariableType;
+    postInstantiateFunc?: (node: UAVariable) => void;
+    value?: number | BindVariableOptions;
+}
+export type AddStateVariableOptionals = "EffectiveDisplayName" | "Name" | "Number" | string;
+export interface AddStateVariableOptions extends AddVariableOptionsWithoutValue {
+    id?: any;
+    optionals?: AddStateVariableOptionals[];
+}
+export type AddTwoStateVariableOptionals = AddStateVariableOptionals | "TransitionTime" | "EffectiveTransitionTime" | "TrueState" | "FalseState";
+export interface AddTwoStateVariableOptions extends AddStateVariableOptions {
+    falseState?: LocalizedTextLike;
+    trueState?: LocalizedTextLike;
+    optionals?: AddTwoStateVariableOptionals[];
+    isFalseSubStateOf?: NodeId | string | BaseNode;
+    isTrueSubStateOf?: NodeId | string | BaseNode;
+    value?: boolean | BindVariableOptions;
+}
+export interface AddTwoStateDiscreteOptions extends AddVariableOptionsWithoutValue {
+    falseState?: LocalizedTextLike;
+    trueState?: LocalizedTextLike;
+    optionals?: string[];
+    isFalseSubStateOf?: NodeIdLike | BaseNode;
+    isTrueSubStateOf?: NodeIdLike | BaseNode;
+    value?: boolean | BindVariableOptions;
+    /** @example  "" */
+    definition?: string;
+}
+export interface RangeVariable extends UAVariable {
+    low: UAVariableT<number, DataType.Double>;
+    high: UAVariableT<number, DataType.Double>;
+}
+export interface XAxisDefinitionVariable extends UAVariable {
+    engineeringUnits: UAVariableT<UAString, DataType.String>;
+    title: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    euRange: RangeVariable;
+}
+export declare const NamespaceOptions: {
+    nodeIdNameSeparator: string;
+};
+export interface UATypesFolder extends UAFolder {
+    dataTypes: UAFolder;
+    eventTypes: UAFolder;
+    objectTypes: UAFolder;
+    referenceTypes: UAFolder;
+    variableTypes: UAFolder;
+}
+export interface AddressSpace extends IAddressSpace {
+    getOwnNamespace(): Namespace;
+    registerNamespace(namespaceUri: string): Namespace;
+    rootFolder: UARootFolder;
+}
+export declare class AddressSpace {
+    static historizerFactory: any;
+    static create(): AddressSpace;
+    private constructor();
+}
+export declare class VariableHistorian implements IVariableHistorian {
+    constructor(node: UAVariable, options: IVariableHistorianOptions);
+    /**
+     * push a new value into the history for this variable
+     * the method should take a very small amount of time and not
+     * directly write to the underlying database
+     * @param newDataValue
+     */
+    push(newDataValue: DataValue): Promise<void>;
+    /**
+     * Extract a series of dataValue from the History database for this value
+     * @param historyReadRawModifiedDetails
+     * @param maxNumberToExtract
+     * @param isReversed
+     * @param reverseDataValue
+     * @param callback
+     */
+    extractDataValues(historyReadRawModifiedDetails: ReadRawModifiedDetails, maxNumberToExtract: number, isReversed: boolean, reverseDataValue: boolean, callback: (err: Error | null, dataValue?: DataValue[]) => void): void;
+}
+export type UAClonable = UAObject | UAVariable | UAMethod;
+export declare function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T>;
+export declare function bindExtObjArrayNode<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, variableTypeNodeId: string | NodeId, indexPropertyName: string): UAVariable;
+export declare function addElement<T extends ExtensionObject>(options: any, uaArrayVariableNode: UADynamicVariableArray<T>): UAVariable;
+export declare function removeElement<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, element: number | UAVariable | ((a: T) => boolean)): void;
+export declare function dumpXml(node: BaseNode, options: any): string;
+export declare function dumpToBSD(namespace: INamespace): string;
+export declare function adjustNamespaceArray(addressSpace: IAddressSpace): void;

package/dist/source/address_space_ts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressSpace = exports.EUEngineeringUnit = void 0;
+var EUEngineeringUnit;
+(function (EUEngineeringUnit) {
+    EUEngineeringUnit[EUEngineeringUnit["degree_celsius"] = 0] = "degree_celsius";
+    // to be continued
+})(EUEngineeringUnit = exports.EUEngineeringUnit || (exports.EUEngineeringUnit = {}));
+class AddressSpace {
+    static create() {
+        return new AddressSpace();
+    }
+    constructor() {
+        /* empty */
+    }
+}
+exports.AddressSpace = AddressSpace;
+//# sourceMappingURL=address_space_ts.js.map

package/dist/source/address_space_ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address_space_ts.js","sourceRoot":"","sources":["../../source/address_space_ts.ts"],"names":[],"mappings":";;;AAwDA,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IACzB,6EAAc,CAAA;IACd,kBAAkB;AACtB,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;AAoFD,MAAa,YAAY;IAGd,MAAM,CAAC,MAAM;QAChB,OAAO,IAAI,YAAY,EAAkB,CAAC;IAC9C,CAAC;IAED;QACI,WAAW;IACf,CAAC;CACJ;AAVD,oCAUC"}

package/dist/source/continuation_points/continuation_point_manager.d.ts

@@ -0,0 +1,91 @@
+import { ReferenceDescription } from "node-opcua-types";
+import { IContinuationPointManager, IContinuationPointInfo, ContinuationData } from "node-opcua-address-space-base";
+import { DataValue } from "node-opcua-data-value";
+/**
+ * from https://reference.opcfoundation.org/v104/Core/docs/Part4/7.6/
+ *
+ * A ContinuationPoint is used to pause a Browse, QueryFirst or HistoryRead operation and allow it to be restarted later by calling BrowseNext,
+ * QueryNext or HistoryRead.
+ * - Operations are paused when the number of results found exceeds the limits set by either the Client or the Server.
+ * - The Client specifies the maximum number of results per operation in the request message.
+ * - A Server shall not return more than this number of results but it may return fewer results.
+ * - The Server allocates a  ContinuationPoint if there are more results to return.
+ * - Servers shall support at least one ContinuationPoint per Session.
+ * - Servers specify a maximum number of ContinuationPoints per Session in the ServerCapabilities Object defined in OPC 10000-5.
+ * - ContinuationPoints remain active until
+ *     a/ the Client retrieves the remaining results,
+ *     b/ or, the Client releases the ContinuationPoint
+ *     c/ or the Session is closed.
+ * - A Server shall automatically free ContinuationPoints from prior requests from a Session if they are needed to process a new request
+ *   from this Session.
+ * - The Server returns a Bad_ContinuationPointInvalid error if a Client tries to use a ContinuationPoint that has been released.
+ * - A Client can avoid this situation by completing paused operations before starting new operations.
+ *   For Session-less Service invocations, the ContinuationPoints are shared across all Session-less Service invocations from all Clients.
+ *   The Server shall support at least the maximum number of ContinuationPoints it would allow for one Session.
+ *
+ * - Requests will often specify multiple operations that may or may not require a ContinuationPoint.
+ * - A Server shall process the operations until it uses the maximum number of continuation points in this response.
+ *   Once that happens the Server shall return a Bad_NoContinuationPoints error for any remaining operations. A Client can avoid
+ *   this situation by sending requests with a number of operations that do not exceed the maximum number  of ContinuationPoints
+ *   per Session defined for the Service in the ServerCapabilities Object defined in OPC 10000-5.
+ *   A Client restarts an operation by passing the ContinuationPoint back to the Server. Server should always be able to reuse the ContinuationPoint
+ *   provided so Servers shall never return Bad_NoContinuationPoints error when continuing a previously halted operation.
+ *   A ContinuationPoint is a subtype of the ByteString data type.
+ *
+ *
+ * for historical access: https://reference.opcfoundation.org/v104/Core/docs/Part11/6.3/
+ *
+ * The continuationPoint parameter in the HistoryRead Service is used to mark a point from which to continue
+ * the read if not all values could be returned in one response. The value is opaque for the Client and is
+ * only used to maintain the state information for the Server to continue from. *
+ *
+ * For HistoricalDataNode requests, a Server may use the timestamp of the last returned data item if the timestamp
+ * is unique. This can reduce the need in the Server to store state information for the continuation point.
+ * The Client specifies the maximum number of results per operation in the request Message. A Server shall
+ * not return more than this number of results but it may return fewer results. The Server allocates a
+ * ContinuationPoint if there are more results to return. The Server may return fewer results due to buffer issues
+ * or other internal constraints. It may also be required to return a continuationPoint due to HistoryRead
+ * parameter constraints. If a request is taking a long time to calculate and is approaching the timeout time, the
+ * Server may return partial results with a continuation point. This may be done if the calculation is going to
+ * take more time than the Client timeout. In some cases it may take longer than the Client timeout to calculate
+ * even one result. Then the Server may return zero results with a continuation point that allows the Server to
+ * resume the calculation on the next Client read call. For additional discussions regarding ContinuationPoints
+ * and HistoryRead please see the individual extensible HistoryReadDetails parameter in 6.4.
+ * If the Client specifies a ContinuationPoint, then the HistoryReadDetails parameter and the TimestampsToReturn
+ * parameter are ignored, because it does not make sense to request different parameters when continuing from a
+ * previous call. It is permissible to change the dataEncoding parameter with each request.
+ * If the Client specifies a ContinuationPoint that is no longer valid, then the Server shall return a
+ * Bad_ContinuationPointInvalid error.
+ * If the releaseContinuationPoints parameter is set in the request the Server shall not return any data and shall
+ * release all ContinuationPoints passed in the request. If the ContinuationPoint for an operation is missing or
+ * invalid then the StatusCode for the operation shall be Bad_ContinuationPointInvalid.
+ */
+export declare class ContinuationPointManager implements IContinuationPointManager {
+    private _map;
+    constructor();
+    /**
+     * returns true if the current number of active continuation point has reached the limit
+     * specified in maxContinuationPoint
+     * @param maxBrowseContinuationPoint
+     */
+    hasReachedMaximum(maxContinuationPoint: number): boolean;
+    clearContinuationPoints(): void;
+    registerHistoryReadRaw(numValuesPerNode: number, dataValues: DataValue[], continuationData: ContinuationData): IContinuationPointInfo<DataValue>;
+    getNextHistoryReadRaw(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<DataValue>;
+    registerReferences(maxElements: number, values: ReferenceDescription[], continuationData: ContinuationData): IContinuationPointInfo<ReferenceDescription>;
+    /**
+     * - releaseContinuationPoints = TRUE
+     *
+     *  passed continuationPoints shall be reset to free resources in
+     *  the Server. The continuation points are released and the results
+     *  and diagnosticInfos arrays are empty.
+     *
+     * - releaseContinuationPoints = FALSE
+     *
+     *   passed continuationPoints shall be used to get the next set of
+     *   browse information
+     */
+    getNextReferences(numValues: number, continuationData: ContinuationData): IContinuationPointInfo<ReferenceDescription>;
+    private _register;
+    private _getNext;
+}

package/dist/source/continuation_points/continuation_point_manager.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContinuationPointManager = void 0;
+/**
+ * @module node-opcua-server
+ */
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
+let counter = 0;
+function make_key() {
+    // return crypto.randomBytes(32);
+    counter += 1;
+    return Buffer.from(counter.toString(), "utf-8");
+}
+/**
+ * from https://reference.opcfoundation.org/v104/Core/docs/Part4/7.6/
+ *
+ * A ContinuationPoint is used to pause a Browse, QueryFirst or HistoryRead operation and allow it to be restarted later by calling BrowseNext,
+ * QueryNext or HistoryRead.
+ * - Operations are paused when the number of results found exceeds the limits set by either the Client or the Server.
+ * - The Client specifies the maximum number of results per operation in the request message.
+ * - A Server shall not return more than this number of results but it may return fewer results.
+ * - The Server allocates a  ContinuationPoint if there are more results to return.
+ * - Servers shall support at least one ContinuationPoint per Session.
+ * - Servers specify a maximum number of ContinuationPoints per Session in the ServerCapabilities Object defined in OPC 10000-5.
+ * - ContinuationPoints remain active until
+ *     a/ the Client retrieves the remaining results,
+ *     b/ or, the Client releases the ContinuationPoint
+ *     c/ or the Session is closed.
+ * - A Server shall automatically free ContinuationPoints from prior requests from a Session if they are needed to process a new request
+ *   from this Session.
+ * - The Server returns a Bad_ContinuationPointInvalid error if a Client tries to use a ContinuationPoint that has been released.
+ * - A Client can avoid this situation by completing paused operations before starting new operations.
+ *   For Session-less Service invocations, the ContinuationPoints are shared across all Session-less Service invocations from all Clients.
+ *   The Server shall support at least the maximum number of ContinuationPoints it would allow for one Session.
+ *
+ * - Requests will often specify multiple operations that may or may not require a ContinuationPoint.
+ * - A Server shall process the operations until it uses the maximum number of continuation points in this response.
+ *   Once that happens the Server shall return a Bad_NoContinuationPoints error for any remaining operations. A Client can avoid
+ *   this situation by sending requests with a number of operations that do not exceed the maximum number  of ContinuationPoints
+ *   per Session defined for the Service in the ServerCapabilities Object defined in OPC 10000-5.
+ *   A Client restarts an operation by passing the ContinuationPoint back to the Server. Server should always be able to reuse the ContinuationPoint
+ *   provided so Servers shall never return Bad_NoContinuationPoints error when continuing a previously halted operation.
+ *   A ContinuationPoint is a subtype of the ByteString data type.
+ *
+ *
+ * for historical access: https://reference.opcfoundation.org/v104/Core/docs/Part11/6.3/
+ *
+ * The continuationPoint parameter in the HistoryRead Service is used to mark a point from which to continue
+ * the read if not all values could be returned in one response. The value is opaque for the Client and is
+ * only used to maintain the state information for the Server to continue from. *
+ *
+ * For HistoricalDataNode requests, a Server may use the timestamp of the last returned data item if the timestamp
+ * is unique. This can reduce the need in the Server to store state information for the continuation point.
+ * The Client specifies the maximum number of results per operation in the request Message. A Server shall
+ * not return more than this number of results but it may return fewer results. The Server allocates a
+ * ContinuationPoint if there are more results to return. The Server may return fewer results due to buffer issues
+ * or other internal constraints. It may also be required to return a continuationPoint due to HistoryRead
+ * parameter constraints. If a request is taking a long time to calculate and is approaching the timeout time, the
+ * Server may return partial results with a continuation point. This may be done if the calculation is going to
+ * take more time than the Client timeout. In some cases it may take longer than the Client timeout to calculate
+ * even one result. Then the Server may return zero results with a continuation point that allows the Server to
+ * resume the calculation on the next Client read call. For additional discussions regarding ContinuationPoints
+ * and HistoryRead please see the individual extensible HistoryReadDetails parameter in 6.4.
+ * If the Client specifies a ContinuationPoint, then the HistoryReadDetails parameter and the TimestampsToReturn
+ * parameter are ignored, because it does not make sense to request different parameters when continuing from a
+ * previous call. It is permissible to change the dataEncoding parameter with each request.
+ * If the Client specifies a ContinuationPoint that is no longer valid, then the Server shall return a
+ * Bad_ContinuationPointInvalid error.
+ * If the releaseContinuationPoints parameter is set in the request the Server shall not return any data and shall
+ * release all ContinuationPoints passed in the request. If the ContinuationPoint for an operation is missing or
+ * invalid then the StatusCode for the operation shall be Bad_ContinuationPointInvalid.
+ */
+class ContinuationPointManager {
+    constructor() {
+        this._map = new Map();
+    }
+    /**
+     * returns true if the current number of active continuation point has reached the limit
+     * specified in maxContinuationPoint
+     * @param maxBrowseContinuationPoint
+     */
+    hasReachedMaximum(maxContinuationPoint) {
+        if (maxContinuationPoint === 0) {
+            return false;
+        }
+        const nbContinuationPoints = this._map.size;
+        return nbContinuationPoints >= maxContinuationPoint;
+    }
+    clearContinuationPoints() {
+        // call when a new request to the server is received
+        this._map.clear();
+    }
+    registerHistoryReadRaw(numValuesPerNode, dataValues, continuationData) {
+        return this._register(numValuesPerNode, dataValues, continuationData);
+    }
+    getNextHistoryReadRaw(numValues, continuationData) {
+        return this._getNext(numValues, continuationData);
+    }
+    registerReferences(maxElements, values, continuationData) {
+        return this._register(maxElements, values, continuationData);
+    }
+    /**
+     * - releaseContinuationPoints = TRUE
+     *
+     *  passed continuationPoints shall be reset to free resources in
+     *  the Server. The continuation points are released and the results
+     *  and diagnosticInfos arrays are empty.
+     *
+     * - releaseContinuationPoints = FALSE
+     *
+     *   passed continuationPoints shall be used to get the next set of
+     *   browse information
+     */
+    getNextReferences(numValues, continuationData) {
+        return this._getNext(numValues, continuationData);
+    }
+    _register(maxValues, values, continuationData) {
+        if (continuationData.releaseContinuationPoints) {
+            this.clearContinuationPoints();
+            return {
+                continuationPoint: undefined,
+                values: [],
+                statusCode: node_opcua_status_code_1.StatusCodes.Good
+            };
+        }
+        if (!continuationData.continuationPoint && !continuationData.index) {
+            if (this._map.size > 0) {
+                warningLog("flushing pending continuationPoints", this._map.size);
+                this.clearContinuationPoints();
+            }
+        }
+        if (maxValues >= 1) {
+            // now make sure that only the requested number of value is returned
+            if (values.length === 0) {
+                return {
+                    continuationPoint: undefined,
+                    values: null,
+                    statusCode: node_opcua_status_code_1.StatusCodes.GoodNoData
+                };
+            }
+        }
+        maxValues = maxValues || values.length;
+        if (maxValues >= values.length) {
+            return {
+                continuationPoint: undefined,
+                values,
+                statusCode: node_opcua_status_code_1.StatusCodes.Good
+            };
+        }
+        // split the array in two ( values)
+        const current_block = values.splice(0, maxValues);
+        const key = make_key();
+        const keyHash = key.toString("utf-8");
+        const result = {
+            continuationPoint: key,
+            values: current_block,
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+        // create
+        const data = {
+            maxElements: maxValues,
+            values: values
+        };
+        this._map.set(keyHash, data);
+        return result;
+    }
+    _getNext(numValues, continuationData) {
+        if (!continuationData.continuationPoint) {
+            return {
+                continuationPoint: undefined,
+                values: null,
+                statusCode: node_opcua_status_code_1.StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        const keyHash = continuationData.continuationPoint.toString("utf-8");
+        const data = this._map.get(keyHash);
+        if (!data) {
+            return {
+                continuationPoint: undefined,
+                values: null,
+                statusCode: node_opcua_status_code_1.StatusCodes.BadContinuationPointInvalid
+            };
+        }
+        const values = data.values.splice(0, numValues || data.maxElements);
+        let continuationPoint = continuationData.continuationPoint;
+        if (data.values.length === 0 || continuationData.releaseContinuationPoints) {
+            // no more data available for next call
+            this._map.delete(keyHash);
+            continuationPoint = undefined;
+        }
+        return {
+            continuationPoint,
+            values,
+            statusCode: node_opcua_status_code_1.StatusCodes.Good
+        };
+    }
+}
+exports.ContinuationPointManager = ContinuationPointManager;
+//# sourceMappingURL=continuation_point_manager.js.map

package/dist/source/continuation_points/continuation_point_manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuation_point_manager.js","sourceRoot":"","sources":["../../../source/continuation_points/continuation_point_manager.ts"],"names":[],"mappings":"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"}

package/dist/source/helpers/adjust_browse_direction.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { BrowseDirection } from "node-opcua-data-model";
+export declare function adjustBrowseDirection(browseDirection: BrowseDirection | null | undefined, defaultValue: BrowseDirection): BrowseDirection;

package/dist/source/helpers/adjust_browse_direction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjustBrowseDirection = void 0;
+function adjustBrowseDirection(browseDirection, defaultValue) {
+    // istanbul ignore next
+    if (browseDirection === null || browseDirection === undefined) {
+        return defaultValue;
+    }
+    return browseDirection;
+}
+exports.adjustBrowseDirection = adjustBrowseDirection;
+//# sourceMappingURL=adjust_browse_direction.js.map

package/dist/source/helpers/adjust_browse_direction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adjust_browse_direction.js","sourceRoot":"","sources":["../../../source/helpers/adjust_browse_direction.ts"],"names":[],"mappings":";;;AAKA,SAAgB,qBAAqB,CACjC,eAAmD,EACnD,YAA6B;IAE7B,uBAAuB;IACvB,IAAI,eAAe,KAAK,IAAI,IAAI,eAAe,KAAK,SAAS,EAAE;QAC3D,OAAO,YAAY,CAAC;KACvB;IACD,OAAO,eAAe,CAAC;AAC3B,CAAC;AATD,sDASC"}

package/dist/source/helpers/argument_list.d.ts

@@ -0,0 +1,33 @@
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { NodeId } from "node-opcua-nodeid";
+import { Argument } from "node-opcua-service-call";
+import { StatusCode } from "node-opcua-status-code";
+import { Variant } from "node-opcua-variant";
+import { DataType } from "node-opcua-variant";
+import { IAddressSpace, UAMethod } from "node-opcua-address-space-base";
+export interface ArgumentDef {
+    dataType: DataType;
+    valueRank?: undefined | number;
+}
+export declare function encode_ArgumentList(definition: ArgumentDef[], args: any[], stream: OutputBinaryStream): void;
+export declare function decode_ArgumentList(definition: ArgumentDef[], stream: BinaryStream): any[];
+export declare function binaryStoreSize_ArgumentList(description: ArgumentDef[], args: any[]): number;
+export declare function getMethodDeclaration_ArgumentList(addressSpace: IAddressSpace, objectId: NodeId, methodId: NodeId): {
+    statusCode: StatusCode;
+    methodDeclaration?: UAMethod;
+};
+/**
+ * @private
+ */
+export declare function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argument, arg: Variant): boolean;
+/**
+ * @method verifyArguments_ArgumentList
+ * @param addressSpace
+ * @param methodInputArguments
+ * @param inputArguments
+ * @return statusCode,inputArgumentResults
+ */
+export declare function verifyArguments_ArgumentList(addressSpace: IAddressSpace, methodInputArguments: Argument[], inputArguments: Variant[]): {
+    inputArgumentResults?: StatusCode[];
+    statusCode: StatusCode;
+};