node-opcua-address-space 2.70.3 → 2.71.0

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

@@ -0,0 +1,74 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { InstantiateObjectOptions, UAMethod, UAObject, UAObjectType } from "../../address_space_ts";
+import { FiniteStateMachineB } from "./finite_state_machine";
+import { State, Transition } from "./state_machine";
+/**
+ * Program Finite State Machine
+ *
+ *
+ * as per part 10 : Program Specification
+ *
+ * A standard set of base states is defined for Programs as part of the Program Finite State
+ * Machine. These states represent the stages in which a Program can exist at an instance in
+ * time as viewed by a Client. This state is the Program’s current state. All Programs shall
+ * support this base set. A Program may or may not require a Client action to cause the state to
+ * change. The states are formally defined in Table 2.
+ *
+ *
+ * Table 2 – Program states
+ *  | State     | Description
+ *  |-----------|-------------------------------------------------------------------------------------|
+ *  | Ready     | The Program is properly initialized and may be started.                             |
+ *  | Running   | The Program is executing making progress towards completion.                        |
+ *  | Suspended | The Program has been stopped prior to reaching a terminal state but may be resumed. |
+ *  | Halted    | The Program is in a terminal or failed state, and it cannot be started or resumed without being reset|
+ *
+ *  The set of states defined to describe a Program can be expanded. Program sub states can be
+ *  defined for the base states to provide more resolution of a process and to describe the cause
+ *  and effect(s) of additional stimuli and transitions.
+ *  Standards bodies and industry groups may extend the base Program Finite State Model to conform to
+ *  various industry models. For example, the Halted state can include the sub states “Aborted” and “Completed”
+ *  to indicate if the function achieved a successful conclusion prior to the transition to Halted.
+ */
+export interface ProgramFiniteStateMachineB extends FiniteStateMachineB {
+    readonly halted: State;
+    readonly ready: State;
+    readonly running: State;
+    readonly suspended: State;
+    readonly haltedToReady: Transition;
+    readonly readyToRunning: Transition;
+    readonly runningToHalted: Transition;
+    readonly runningToReady: Transition;
+    readonly runningToSuspended: Transition;
+    readonly suspendedToRunning: Transition;
+    readonly suspendedToHalted: Transition;
+    readonly suspendedToReady: Transition;
+    readonly readyToHalted: Transition;
+    /**
+     * Start Causes the Program to transition from the Ready state to the Running state.
+     */
+    readonly start: UAMethod;
+    /**
+     * Suspend Causes the Program to transition from the Running state to the Suspended state.
+     */
+    readonly suspend: UAMethod;
+    /**
+     * Resume Causes the Program to transition from the Suspended state to the Running state.
+     */
+    readonly resume: UAMethod;
+    /**
+     * Halt Causes the Program to transition from the Ready, Running or Suspended state to the Halted state.
+     */
+    readonly halt: UAMethod;
+    /**
+     * Reset Causes the Program to transition from the Halted state to the Ready state
+     */
+    reset: UAMethod;
+}
+export interface ProgramFiniteStateMachineType extends ProgramFiniteStateMachineB, UAObjectType {
+    instantiate(options: InstantiateObjectOptions): ProgramFiniteStateMachine;
+}
+export interface ProgramFiniteStateMachine extends ProgramFiniteStateMachineB, UAObject {
+}

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

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

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

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

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

