node-opcua-address-space 2.180.0 → 2.181.1

package/api/loader/parsers/variant_parser.ts

@@ -0,0 +1,363 @@
+import { coerceBoolean, coerceInt64, coerceUInt64, DataType, type Int64, isValidGuid, type UInt64 } from "node-opcua-basic-types";
+import {
+    coerceLocalizedText,
+    coerceQualifiedName,
+    type LocalizedTextOptions,
+    type QualifiedNameOptions
+} from "node-opcua-data-model";
+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 { XmlExtensionObjectFragment } from "../nodeset_record.js";
+import { makeExtensionObjectInnerParser, makeExtensionObjectParser } from "./extension_object_parser.js";
+import { type LocalizedTextParserLikeL1, localizedText_parser } from "./localized_text_parser.js";
+import { makeNodeIdParser } from "./nodeid_parser.js";
+import { makeQualifiedNameParser, type QualifiedNameParserL1 } from "./qualified_name_parser.js";
+
+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 };
+}
+
+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);
+
+/** an element of an ExtensionObject array as the reader leaves it: decoded, or waiting as its XML */
+export type ExtensionObjectOrFragment = ExtensionObject | XmlExtensionObjectFragment;
+
+export interface ListOfExtensionObjectParser extends ListOfTParser<ExtensionObjectOrFragment> {
+    listExtensionObject: ExtensionObjectOrFragment[];
+    parser: {
+        ExtensionObject: ParserLike;
+    };
+}
+
+/**
+ * an ExtensionObject value whose XML the reader could not decode holds a placeholder; a value
+ * used where only decoded objects can go (a Variant field of a structure) drops it, as before
+ */
+export function withoutXmlFragments(options: VariantOptions): VariantOptions {
+    if (options.dataType !== DataType.ExtensionObject) {
+        return options;
+    }
+    const value = options.value;
+    if (value instanceof XmlExtensionObjectFragment) {
+        return { ...options, value: null };
+    }
+    if (Array.isArray(value) && value.some((e) => e instanceof XmlExtensionObjectFragment)) {
+        return { ...options, value: value.map((e) => (e instanceof XmlExtensionObjectFragment ? null : e)) };
+    }
+    return options;
+}
+
+/**
+ * the reader of a `<Value>` element: `setValue` receives the value as `VariantOptions`, with the
+ * ids it holds resolved through `translateNodeId`; an extension object the reader cannot decode
+ * on the spot is left in the value as an {@link XmlExtensionObjectFragment}, for the consumer of
+ * the record to decode once the data types are known
+ */
+export function makeVariantReader<T extends ReaderStateParserLike>(
+    setValue: (self: T, data: VariantOptions) => 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) => {
+                    setValue2({
+                        dataType: DataType.ExtensionObject,
+                        arrayType: VariantArrayType.Scalar,
+                        value: new XmlExtensionObjectFragment(xmlEncodingNodeId, bodyXML)
+                    });
+                }
+            ),
+
+            ListOfExtensionObject: {
+                init(this: ListOfExtensionObjectParser) {
+                    this.listExtensionObject = [];
+                },
+                parser: makeExtensionObjectParser<ListOfExtensionObjectParser>(
+                    translateNodeId,
+                    (extensionObject: ExtensionObject, self) => {
+                        self.listExtensionObject.push(extensionObject);
+                    },
+                    (xmlEncodingNodeId: NodeId, bodyXML: string, self) => {
+                        self.listExtensionObject.push(new XmlExtensionObjectFragment(xmlEncodingNodeId, bodyXML));
+                    }
+                ),
+                finish(this: ListOfExtensionObjectParser) {
+                    setValue2({
+                        arrayType: VariantArrayType.Array,
+                        dataType: DataType.ExtensionObject,
+                        value: this.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/api/loader/register_node_promoter.ts

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

package/api/namespace.ts

@@ -0,0 +1,25 @@
+import type { INamespace } from "node-opcua-address-space-base";
+import type { NamespaceToImageOptions, ToNodesetRecordsOptions } from "../impl/nodeset_tools/nodeset_to_records.js";
+import type { NodesetRecord } from "./loader/nodeset_record.js";
+
+import type { INamespaceAlarmAndCondition } from "./namespace_alarm_and_condition.js";
+import type { INamespaceDataAccess } from "./namespace_data_access.js";
+import type { INamespaceMachineState } from "./namespace_machine_state.js";
+
+/** a namespace as a record producer: what the image writer, a loader or a diff consumes */
+export interface INamespaceRecordExport {
+    /**
+     * the header record then one record per node, in the order `toNodeset2XML` writes them, ids in
+     * the exported file's own namespace table
+     */
+    toNodesetRecords(options?: ToNodesetRecordsOptions): Iterable<NodesetRecord>;
+    /** the precompiled image of the namespace */
+    toNodesetImage(options?: NamespaceToImageOptions): Promise<Uint8Array>;
+}
+
+export interface Namespace
+    extends INamespace,
+        INamespaceAlarmAndCondition,
+        INamespaceDataAccess,
+        INamespaceMachineState,
+        INamespaceRecordExport {}

package/api/namespace_alarm_and_condition.ts

@@ -0,0 +1,78 @@
+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 "../impl/alarms_and_conditions/ua_off_normal_alarm_impl.js";
+import type { InstantiateAlarmConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_alarm_condition_options.js";
+import type { InstantiateConditionOptions } from "./interfaces/alarms_and_conditions/instantiate_condition_options.js";
+import type { InstantiateExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_deviation_alarm_options.js";
+import type { InstantiateExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options.js";
+import type { InstantiateLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_limit_alarm_options.js";
+import type { InstantiateNonExclusiveDeviationAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_deviation_alarm_options.js";
+import type { InstantiateNonExclusiveLimitAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_non_exclusive_limit_alarm_options.js";
+import type { InstantiateOffNormalAlarmOptions } from "./interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options.js";
+import type { UAAcknowledgeableConditionEx } from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex.js";
+import type { UAAlarmConditionEx } from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex.js";
+import type { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex.js";
+import type { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex.js";
+import type { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.js";
+import type { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.js";
+import type { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex.js";
+import type { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.js";
+import type { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex.js";
+
+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/api/namespace_data_access.ts

@@ -0,0 +1,92 @@
+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.js";
+import type { UAMultiStateDiscreteEx } from "./interfaces/data_access/ua_multistate_discrete_ex.js";
+import type { UAMultiStateValueDiscreteEx } from "./interfaces/data_access/ua_multistate_value_discrete_ex.js";
+import type { UATwoStateDiscreteEx } from "./interfaces/data_access/ua_two_state_discrete_ex.js";
+import type { UAYArrayItemEx } from "./interfaces/data_access/ua_y_array_item_ex.js";
+import type { UATwoStateVariableEx } from "./ua_two_state_variable_ex.js";
+
+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/api/namespace_machine_state.ts

@@ -0,0 +1,20 @@
+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.js";
+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;
+}