node-opcua-address-space 2.179.0 → 2.181.0

package/source/loader/parsers/variant_parser.ts

@@ -1,433 +0,0 @@
-import type { IAddressSpace, UAVariable } from "node-opcua-address-space-base";
-import { assert } from "node-opcua-assert";
-import { coerceBoolean, coerceInt64, coerceUInt64, DataType, type Int64, isValidGuid, type UInt64 } from "node-opcua-basic-types";
-import {
-    coerceLocalizedText,
-    coerceQualifiedName,
-    type LocalizedTextOptions,
-    NodeClass,
-    type QualifiedNameOptions
-} from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import type { ExtensionObject } from "node-opcua-extension-object";
-import { type NodeId, type NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
-import { VariantArrayType, type VariantOptions } from "node-opcua-variant";
-import type { IReaderState, ParserLike, ReaderStateParserLike, Xml2Json, XmlAttributes } from "node-opcua-xml2json";
-import {
-    createXMLExtensionObjectDecodingTask,
-    makeExtensionObjectInnerParser,
-    makeExtensionObjectParser
-} from "./extension_object_parser";
-import { type LocalizedTextParserLikeL1, localizedText_parser } from "./localized_text_parser";
-import { makeNodeIdParser } from "./nodeid_parser";
-import { makeQualifiedNameParser, type QualifiedNameParserL1 } from "./qualified_name_parser";
-
-const debugLog = make_debugLog(__dirname);
-const doDebug = checkDebugFlag(__dirname);
-
-export type Task = (addressSpace2: IAddressSpace) => Promise<void>;
-
-type IBasicReaderStateParserLike<T> = ReaderStateParserLike & {
-    value: T | undefined;
-    text: string;
-};
-
-function BasicType_parser<T>(dataType: string, parseFunc: (this: { value: T | undefined }, text: string) => T): ParserLike {
-    const _parser: Record<string, ReaderStateParserLike> = {};
-    const a = {
-        init(this: IBasicReaderStateParserLike<T>, _name: string, _attrs: XmlAttributes, _parent: IReaderState, _engine: Xml2Json) {
-            this.value = undefined;
-        },
-        finish(this: IBasicReaderStateParserLike<T>) {
-            this.value = parseFunc.call(this, this.text);
-        }
-    };
-    _parser[dataType] = a as ReaderStateParserLike;
-    return _parser as ParserLike;
-}
-
-function ListOf<T>(
-    _setValue: (data: VariantOptions) => void,
-    dataType: string,
-    parseFunc: (this: { value: T | undefined }, text: string) => T
-) {
-    return {
-        init(this: ListOfTParser<T>) {
-            this.listData = [];
-        },
-
-        parser: BasicType_parser<T>(dataType, parseFunc),
-
-        finish(this: ListOfTParser<T>) {
-            _setValue({
-                arrayType: VariantArrayType.Array,
-                dataType: (DataType as unknown as Record<string, number>)[dataType] as DataType,
-                value: this.listData
-            });
-        },
-        endElement(this: ListOfTParser<T>, _element: string) {
-            this.listData.push(this.parser[dataType].value as T);
-        }
-    };
-}
-
-interface Parser {
-    parent?: Parser;
-    obj?: { nodeId: NodeId };
-}
-
-interface UAVariableTypeWithVariantValue {
-    value: { value: unknown };
-}
-
-function _installExtensionObjectListInitializationPostTask(
-    postTasks2_AssignedExtensionObjectToDataValue: Task[],
-    element: ListOfExtensionObjectParser
-) {
-    let listExtensionObject: (ExtensionObject | null)[] | undefined = element.listExtensionObject;
-    let nodeId: NodeId | undefined = element.parent.parent?.obj?.nodeId;
-    if (!nodeId) {
-        throw new Error("expecting a nodeid");
-    }
-    const task = async (addressSpace2: IAddressSpace) => {
-        const node = nodeId ? addressSpace2.findNode(nodeId) : null;
-        if (!node) {
-            // c8 ignore next
-            doDebug && debugLog(`Cannot find node with nodeId ${nodeId}. may be the node was marked as deprecated`);
-        } else if (node.nodeClass === NodeClass.Variable) {
-            const v = node as UAVariable;
-            assert(v.getBasicDataType() === DataType.ExtensionObject, "expecting an extension object");
-            v.bindExtensionObject(listExtensionObject as ExtensionObject[], { createMissingProp: false });
-        } else if (node.nodeClass === NodeClass.VariableType) {
-            // no need to bind a variable type
-            (node as unknown as UAVariableTypeWithVariantValue) /*fix me*/.value.value = listExtensionObject;
-        }
-        listExtensionObject?.slice(0);
-        listExtensionObject = undefined;
-        nodeId = undefined;
-    };
-    postTasks2_AssignedExtensionObjectToDataValue.push(task);
-}
-
-export interface ListOfTParser<T> extends Parser {
-    listData: T[];
-    parent: Parser;
-    parser: {
-        [key: string]: ReaderStateParserLike & { value?: T; nodeId?: NodeId | string };
-    };
-}
-function parser2(_setValue: (data: VariantOptions) => void, type: string, p: (text: string) => unknown): ReaderStateParserLike {
-    return {
-        finish(this: { text: string }) {
-            _setValue({
-                arrayType: VariantArrayType.Scalar,
-                dataType: (DataType as unknown as Record<string, number>)[type] as DataType,
-                value: p(this.text)
-            });
-        }
-    };
-}
-const parseUInt64 = (str: string): UInt64 => coerceUInt64(str);
-const parseInt64 = (str: string): Int64 => coerceInt64(str);
-
-export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObject> {
-    isDeferred: boolean;
-    listExtensionObject: (ExtensionObject | null)[];
-    listExtensionObjectXML: { xmlEncodingNodeId: NodeId; bodyXML: string }[];
-    parser: {
-        ExtensionObject: ParserLike;
-    };
-}
-
-export function makeVariantReader<T extends ReaderStateParserLike>(
-    setValue: (self: T, data: VariantOptions) => void,
-    setDeferredValue: (self: T, data: VariantOptions, deferedTask: () => ExtensionObject | ExtensionObject[] | null) => void,
-    postExtensionObjectDecoding: (task: (addressSpace: IAddressSpace) => Promise<void>) => void,
-    translateNodeId: (nodeId: string) => NodeId
-): ReaderStateParserLike {
-    let self: T;
-    const setValue2 = (data: VariantOptions) => {
-        setValue(self, data);
-    };
-    const reader = {
-        init(this: ReaderStateParserLike) {
-            /* empty */
-            self = this as T;
-        },
-        parser: {
-            QualifiedName: {
-                ...makeQualifiedNameParser(translateNodeId).QualifiedName,
-                finish(this: QualifiedNameParserL1) {
-                    setValue2({
-                        dataType: DataType.QualifiedName,
-                        value: coerceQualifiedName({ ...this.qualifiedName })
-                    });
-                }
-            },
-            LocalizedText: {
-                ...localizedText_parser.LocalizedText,
-                finish(this: LocalizedTextParserLikeL1) {
-                    setValue2({
-                        dataType: DataType.LocalizedText,
-                        value: coerceLocalizedText({ ...this.localizedText })
-                    });
-                }
-            },
-            XmlElement: {
-                finish(this: { text: string }) {
-                    setValue2({
-                        dataType: DataType.XmlElement,
-                        value: this.text
-                    });
-                }
-            },
-            String: {
-                finish(this: { text: string }) {
-                    setValue2({
-                        dataType: DataType.String,
-                        value: this.text
-                    });
-                }
-            },
-            Guid: {
-                parser: {
-                    String: {
-                        finish(this: { text: string }) {
-                            const guid = this.text;
-                            if (!isValidGuid(guid)) {
-                                /* ?*/
-                            }
-                            setValue2({
-                                dataType: DataType.Guid,
-                                arrayType: VariantArrayType.Scalar,
-                                value: this.text
-                            });
-                        }
-                    }
-                }
-            },
-            NodeId: {
-                parser: {
-                    Identifier: {
-                        finish(this: { text: string }) {
-                            const nodeId = this.text;
-                            setValue2({
-                                dataType: DataType.NodeId,
-                                arrayType: VariantArrayType.Scalar,
-                                value: translateNodeId(resolveNodeId(nodeId).toString())
-                            });
-                        }
-                    }
-                }
-            },
-            Boolean: parser2(setValue2, "Boolean", coerceBoolean),
-            Byte: parser2(setValue2, "Byte", parseInt),
-            Int16: parser2(setValue2, "Int16", parseInt),
-            Int32: parser2(setValue2, "Int32", parseInt),
-            Int8: parser2(setValue2, "Int8", parseInt),
-            SByte: parser2(setValue2, "SByte", parseInt),
-            UInt16: parser2(setValue2, "UInt16", parseInt),
-            UInt32: parser2(setValue2, "UInt32", parseInt),
-            UInt8: parser2(setValue2, "UInt8", parseInt),
-
-            UInt64: parser2(setValue2, "UInt64", parseUInt64),
-            Int64: parser2(setValue2, "Int64", parseInt64),
-
-            ByteString: {
-                init(this: { value: Buffer | null; text: string }) {
-                    this.value = null;
-                },
-                finish(this: { value: Buffer | null; text: string }) {
-                    const base64text = this.text;
-                    const byteString = Buffer.from(base64text, "base64");
-                    setValue2({
-                        arrayType: VariantArrayType.Scalar,
-                        dataType: DataType.ByteString,
-                        value: byteString
-                    });
-                }
-            },
-            Float: {
-                finish(this: { text: string }) {
-                    setValue2({
-                        dataType: DataType.Float,
-                        value: parseFloat(this.text)
-                    });
-                }
-            },
-
-            Double: {
-                finish(this: { text: string }) {
-                    setValue2({
-                        dataType: DataType.Double,
-                        value: parseFloat(this.text)
-                    });
-                }
-            },
-
-            ExtensionObject: makeExtensionObjectInnerParser<ListOfExtensionObjectParser>(
-                translateNodeId,
-                (extensionObject: ExtensionObject) => {
-                    setValue2({
-                        dataType: DataType.ExtensionObject,
-                        value: extensionObject
-                    });
-                },
-                (xmlEncodingNodeId: NodeId, bodyXML: string, _data) => {
-                    let _capturedExtensionObject: ExtensionObject | ExtensionObject[] | null = null;
-                    // extension object creation will be postponed
-                    const task0 = createXMLExtensionObjectDecodingTask(
-                        translateNodeId,
-                        xmlEncodingNodeId,
-                        bodyXML,
-                        (extensionObject: ExtensionObject) => {
-                            _capturedExtensionObject = extensionObject;
-                        }
-                    );
-                    postExtensionObjectDecoding(task0);
-                    setDeferredValue(
-                        self,
-                        {
-                            dataType: DataType.ExtensionObject,
-                            arrayType: VariantArrayType.Scalar,
-                            value: null
-                        },
-                        () => _capturedExtensionObject
-                    );
-                }
-            ),
-
-            ListOfExtensionObject: {
-                init(this: ListOfExtensionObjectParser) {
-                    this.listExtensionObject = [];
-                    this.listExtensionObjectXML = [];
-                    this.isDeferred = false;
-                },
-                parser: makeExtensionObjectParser<ListOfExtensionObjectParser>(
-                    translateNodeId,
-                    (extensionOject: ExtensionObject, self) => {
-                        // const self = reader.parser!.ListOfExtensionObject as ListOfExtensionObjectParser;
-                        self.listExtensionObject.push(extensionOject);
-                    },
-                    (xmlEncodingNodeId: NodeId, bodyXML: string, self) => {
-                        // constœ self = reader.parser!.ListOfExtensionObject as ListOfExtensionObjectParser;
-                        self.isDeferred = true;
-                        self.listExtensionObjectXML.push({ xmlEncodingNodeId, bodyXML });
-                        // extension object creation will be postponed
-                        self.listExtensionObject.push(null);
-                        const index = self.listExtensionObject.length - 1;
-                        assert(index >= 0);
-                        const listExtensionObject = self.listExtensionObject;
-                        const task0 = createXMLExtensionObjectDecodingTask(
-                            translateNodeId,
-                            xmlEncodingNodeId,
-                            bodyXML,
-                            (extensionObject: ExtensionObject) => {
-                                listExtensionObject[index] = extensionObject;
-                            }
-                        );
-                        postExtensionObjectDecoding(task0);
-                    }
-                ),
-                finish(this: ListOfExtensionObjectParser) {
-                    if (!this.isDeferred) {
-                        setValue2({
-                            arrayType: VariantArrayType.Array,
-                            dataType: DataType.ExtensionObject,
-                            value: this.listExtensionObject
-                        });
-                    } else {
-                        // postpone the creation of the extension object
-                        const listExtensionObject: ExtensionObject[] = this.listExtensionObject as ExtensionObject[];
-                        setDeferredValue(
-                            self,
-                            {
-                                arrayType: VariantArrayType.Array,
-                                dataType: DataType.ExtensionObject,
-                                value: null
-                            },
-                            () => listExtensionObject
-                        );
-                        this.listExtensionObject = [];
-                    }
-                }
-            },
-
-            ListOfLocalizedText: {
-                init(this: ListOfTParser<LocalizedTextOptions>) {
-                    this.listData = [];
-                },
-                parser: {
-                    ...localizedText_parser
-                },
-                endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
-                    this.listData.push(this.parser.LocalizedText.value as QualifiedNameOptions);
-                },
-                finish(this: ListOfTParser<QualifiedNameOptions>) {
-                    setValue2({
-                        arrayType: VariantArrayType.Array,
-                        dataType: DataType.LocalizedText,
-                        value: this.listData
-                    });
-                }
-            },
-            ListOfQualifiedName: {
-                init(this: ListOfTParser<QualifiedNameOptions>) {
-                    this.listData = [];
-                },
-                parser: makeQualifiedNameParser(translateNodeId),
-                endElement(this: ListOfTParser<QualifiedNameOptions> /*element*/) {
-                    this.listData.push(this.parser.QualifiedName.value as QualifiedNameOptions);
-                },
-                finish(this: ListOfTParser<QualifiedNameOptions>) {
-                    setValue2({
-                        arrayType: VariantArrayType.Array,
-                        dataType: DataType.QualifiedName,
-                        value: this.listData
-                    });
-                }
-            },
-            ListOfNodeId: {
-                init(this: ListOfTParser<NodeIdLike>) {
-                    this.listData = [];
-                },
-                parser: makeNodeIdParser(translateNodeId),
-                endElement(this: ListOfTParser<NodeIdLike>, _elementName: string) {
-                    this.listData.push(this.parser.NodeId.nodeId as NodeIdLike);
-                },
-                finish(this: ListOfTParser<NodeIdLike>) {
-                    setValue2({
-                        arrayType: VariantArrayType.Array,
-                        dataType: DataType.NodeId,
-                        value: this.listData
-                    });
-                }
-            },
-
-            ListOfBoolean: ListOf<boolean>(setValue2, "Boolean", coerceBoolean),
-
-            ListOfByte: ListOf<number>(setValue2, "Byte", parseInt),
-
-            ListOfDouble: ListOf<number>(setValue2, "Double", parseFloat),
-
-            ListOfFloat: ListOf<number>(setValue2, "Float", parseFloat),
-
-            ListOfInt32: ListOf<number>(setValue2, "Int32", parseInt),
-
-            ListOfInt16: ListOf<number>(setValue2, "Int16", parseInt),
-
-            ListOfInt8: ListOf<number>(setValue2, "Int8", parseInt),
-
-            ListOfUInt32: ListOf<number>(setValue2, "UInt32", parseInt),
-
-            ListOfUInt16: ListOf<number>(setValue2, "UInt16", parseInt),
-
-            ListOfUInt8: ListOf<number>(setValue2, "UInt8", parseInt),
-
-            ListOfString: ListOf<string>(setValue2, "String", (value: string) => value),
-
-            ListOfXmlElement: ListOf<string>(setValue2, "XmlElement", (value: string) => value)
-        }
-    };
-    return reader as unknown as ReaderStateParserLike;
-}