@@ -0,0 +1,342 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { DateTime, UAString, UInt32 } from "node-opcua-basic-types";
+import { LocalizedText, QualifiedName } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import { InstantiateObjectOptions, Property, UAObject, UAObjectType, UAReferenceType, UAVariableT, UAVariableTypeT } from "../../address_space_ts";
+import { _UAStateVariable } from "./ua_state_variable";
+export declare type UtcTime = DateTime;
+export declare type UABaseEventType = UAObjectType;
+export interface NonHierarchicalReferences extends UAReferenceType {
+}
+export interface StateVariableType extends UAVariableTypeT<LocalizedText, DataType.LocalizedText>, _UAStateVariable {
+    isAbstract: false;
+}
+export interface StateVariable extends UAVariableT<LocalizedText, DataType.LocalizedText>, _UAStateVariable {
+}
+/**
+ * The TransitionVariableType is the base VariableType for Variables that store a Transition that
+ * occurred within a StateMachine as a human readable name.
+ *
+ * The SourceTimestamp for the value specifies when the Transition occurred. This value may
+ * also be exposed with the TransitionTime Property
+ */
+export interface TransitionVariableB {
+    isAbstract: false;
+    /**
+     * is a name which uniquely identifies a Transition within the StateMachineType.
+     *
+     * A subtype may restrict the DataType.
+     */
+    id: UAVariableT<UAString | NodeId | UInt32, DataType.String | DataType.NodeId | DataType.UInt32>;
+    /**
+     * Name is a QualifiedName which uniquely identifies a transition within the StateMachineType
+     */
+    name?: UAVariableT<QualifiedName, DataType.QualifiedName>;
+    /**
+     * Number is an integer which uniquely identifies a transition within the StateMachineType.
+     */
+    number?: UAVariableT<UInt32, DataType.UInt32>;
+    /**
+     * TransitionTime specifies when the transition occurred.
+     */
+    transitionTime?: UAVariableT<UtcTime, DataType.DateTime>;
+    /**
+     * Effective Transition time
+     *
+     * EffectiveTransitionTime specifies the time when the current state or one of its substates was
+     * entered. If, for example, a StateA is active and – while active – switches several times between
+     * its substates SubA and SubB, then the TransitionTime stays at the point in time where StateA
+     * became active whereas the EffectiveTransitionTime changes with each change of a substate.
+     */
+    effectiveTransitionTime?: UAVariableT<UtcTime, DataType.DateTime>;
+}
+export interface TransitionVariable extends UAVariableT<LocalizedText, DataType.LocalizedText>, TransitionVariableB {
+}
+export interface StateB {
+    stateNumber: Property<UInt32, DataType.UInt32>;
+}
+export interface StateType extends StateB, UAObjectType {
+}
+export interface State extends StateB, UAObject {
+}
+export interface TransitionB {
+    transitionNumber: Property<UInt32, DataType.UInt32>;
+}
+export interface TransitionType extends TransitionB, UAObjectType {
+}
+export interface Transition extends TransitionB, UAObject {
+}
+/**
+ * Initial State Type
+ *
+ * The InitialStateType is a subtype of the StateType and is formally defined in Table B.8.
+ * An Object of the InitialStateType represents the State that a FiniteStateMachine enters
+ * when it is activated.
+ *
+ * Each FiniteStateMachine can have at most one State of type InitialStateType, but
+ * a FiniteStateMachine does not have to have a State of this type.
+ *
+ * A SubStateMachine goes into its initial state whenever the parent state is entered. However, a
+ * state machine may define a transition that goes directly to a state of the SubStateMachine. In
+ * this case the SubStateMachine goes into that State instead of the initial State. The two
+ * scenarios are illustrated in Figure B.4. The transition from State5 to State6 causes the
+ * SubStateMachine to go into the initial State (State7), however, the transition from State4 to
+ * State8 causes the parent machine to go to State6 and the SubStateMachine will go to State8.
+ *
+ * If no initial state for a SubStateMachine exists and the State having the SubStateMachine is
+ * entered directly, then the State of the SubStateMachine is server-specific.
+ */
+export interface InitialStateB extends StateB {
+}
+export interface InitialStateType extends InitialStateB, StateType {
+}
+export interface InitialState extends InitialStateB, State {
+}
+/**
+ * ToState Reference Type
+ *
+ * The ToState ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to the ending State the
+ * Transition connects.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode of this ReferenceType shall be an Object of the ObjectType
+ * StateType or one of its subtypes.
+ *
+ * References of this ReferenceType may be only exposed uni-directional. Sometimes this is
+ * required, for example, if a Transition points to a State of a sub-machine.
+ */
+export interface ToStateReferenceType extends NonHierarchicalReferences {
+}
+/**
+ *
+ * FromState Reference Type
+ *
+ * The FromState ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to the starting State the
+ * Transition connects.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode of this ReferenceType shall be an Object of the ObjectType
+ * StateType or one of its subtypes.
+ */
+export interface FromStateReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * HasCause
+ * The HasCause ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point form a Transition to something that causes the
+ * Transition. In this annex we only define Methods as Causes. However, the ReferenceType is
+ * not restricted to point to Methods. The referenced Methods can, but do not have to point to a
+ * Method of the StateMachineType. For example, it is allowed to point to a server-wide restart
+ * Method leading the state machine to go into its initial state.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode can be of any NodeClass
+ */
+export interface HasCauseReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * HasEffect ReferenceType
+ *
+ * The HasEffect ReferenceType is a concrete ReferenceType and can be used directly. It is a
+ * subtype of NonHierarchicalReferences.
+ * The semantic of this ReferenceType is to point form a Transition to something that will be
+ * effected when the Transition is triggered. In this annex we only define EventTypes as Effects.
+ *
+ * However, the ReferenceType is not restricted to point to EventTypes.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType TransitionType or
+ * one of its subtypes. The TargetNode can be of any NodeClass.
+ */
+export interface HasEffectReferenceType extends NonHierarchicalReferences {
+}
+/**
+ * The HasSubStateMachine ReferenceType is a concrete ReferenceType and can be used
+ * directly. It is a subtype of NonHierarchicalReferences.
+ *
+ * The semantic of this ReferenceType is to point from a State to an instance of
+ * StateMachineType which represents the sub-states for the State.
+ *
+ * The SourceNode of this ReferenceType shall be an Object of the ObjectType StateType.
+ *
+ * The TargetNode shall be an Object of the ObjectType StateMachineType or one of its subtypes.
+ *
+ * Each Object can be the TargetNode of at most one HasSubStateMachine Reference.
+ *
+ * The SourceNode (the state) and the TargetNode (the SubStateMachine) shall belong to the
+ * same StateMachine, that is, both shall be referenced from the same Object of type
+ * StateMachineType using a HasComponent Reference or a subtype of HasComponent.
+ */
+export interface HasSubStateMachine extends NonHierarchicalReferences {
+}
+/**
+ * The TransitionEventType is a subtype of the BaseEventType. It can be used to generate an
+ * Event identifying that a Transition of a StateMachine was triggered.
+ *
+ * The TransitionEventType inherits the Properties of the BaseEventType.
+ *
+ * The inherited Property SourceNode shall be filled with the NodeId of the StateMachine instance
+ * where the Transition occurs. If the Transition occurs in a SubStateMachine, then the NodeId of
+ * the SubStateMachine has to be used. If the Transition occurs between a StateMachine and a
+ * SubStateMachine, then the NodeId of the StateMachine has to be used, independent of the
+ * direction of the Transition.
+ */
+export interface TransitionEventType extends UABaseEventType {
+    /**
+     *  Transition identifies the Transition that triggered the Event.
+     */
+    transition: TransitionVariable;
+    /**
+     * FromState identifies the State before the Transition.
+     */
+    fromState: StateVariable;
+    /**
+     * ToState identifies the State after the Transition.
+     */
+    toState: StateVariable;
+}
+/**
+ * Transitions of a FiniteStateMachine are represented as Objects of the ObjectType
+ * TransitionType formally defined in Table B.9.
+ * Each valid Transition shall have exactly one FromState Reference and exactly one ToState
+ * Reference, each pointing to an Object of the ObjectType StateType.
+ * Each Transition can have one or more HasCause References pointing to the cause that triggers
+ * the Transition.
+ * Each Transition can have one or more HasEffect References pointing to the effects that occur
+ * when the Transition was triggered.
+ */
+export interface TransitionB {
+    transitionNumber: Property<UInt32, DataType.UInt32>;
+    /**
+     * direct access to the ToState node as defined in the ToState Reference
+     * toStateNode is pointed by the ToStateReferenceType references
+     */
+    toStateNode: State | null;
+    /**
+     * direct access to the FromState node as defined in the ToState Reference
+     * fromStateNode is pointed by the ToStateReferenceType references
+     */
+    fromStateNode: State | null;
+}
+export interface TransitionType extends TransitionB, UAObjectType {
+}
+export interface Transition extends TransitionB, UAObject {
+}
+export declare type TransitionSelector = (transitions: Transition[], fromState: State, toState: State) => Transition | null;
+/**
+ * State Machine type
+ *
+ * StateMachines produce Events which may include the current state of a StateMachine. In that
+ * case Servers shall provide all the optional Properties of the StateVariableType in the Event,
+ * even if they are not provided on the instances in the AddressSpace.
+ */
+/**
+ * StateMachineType
+ *
+ * The StateMachineType is the base ObjectType for all StateMachineTypes. It defines a single
+ * Variable which represents the current state of the machine.
+ * An instance of this ObjectType shall generate an Event whenever a significant state change occurs.
+ * The Server decides which state changes are significant. Servers shall use the GeneratesEvent
+ * ReferenceType to indicate which Event(s) could be produced by the StateMachine.
+ *
+ * Subtypes may add Methods which affect the state of the machine. The Executable Attribute is
+ * used to indicate whether the Method is valid given the current state of the machine. The
+ * generation of AuditEvents for Methods is defined in Part 4. A StateMachine may not be active.
+ *
+ * In this case, the CurrentState and LastTransition Variables shall have a status equal to
+ * BadStateNotActive (see Table B.17).
+ *
+ * Subtypes may add components which are instances of StateMachineTypes. These components
+ * are considered to be sub-states of the StateMachine. SubStateMachines are only active when
+ * the parent machine is in an appropriate state.
+ * Events produced by SubStateMachines may be suppressed by the parent machine. In some
+ * cases, the parent machine will produce a single Event that reflects changes in multiple
+ * SubStateMachines
+ */
+export interface StateMachineB {
+    /**
+     * Current state
+     * CurrentState stores the current state of an instance of the StateMachineType. CurrentState
+     * provides a human readable name for the current state which may not be suitable for use in
+     * application control logic. Applications should use the Id Property of CurrentState if they need a
+     * nique identifier for the state.
+     */
+    readonly currentState: StateVariable;
+    /**
+     * Last transition
+     *
+     * LastTransition stores the last transition which occurred in an instance of the StateMachineType.
+     * LastTransition provides a human readable name.
+     */
+    readonly lastTransition?: TransitionVariable | null;
+    readonly initialState: InitialState | null;
+    readonly states: State[];
+    readonly transitions: Transition[];
+    /**
+     * return all state nodes associated with this state machine
+     */
+    getStates(): State[];
+    /**
+     * return all state to state transition node associated with this state machine
+     */
+    getTransitions(): Transition[];
+    /**
+     * return the state Node by Name
+     * @param name
+     */
+    getStateByName(name: string): State | null;
+    /**
+     * returns true if there is a valid transition from currentStateNode to toStateNode
+     * @param toStateNode
+     */
+    isValidTransition(toStateNode: State | string, predicate?: TransitionSelector): boolean;
+    /**
+     * try to find the valid transition between fromState Node to toState Node
+     * @param fromStateNode
+     * @param toStateNode
+     */
+    findTransitionNode(fromStateNode: State, toStateNode: State, predicate?: TransitionSelector): Transition | null;
+    /**
+     * return the current state as string
+     */
+    getCurrentState(): string | null;
+    /**
+     * change the current state
+     *
+     * note:
+     *  - a transition from currentState to toState node must exists
+     * - a TransitionEventType event will be raised
+     * @param toStateNode
+     */
+    setState(toStateNode: State | string | null, predicate?: TransitionSelector): void;
+}
+export interface StateMachineType extends UAObjectType, StateMachineB {
+    readonly currentState: StateVariable;
+    readonly lastTransition: TransitionVariable;
+    instantiate(options: InstantiateObjectOptions): StateMachine;
+}
+export declare function promoteToStateMachine(node: UAObject): StateMachine;
+export interface StateMachine extends UAObject, StateMachineB {
+    readonly currentState: StateVariable;
+    readonly lastTransition?: TransitionVariable | null;
+    readonly initialState: InitialState | null;
+    readonly states: State[];
+    readonly transitions: Transition[];
+    getStates(): State[];
+    getTransitions(): Transition[];
+    getStateByName(name: string): State | null;
+    isValidTransition(toStateNode: State | string, predicate?: TransitionSelector): boolean;
+    findTransitionNode(fromStateNode: State, toStateNode: State, predicate?: TransitionSelector): Transition | null;
+    getCurrentState(): string | null;
+    setState(toStateNode: State | string, predicate?: TransitionSelector): void;
+}

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

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

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

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

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

