node-opcua-address-space 2.180.0 → 2.181.0

package/api/interfaces/alarms_and_conditions/ua_alarm_condition_ex.ts

@@ -0,0 +1,72 @@
+import type { BaseNode, ListenerSignature, UAVariable } from "node-opcua-address-space-base";
+import type { NodeId } from "node-opcua-nodeid";
+import type { UAAlarmCondition_Base } from "node-opcua-nodeset-ua";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { UAShelvedStateMachineEx } from "../state_machine/ua_shelved_state_machine_ex.js";
+import type { ConditionInfo } from "./condition_info_i.js";
+import type {
+    UAAcknowledgeableConditionEvents,
+    UAAcknowledgeableConditionEx,
+    UAAcknowledgeableConditionHelper
+} from "./ua_acknowledgeable_condition_ex.js";
+
+export interface UAAlarmConditionHelper extends UAAcknowledgeableConditionHelper {
+    activateAlarm(): void;
+    deactivateAlarm(retain?: boolean): void;
+    isSuppressedOrShelved(): boolean;
+    getSuppressedOrShelved(): boolean;
+    setMaxTimeShelved(duration: number): void;
+    getMaxTimeShelved(): number;
+    getInputNodeNode(): UAVariable | null;
+    getInputNodeValue(): number | null;
+    updateState(): void;
+    getCurrentConditionInfo(): ConditionInfo;
+    installInputNodeMonitoring(inputNode: BaseNode | NodeId): void;
+
+    /**
+     * What the alarm reports when its state changes. Assign to it to give an alarm a message
+     * and a severity of its own:
+     *
+     * ```ts
+     * alarm.calculateConditionInfo = (state, isActive, value, oldConditionInfo) =>
+     *     new ConditionInfo({
+     *         message: `Tank is almost ${Math.ceil(Number(value) * 100)}% full`,
+     *         severity: 100,
+     *         quality: StatusCodes.Good,
+     *         retain: true
+     *     });
+     * ```
+     *
+     * The default returns the previous ConditionInfo unchanged, so an alarm that does not
+     * assign one reports nothing new.
+     *
+     * This has been the documented way to give an alarm its own message for years, but under
+     * the name `_calculateConditionInfo` and only on the implementation class, so following
+     * the documentation meant importing from inside the package. That name still works and is
+     * deprecated.
+     */
+    calculateConditionInfo(
+        stateName: string | null,
+        isActive: boolean,
+        value: string,
+        oldConditionInfo: ConditionInfo
+    ): ConditionInfo;
+}
+
+export interface UALarmConditionEvents extends UAAcknowledgeableConditionEvents {}
+export interface UAAlarmConditionEx<T extends UALarmConditionEvents & ListenerSignature<T> = UALarmConditionEvents>
+    extends UAAlarmConditionHelper,
+        UAAlarmCondition_Base,
+        UAAcknowledgeableConditionEx<T> {
+    enabledState: UATwoStateVariableEx;
+    activeState: UATwoStateVariableEx;
+    ackedState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+
+    suppressedState?: UATwoStateVariableEx;
+
+    outOfServiceState?: UATwoStateVariableEx;
+    shelvingState?: UAShelvedStateMachineEx;
+    silenceState?: UATwoStateVariableEx;
+    latchedState?: UATwoStateVariableEx;
+}

package/api/interfaces/alarms_and_conditions/ua_certificate_expiration_alarm_ex.ts