package/source/loader/register_node_promoter.ts

@@ -1,6 +0,0 @@
-import { resolveNodeId } from "node-opcua-nodeid";
-import { g_promotableObject, type Promoter } from "./namespace_post_step";
-
-export function registerNodePromoter(standardNodeId: number, promoter: Promoter, onInstanceOnly = false): void {
-    g_promotableObject.set(resolveNodeId(standardNodeId).toString(), { promoter, onInstanceOnly });
-}

package/source/namespace.ts

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

package/source/namespace_alarm_and_condition.ts

@@ -1,78 +0,0 @@
-import type { UAEventType } from "node-opcua-address-space-base";
-import type { NodeId } from "node-opcua-nodeid";
-import type { VariantOptions } from "node-opcua-variant";
-import type { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
-import type { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
-import type { InstantiateConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_condition_options";
-import type { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options";
-import type { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
-import type { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
-import type { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options";
-import type { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options";
-import type { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
-import type { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
-import type { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
-import type { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
-import type { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
-import type { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
-import type { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
-import type { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
-import type { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
-import type { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
-
-export interface INamespaceAlarmAndCondition {
-    // --- Alarms & Conditions -------------------------------------------------
-    instantiateCondition(
-        conditionTypeId: UAEventType | NodeId | string,
-        options: InstantiateConditionOptions,
-        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/source/namespace_data_access.ts

@@ -1,92 +0,0 @@
-import type {
-    AddVariableOptionsWithoutValue,
-    AddYArrayItemOptions,
-    BindVariableOptions,
-    UADataType,
-    UAVariableType
-} from "node-opcua-address-space-base";
-import type { NodeIdLike } from "node-opcua-nodeid";
-import type { UAAnalogItem, UADataItem } from "node-opcua-nodeset-ua";
-import type { EUInformation, EUInformationOptions } from "node-opcua-types";
-import type { DataType, VariantArrayType } from "node-opcua-variant";
-import type {
-    AddMultiStateDiscreteOptions,
-    AddMultiStateValueDiscreteOptions,
-    AddTwoStateDiscreteOptions,
-    AddTwoStateVariableOptions
-} from "./address_space_ts";
-import type { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex";
-import type { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex";
-import type { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex";
-import type { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex";
-import type { UATwoStateVariableEx } from "./ua_two_state_variable_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 | UADataType;
-
-    /**
-     * an optional VariableType, which must be a subtype of AnalogItemType, to use instead of the
-     * plain AnalogItemType. Its own mandatory members (if any) will be instantiated as well.
-     * @default AnalogItemType
-     */
-    typeDefinition?: string | NodeIdLike | UAVariableType;
-
-    /**
-     * the acceptValueOutOfRange property indicates whether the write operation will accept or reject a value which
-     * is out of range of the instrumentRange.
-     *
-     * **if true**: during a writeOperation by a client if the dataValue that is outside of the instrumentRange
-     * it will be recorded database and the statusCode will be set to BadOutOfRange, and
-     * the write operation will return Good. If the variable supports historizing, the value will be recorded in the history database.
-     * as well.
-     *
-     * **if false**: during a writeOperation by a client, if the dataValue that is outside of the instrumentRange
-     * it will be denied and the write operation will return BadOutOfRange.
-     *
-     * @default undefined (false)
-     *
-     */
-    acceptValueOutOfRange?: boolean;
-}
-
-export interface UAAnalogItemEx<T, DT extends DataType> extends UAAnalogItem<T, DT> {
-    acceptValueOutOfRange?: boolean;
-}
-export interface INamespaceDataAccess {
-    addDataItem<T, DT extends DataType>(options: AddDataItemOptions): UADataItem<T, DT>;
-    addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItemEx<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/source/namespace_machine_state.ts

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