@@ -1,12 +1,12 @@
-/**
- * @module node-opcua-address-space
- */
-import { InstantiateObjectOptions, UAObject } from "node-opcua-address-space-base";
-import { UAExclusiveLimitStateMachine_Base } from "node-opcua-nodeset-ua";
-import { UAStateMachineEx, UAStateMachineHelper, UAStateMachineType } from "./ua_state_machine_type";
-export interface UAExclusiveLimitStateMachineEx extends UAObject, UAExclusiveLimitStateMachine_Base, UAStateMachineHelper, UAStateMachineEx {
-}
-export interface UAExclusiveLimitStateMachineType extends UAStateMachineType {
-    isAbstract: false;
-    instantiate(options: InstantiateObjectOptions): UAExclusiveLimitStateMachineEx;
-}
+/**
+ * @module node-opcua-address-space
+ */
+import { InstantiateObjectOptions, UAObject } from "node-opcua-address-space-base";
+import { UAExclusiveLimitStateMachine_Base } from "node-opcua-nodeset-ua";
+import { UAStateMachineEx, UAStateMachineHelper, UAStateMachineType } from "./ua_state_machine_type";
+export interface UAExclusiveLimitStateMachineEx extends UAObject, UAExclusiveLimitStateMachine_Base, UAStateMachineHelper, UAStateMachineEx {
+}
+export interface UAExclusiveLimitStateMachineType extends UAStateMachineType {
+    isAbstract: false;
+    instantiate(options: InstantiateObjectOptions): UAExclusiveLimitStateMachineEx;
+}

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

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

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