@@ -0,0 +1,36 @@
+import type { DateTime } from "node-opcua-basic-types";
+import type { Certificate } from "node-opcua-crypto/web";
+import type { UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { UAAcknowledgeableConditionEx } from "./ua_acknowledgeable_condition_ex.js";
+
+export interface UACertificateExpirationAlarmEx
+    extends Omit<
+            UACertificateExpirationAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        >,
+        UAAcknowledgeableConditionEx {
+    activeState: UATwoStateVariableEx;
+    suppressedState?: UATwoStateVariableEx;
+
+    getExpirationDate(): DateTime;
+    setExpirationDate(value: Date): void;
+    getExpirationLimit(): number;
+    setExpirationLimit(value: number): void;
+    setCertificate(certificate: Certificate | null): void;
+    getCertificate(): Certificate | null;
+
+    /**
+     * update the    status of the alarm
+     */
+    update(): void;
+}

package/api/interfaces/alarms_and_conditions/ua_condition_ex.ts

@@ -0,0 +1,55 @@
+import type { ListenerSignature, UAObject, UAProperty, UAVariable } from "node-opcua-address-space-base";
+import type { LocalizedText } from "node-opcua-data-model";
+import type { NodeId } from "node-opcua-nodeid";
+import type { UACondition_Base } from "node-opcua-nodeset-ua";
+import type { StatusCode } from "node-opcua-status-code";
+import type { TimeZoneDataType } from "node-opcua-types";
+import type { DataType } from "node-opcua-variant";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { ISetStateOptions } from "../i_set_state_options.js";
+import type { ConditionInfoOptions } from "./condition_info_i.js";
+import type { ConditionSnapshot } from "./condition_snapshot.js";
+import type { UABaseEventEvents, UABaseEventEx, UABaseEventHelper } from "./ua_base_event_ex.js";
+
+export type { UABaseEventHelper } from "./ua_base_event_ex.js";
+
+export type AddCommentEventHandler = (eventId: Buffer | null, comment: LocalizedText, branch: ConditionSnapshot) => void;
+
+export interface UAConditionEvents extends UABaseEventEvents {
+    addComment: AddCommentEventHandler;
+    branch_deleted: (branchId: string) => void;
+}
+
+export interface UAConditionHelper extends UABaseEventHelper {
+    getBranchCount(): number;
+    getBranches(): ConditionSnapshot[];
+    getBranchIds(): NodeId[];
+    createBranch(): ConditionSnapshot;
+    deleteBranch(branch: ConditionSnapshot): void;
+    getEnabledState(): boolean;
+    getEnabledStateAsString(): string;
+    setEnabledState(requestedEnabledState: boolean, options?: ISetStateOptions): StatusCode;
+    setReceiveTime(time: Date): void;
+    setLocalTime(time: TimeZoneDataType): void;
+    setTime(time: Date): void;
+    conditionOfNode(): UAObject | UAVariable | null;
+    raiseConditionEvent(branch: ConditionSnapshot, renewEventId: boolean): void;
+    raiseNewCondition(conditionInfo: ConditionInfoOptions): void;
+    raiseNewBranchState(branch: ConditionSnapshot): void;
+    currentBranch(): ConditionSnapshot;
+    findBranchForEventId(eventId: Buffer | null): ConditionSnapshot | null;
+}
+
+export interface UAConditionEx<T extends UAConditionEvents & ListenerSignature<T> = UAConditionEvents>
+    extends UABaseEventEx,
+        UACondition_Base,
+        UAObject<T>,
+        UAConditionHelper {
+    enabledState: UATwoStateVariableEx;
+    // these are declared as optional in UABaseEvent_Base but required in UACondition_Base;
+    // re-state them here to disambiguate the two parent interfaces.
+    conditionClassId: UAProperty<NodeId, DataType.NodeId>;
+    conditionClassName: UAProperty<LocalizedText, DataType.LocalizedText>;
+    conditionSubClassId?: UAProperty<NodeId[], DataType.NodeId>;
+    conditionSubClassName?: UAProperty<LocalizedText[], DataType.LocalizedText>;
+}

package/api/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.ts

@@ -0,0 +1,17 @@
+import type { UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UAAlarmConditionEx } from "./ua_alarm_condition_ex.js";
+
+export interface UADiscreteAlarmEx
+    extends UAAlarmConditionEx,
+        Omit<
+            UADiscreteAlarm_Base,
+            | "suppressedState"
+            | "silenceState"
+            | "shelvingState"
+            | "outOfServiceState"
+            | "latchedState"
+            | "confirmedState"
+            | "ackedState"
+            | "activeState"
+            | "enabledState"
+        > {}

package/api/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.ts

@@ -0,0 +1,21 @@
+import type { UAExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+import type { DeviationStuff } from "./deviation_stuff.js";
+import type { UAExclusiveLimitAlarmEx } from "./ua_exclusive_limit_alarm_ex.js";
+
+export interface UAExclusiveDeviationAlarmEx
+    extends Omit<
+            UAExclusiveDeviationAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+            | "setpointNode"
+        >,
+        UAExclusiveLimitAlarmEx,
+        DeviationStuff {}

package/api/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.ts

@@ -0,0 +1,21 @@
+import type { UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { UAExclusiveLimitStateMachineEx } from "../state_machine/ua_exclusive_limit_state_machine_type_ex.js";
+import type { UAShelvedStateMachineEx } from "../state_machine/ua_shelved_state_machine_ex.js";
+import type { UALimitAlarmEx, UALimitAlarmHelper } from "./ua_limit_alarm_ex.js";
+
+/** @deprecated kept for backward compatibility — alias of UALimitAlarmHelper. */
+export type UAExclusiveLimitAlarmHelper = UALimitAlarmHelper;
+
+export interface UAExclusiveLimitAlarmEx extends Omit<UAExclusiveLimitAlarm_Base, "limitState">, UALimitAlarmEx {
+    ackedState: UATwoStateVariableEx;
+    activeState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+    enabledState: UATwoStateVariableEx;
+    latchedState?: UATwoStateVariableEx;
+    outOfServiceState?: UATwoStateVariableEx;
+    silenceState?: UATwoStateVariableEx;
+    suppressedState?: UATwoStateVariableEx;
+    limitState: UAExclusiveLimitStateMachineEx;
+    shelvingState?: UAShelvedStateMachineEx;
+}

package/api/interfaces/alarms_and_conditions/ua_limit_alarm_ex.ts

@@ -0,0 +1,26 @@
+import type { UALimitAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { UAShelvedStateMachineEx } from "../state_machine/ua_shelved_state_machine_ex.js";
+import type { UAAlarmConditionEx, UAAlarmConditionHelper } from "./ua_alarm_condition_ex.js";
+
+export interface UALimitAlarmHelper extends UAAlarmConditionHelper {
+    setLowLowLimit(value: number): void;
+    setLowLimit(value: number): void;
+    setHighLimit(value: number): void;
+    setHighHighLimit(value: number): void;
+    getHighHighLimit(): number;
+    getHighLimit(): number;
+    getLowLimit(): number;
+    getLowLowLimit(): number;
+}
+export interface UALimitAlarmEx extends UALimitAlarm_Base, UAAlarmConditionEx, UALimitAlarmHelper {
+    enabledState: UATwoStateVariableEx;
+    ackedState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+    activeState: UATwoStateVariableEx;
+    latchedState?: UATwoStateVariableEx;
+    outOfServiceState?: UATwoStateVariableEx;
+    silenceState?: UATwoStateVariableEx;
+    shelvingState?: UAShelvedStateMachineEx;
+    suppressedState?: UATwoStateVariableEx;
+}

package/api/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.ts

@@ -0,0 +1,29 @@
+import type { UAVariableT } from "node-opcua-address-space-base";
+import type { DataType } from "node-opcua-basic-types";
+import type { UANonExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+import type { DeviationStuff } from "./deviation_stuff.js";
+import type { UANonExclusiveLimitAlarmEx } from "./ua_non_exclusive_limit_alarm_ex.js";
+
+export interface UANonExclusiveDeviationAlarmEx
+    extends Omit<
+            UANonExclusiveDeviationAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+            //
+            | "highHighState"
+            | "highState"
+            | "lowState"
+            | "lowLowState"
+        >,
+        UANonExclusiveLimitAlarmEx,
+        DeviationStuff {
+    setpointNodeNode: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float>;
+}

package/api/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex.ts

@@ -0,0 +1,25 @@
+import type { UANonExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UATwoStateVariableEx } from "../../ua_two_state_variable_ex.js";
+import type { UALimitAlarmEx } from "./ua_limit_alarm_ex.js";
+
+export interface UANonExclusiveLimitAlarmEx
+    extends UALimitAlarmEx,
+        Omit<
+            UANonExclusiveLimitAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        > {
+    activeState: UATwoStateVariableEx;
+    highHighState?: UATwoStateVariableEx;
+    highState?: UATwoStateVariableEx;
+    lowState?: UATwoStateVariableEx;
+    lowLowState?: UATwoStateVariableEx;
+}

package/api/interfaces/data_access/ua_multistate_discrete_ex.ts

@@ -0,0 +1,57 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { DataType, Variant } from "node-opcua-variant";
+
+/**
+ * @see https://reference.opcfoundation.org/v104/Core/docs/Part8/5.3.3/#5.3.3.3
+ */
+
+import type { UAProperty, UAVariableT } from "node-opcua-address-space-base";
+import type { Int64, UInt64 } from "node-opcua-basic-types";
+import type { LocalizedText } from "node-opcua-data-model";
+import type { DTEnumValue, UADiscreteItem, UADiscreteItem_Base, UAMultiStateDiscrete_Base } from "node-opcua-nodeset-ua";
+/**
+ * @module node-opcua-address-space.DataAccess
+ */
+import type { StatusCode } from "node-opcua-status-code";
+import type { ISetStateOptions } from "../i_set_state_options.js";
+
+export { UAMultiStateDiscrete } from "node-opcua-nodeset-ua";
+
+export interface UAMultiStateDiscreteEx<T, DT extends DataType> extends UAVariableT<T, DT>, UAMultiStateDiscrete_Base<T, DT> {
+    //------------ helpers ------------------
+    getValue(): number;
+    getValueAsString(): string;
+    getIndex(value: string): number;
+    setValue(value: string | number, options?: ISetStateOptions): void;
+    checkVariantCompatibility(value: Variant): StatusCode;
+}
+
+export interface UAMultiStateValueDiscreteArray_Base<T, DT extends DataType> extends UADiscreteItem_Base<T, DT> {
+    enumValues: UAProperty<DTEnumValue[], DataType.ExtensionObject>;
+    valueAsText: UAProperty<LocalizedText[], DataType.LocalizedText>;
+}
+
+export interface UAMultiStateValueDiscreteArray<T, DT extends DataType>
+    extends UADiscreteItem<T, DT>,
+        UAMultiStateValueDiscreteArray_Base<T, DT> {
+    /** empty interface */
+}
+
+export interface UAMultiStateValueDiscreteArrayEx<T, DT extends DataType>
+    extends UAVariableT<T, DT>,
+        UAMultiStateValueDiscreteArray_Base<T, DT> {
+    /**
+     * EnumValues is an array of EnumValueType. Each entry of the array represents one enumeration
+     * value with its integer notation, a human-readable representation, and help information.
+     * This represents enumerations with integers that are not zero-based or have gaps (e.g. 1, 2, 4, 8, 16).
+     *  See OPC 10000-3 for the definition of this type. MultiStateValueDiscrete Variables expose the
+     * current integer notation in their Value Attribute. Clients will often read the EnumValues
+     * Property in advance and cache it to lookup a name or help whenever they receive the numeric representation.
+     */
+    getValueAsString(): string[];
+    getValueAsNumber(): number[];
+    setValue(value: string | number | Int64, options?: ISetStateOptions): void;
+    findValueAsText(value: number | UInt64): Variant;
+}

package/api/interfaces/data_access/ua_multistate_value_discrete_ex.ts

@@ -0,0 +1,31 @@
+import type { UAVariableT } from "node-opcua-address-space-base";
+import type { Int64, UInt64 } from "node-opcua-basic-types";
+import type { UAMultiStateValueDiscrete_Base } from "node-opcua-nodeset-ua";
+import type { DataType, Variant } from "node-opcua-variant";
+import type { ISetStateOptions } from "../i_set_state_options.js";
+
+/**
+ * @see https://reference.opcfoundation.org/v104/Core/docs/Part8/5.3.3/#5.3.3.4
+ */
+export interface UAMultiStateValueDiscreteEx<T, DT extends DataType>
+    extends UAVariableT<T, DT>,
+        UAMultiStateValueDiscrete_Base<T, DT> {
+    /**
+     * EnumValues is an array of EnumValueType. Each entry of the array represents one enumeration
+     * value with its integer notation, a human-readable representation, and help information.
+     * This represents enumerations with integers that are not zero-based or have gaps (e.g. 1, 2, 4, 8, 16).
+     *  See OPC 10000-3 for the definition of this type. MultiStateValueDiscrete Variables expose the
+     * current integer notation in their Value Attribute. Clients will often read the EnumValues
+     * Property in advance and cache it to lookup a name or help whenever they receive the numeric representation.
+     */
+    //------------ helpers ------------------
+    //    getValue(): number;
+    //    getIndex(value: string): number;
+
+    getValueAsString(): string;
+    getValueAsNumber(): number;
+
+    setValue(value: string | number | Int64, options?: ISetStateOptions): void;
+
+    findValueAsText(value: number | UInt64): Variant;
+}

package/api/interfaces/data_access/ua_two_state_discrete_ex.ts

@@ -0,0 +1,15 @@
+import type { UAVariableT } from "node-opcua-address-space-base";
+import type { LocalizedTextLike } from "node-opcua-data-model";
+import type { UATwoStateDiscrete_Base } from "node-opcua-nodeset-ua";
+import type { DataType } from "node-opcua-variant";
+import type { ISetStateOptions } from "../i_set_state_options.js";
+
+/**
+ * @see https://reference.opcfoundation.org/v104/Core/VariableTypes/TwoStateDiscreteType/
+ */
+export interface UATwoStateDiscreteEx extends UAVariableT<boolean, DataType.Boolean>, UATwoStateDiscrete_Base<boolean> {
+    // --- helpers ---
+    getValue(): boolean;
+    getValueAsString(): string;
+    setValue(value: boolean | LocalizedTextLike, options?: ISetStateOptions): void;
+}

package/api/interfaces/nodeset_loader_options.ts

@@ -0,0 +1,58 @@
+/**
+ * how a part of the access policy declared in a NodeSet2 file is handled at load time.
+ *
+ *  - `"apply"`  : the declaration is installed on the node, as mandated by OPC UA Part 6 F.3.
+ *  - `"ignore"` : the declaration is discarded. This is what node-opcua did before these options
+ *                 existed: a nodeset declaring a restrictive policy would load fail-open.
+ */
+import type { NodesetImageStore } from "../loader/nodeset_image_store.js";
+
+export type NodeSetPermissionsPolicy = "apply" | "ignore";
+
+export interface NodeSetLoaderOptions {
+    loadDraftNodes?: boolean;
+    loadDeprecatedNodes?: boolean;
+    /**
+     * the `<RolePermissions>` element and the `HasNoPermissions` attribute: *who* may do *what*.
+     *
+     * This is a property of the information model, so it applies by default. `HasNoPermissions`
+     * yields an empty permission list, which is distinct from an absent `<RolePermissions>`:
+     * the former grants nothing, the latter inherits the namespace default.
+     * @default "apply"
+     */
+    permissions?: NodeSetPermissionsPolicy;
+    /**
+     * the `AccessRestrictions` attribute: how the SecureChannel must be secured — signed,
+     * encrypted, session-bound — before the node may be reached at all.
+     *
+     * This one is **opt-in**, because it is a property of the deployment rather than of the
+     * model, and node-opcua cannot assume the deployment matches what the nodeset author had
+     * in mind. `Opc.Ua.NodeSet2.xml` carries 359 of these, and enforcing them denies 199
+     * variables under the Server Object alone — the RoleSet internals, `ServerConfiguration`,
+     * method arguments — to any Session on an unsecured channel. That is the correct reading
+     * of the attribute, and exactly what you want on a hardened server; it is also a large
+     * behaviour change for the many deployments that run with `MessageSecurityMode.None`.
+     *
+     * Turn it on once your endpoints require signing or encryption.
+     * @default "ignore"
+     */
+    accessRestrictions?: NodeSetPermissionsPolicy;
+    /**
+     * how much text the loader parses between two turns of the event loop, in characters, when
+     * a nodeset arrives as a stream: a server starting up keeps answering while a large model
+     * loads. A chunk is parsed whole, so a source delivered in one piece never yields. Zero
+     * disables the yield.
+     * @default 8388608 (8 MiB)
+     */
+    yieldEveryBytes?: number;
+    /**
+     * where precompiled images of the documents are kept between loads. With a store, a
+     * document given whole (a path, a string, bytes) is hashed and its image replayed when the
+     * store has it, parsed and written otherwise; a stream is parsed and written, and replayed
+     * only when its named source carries an `imageKey`. `true` selects the default store: the
+     * per-user file store of the Node.js `generateAddressSpace`, a memory store elsewhere. An
+     * image the store returns that fails to read is discarded and rebuilt.
+     * @default undefined (no store)
+     */
+    imageStore?: NodesetImageStore | boolean;
+}

package/api/interfaces/state_machine/ua_exclusive_limit_state_machine_type_ex.ts

@@ -0,0 +1,20 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { InstantiateObjectOptions, UAObject } from "node-opcua-address-space-base";
+import type { UAExclusiveLimitStateMachine_Base } from "node-opcua-nodeset-ua";
+
+import type { UAStateMachineEx, UAStateMachineHelper, UAStateMachineType } from "./ua_state_machine_type.js";
+
+export interface UAExclusiveLimitStateMachineEx
+    extends UAObject,
+        Omit<UAExclusiveLimitStateMachine_Base, "currentState" | "lastTransition">,
+        UAStateMachineHelper,
+        UAStateMachineEx {
+    /** empty interface */
+}
+
+export interface UAExclusiveLimitStateMachineType extends UAStateMachineType {
+    isAbstract: false;
+    instantiate(options: InstantiateObjectOptions): UAExclusiveLimitStateMachineEx;
+}

package/api/interfaces/state_machine/ua_finite_state_machine_type.ts

@@ -0,0 +1,50 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { InstantiateObjectOptions } from "node-opcua-address-space-base";
+
+import type { UAStateMachineEx, UAStateMachineType } from "./ua_state_machine_type.js";
+/**
+ * Finite State Machine
+ *
+ * The FiniteStateMachineType is the base ObjectType for StateMachines that explicitly define
+ * the possible States and Transitions. Once the States are defined subtypes shall not add new
+ * States (see B.4.18).
+ * The States of the machine are represented with instances of the StateType ObjectType.
+ *
+ * EachState shall have a BrowseName which is unique within the StateMachine and shall have a
+ * StateNumber which shall also be unique across all States defined in the StateMachine.
+ *
+ * Be aware that States in a SubStateMachine may have the same StateNumber or BrowseName as
+ * States in the parent machine. A concrete subtype of FiniteStateMachineType shall define at
+ * least one State.
+ *
+ * A StateMachine may define one State which is an instance of the InitialStateType. This State
+ * is the State that the machine goes into when it is activated.
+ *
+ * The Transitions that may occur are represented with instances of the TransitionType.
+ *
+ * Each Transition shall have a BrowseName which is unique within the StateMachine and may have a
+ * TransitionNumber which shall also be unique across all Transitions defined in the StateMachine.
+ *
+ * The initial State for a Transition is a StateType Object which is the target of a FromState
+ * Reference. The final State for a Transition is a StateType Object which is the target of a ToState
+ * Reference. The FromState and ToState References shall always be specified.
+ * A Transition may produce an Event. The Event is indicated by a HasEffect Reference to a
+ * subtype of BaseEventType. The StateMachineType shall have GeneratesEvent References to
+ * the targets of a HasEffect Reference for each of its Transitions.
+ * A FiniteStateMachineType may define Methods that cause a transition to occur. These Methods
+ * are targets of HasCause References for each of the Transitions that may be triggered by the
+ * Method. The Executable Attribute for a Method is used to indicate whether the current State of
+ * the machine allows the Method to be called.
+ *
+ * A FiniteStateMachineType may have sub-state-machines which are represented as instances
+ * of StateMachineType ObjectTypes. Each State shall have a HasSubStateMachine Reference
+ * to the StateMachineType Object which represents the child States. The SubStateMachine is
+ * not active if the parent State is not active. In this case the CurrentState and LastTransition
+ * Variables of the SubStateMachine shall have a status equal to BadStateNotActive (see Table
+ * B.17).
+ */
+export interface UAFiniteStateMachineType extends UAStateMachineType {
+    instantiate(options: InstantiateObjectOptions): UAStateMachineEx;
+}

package/api/interfaces/state_machine/ua_program_state_machine_type.ts

@@ -0,0 +1,14 @@
+/**
+ * @module node-opcua-address-space
+ */
+import type { InstantiateObjectOptions, UAObjectType } from "node-opcua-address-space-base";
+import type { UAProgramStateMachine_Base } from "node-opcua-nodeset-ua";
+import type { UAStateMachineEx } from "./ua_state_machine_type.js";
+
+export interface UAProgramStateMachineEx extends UAStateMachineEx {
+    /** empty interface */
+}
+
+export interface UAProgramStateMachineType extends UAProgramStateMachine_Base, UAObjectType {
+    instantiate(options: InstantiateObjectOptions): UAProgramStateMachineEx;
+}

package/api/interfaces/state_machine/ua_shelved_state_machine_ex.ts

@@ -0,0 +1,35 @@
+import type { UAMethod, UAProperty } from "node-opcua-address-space-base";
+import type { DataType } from "node-opcua-basic-types";
+import type { UAShelvedStateMachine_Base, UAState } from "node-opcua-nodeset-ua";
+import type { UAStateMachineEx } from "./ua_state_machine_type.js";
+
+import type { UATransitionEx } from "./ua_transition_ex.js";
+
+export interface UAShelvedStateMachineHelper {
+    _timer: NodeJS.Timeout | null;
+    _shelvedTime: Date;
+    _unshelvedTime: Date;
+    _duration: number;
+}
+
+export interface UAShelvedStateMachineEx
+    extends Omit<UAShelvedStateMachine_Base, "currentState" | "lastTransition">,
+        UAStateMachineEx,
+        UAShelvedStateMachineHelper {
+    unshelveTime: UAProperty<number, /*z*/ DataType.Double>;
+    unshelved: UAState;
+    timedShelved: UAState;
+    oneShotShelved: UAState;
+    unshelvedToTimedShelved: UATransitionEx;
+    unshelvedToOneShotShelved: UATransitionEx;
+    timedShelvedToUnshelved: UATransitionEx;
+    timedShelvedToOneShotShelved: UATransitionEx;
+    oneShotShelvedToUnshelved: UATransitionEx;
+    oneShotShelvedToTimedShelved: UATransitionEx;
+    timedShelve: UAMethod;
+    timedShelve2?: UAMethod;
+    unshelve: UAMethod;
+    unshelve2?: UAMethod;
+    oneShotShelve: UAMethod;
+    oneShotShelve2?: UAMethod;
+}