@@ -1,49 +1,49 @@
-/**
- * @module node-opcua-address-space
- */
-import { InstantiateObjectOptions } from "node-opcua-address-space-base";
-import { UAStateMachineEx, UAStateMachineType } from "./ua_state_machine_type";
-/**
- * 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;
-}
+/**
+ * @module node-opcua-address-space
+ */
+import { InstantiateObjectOptions } from "node-opcua-address-space-base";
+import { UAStateMachineEx, UAStateMachineType } from "./ua_state_machine_type";
+/**
+ * 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/dist/source/interfaces/state_machine/ua_finite_state_machine_type.js

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

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

@@ -0,0 +1,18 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { LocalizedText } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import { UAVariableT } from "../../address_space_ts";
+import { _UAStateVariable } from "./ua_state_variable";
+export interface FiniteStateVariableB extends _UAStateVariable {
+    /**
+     * Id is inherited from the TransitionVariableType and overridden to reflect
+     * the required DataType.
+     * This value shall be the NodeId of one of the Transition Objects of the FiniteStateMachineType.
+     */
+    id: UAVariableT<NodeId, DataType.NodeId>;
+}
+export interface FiniteStateVariable extends FiniteStateVariableB, UAVariableT<LocalizedText, DataType.LocalizedText> {
+}

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

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

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

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

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

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

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

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