node-opcua-nodeset-adi 2.51.0

package/dist/ua_analyser_channel_operating_mode_sub_state_machine.d.ts

@@ -0,0 +1,351 @@
+import { UAProperty } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-variant";
+import { UInt32 } from "node-opcua-basic-types";
+import { UATransition } from "node-opcua-nodeset-ua/source/ua_transition";
+import { UAFiniteStateMachine, UAFiniteStateMachine_Base } from "node-opcua-nodeset-ua/source/ua_finite_state_machine";
+import { UAInitialState } from "node-opcua-nodeset-ua/source/ua_initial_state";
+import { UAState } from "node-opcua-nodeset-ua/source/ua_state";
+import { UAAnalyserChannel_OperatingModeExecuteSubStateMachine } from "./ua_analyser_channel_operating_mode_execute_sub_state_machine";
+import { UAAnalyserChannelOperatingExecuteState } from "./ua_analyser_channel_operating_execute_state";
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_stoppedToResettingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_resettingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_resettingToIdleTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_idleToStartingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_startingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_startingToExecuteTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_executeToCompletingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completingToCompleteTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completeToStoppedTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_executeToHoldingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_holdingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_holdingToHeldTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_heldToUnholdingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unholdingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToHoldingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToExecuteTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_executeToSuspendingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToSuspendedTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToUnsuspendingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToSuspendingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToExecuteTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_stoppingToStoppedTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_abortingToAbortedTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_abortedToClearingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_clearingToStoppedTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_resettingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_idleToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_startingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_executeToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completeToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_holdingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_heldToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToStoppingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_stoppedToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_resettingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_idleToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_startingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_executeToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_completeToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_holdingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_heldToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_stoppingToAbortingTransition extends Omit<UATransition, "transitionNumber"> {
+    transitionNumber: UAProperty<UInt32, /*z*/ DataType.UInt32>;
+}
+/**
+ * AnalyserChannel OperatingMode SubStateMachine
+ *
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |ObjectType                                        |
+ * |typedDefinition |2:AnalyserChannel_OperatingModeSubStateMachineType ns=2;i=1008|
+ * |isAbstract      |false                                             |
+ */
+export interface UAAnalyserChannel_OperatingModeSubStateMachine_Base extends UAFiniteStateMachine_Base {
+    operatingExecuteSubStateMachine: UAAnalyserChannel_OperatingModeExecuteSubStateMachine;
+    /**
+     * stopped
+     * This is the initial state after
+     * AnalyserDeviceStateMachine state Powerup
+     */
+    stopped: UAInitialState;
+    /**
+     * resetting
+     * This state is the result of a Reset or
+     * SetConfiguration Method call from the Stopped
+     * state.
+     */
+    resetting: UAState;
+    /**
+     * idle
+     * The Resetting state is completed, all parameters
+     * have been committed and ready to start acquisition
+     */
+    idle: UAState;
+    /**
+     * starting
+     * The analyser has received the Start or
+     * SingleAcquisitionStart Method call and it is
+     * preparing to enter in Execute state.
+     */
+    starting: UAState;
+    /**
+     * execute
+     * All repetitive acquisition cycles are done in
+     * this state:
+     */
+    execute: UAAnalyserChannelOperatingExecuteState;
+    /**
+     * completing
+     * This state is an automatic or commanded exit from
+     * the Execute state.
+     */
+    completing: UAState;
+    /**
+     * complete
+     * At this point, the Completing state is done and
+     * it transitions automatically to Stopped state to
+     * wait.
+     */
+    complete: UAState;
+    /**
+     * suspending
+     * This state is a result of a change in monitored
+     * conditions due to process conditions or factors.
+     */
+    suspending: UAState;
+    /**
+     * suspended
+     * The analyser or channel may be running but no
+     * results are being generated while the analyser or
+     * channel is waiting for external process
+     * conditions to return to normal.
+     */
+    suspended: UAState;
+    /**
+     * unsuspending
+     * This state is a result of a device request from
+     * Suspended state to transition back to the Execute
+     * state by calling the Unsuspend Method.
+     */
+    unsuspending: UAState;
+    /**
+     * holding
+     * Brings the analyser or channel to a controlled
+     * stop or to a state which represents Held for the
+     * particular unit control mode
+     */
+    holding: UAState;
+    /**
+     * held
+     * The Held state holds the analyser or channel's
+     * operation. At this state, no acquisition cycle is
+     * performed.
+     */
+    held: UAState;
+    /**
+     * unholding
+     * The Unholding state is a response to an operator
+     * command to resume the Execute state.
+     */
+    unholding: UAState;
+    /**
+     * stopping
+     * Initiated by a Stop Method call, this state:
+     */
+    stopping: UAState;
+    /**
+     * aborting
+     * The Aborting state can be entered at any time in
+     * response to the Abort command or on the
+     * occurrence of a machine fault.
+     */
+    aborting: UAState;
+    /**
+     * aborted
+     * This state maintains machine status information
+     * relevant to the Abort condition.
+     */
+    aborted: UAState;
+    /**
+     * clearing
+     * Clears faults that may have occurred when
+     * Aborting and are present in the Aborted state
+     * before proceeding to a Stopped state
+     */
+    clearing: UAState;
+    stoppedToResettingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_stoppedToResettingTransition;
+    resettingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_resettingTransition;
+    resettingToIdleTransition: UAAnalyserChannel_OperatingModeSubStateMachine_resettingToIdleTransition;
+    idleToStartingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_idleToStartingTransition;
+    startingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_startingTransition;
+    startingToExecuteTransition: UAAnalyserChannel_OperatingModeSubStateMachine_startingToExecuteTransition;
+    executeToCompletingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_executeToCompletingTransition;
+    completingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completingTransition;
+    completingToCompleteTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completingToCompleteTransition;
+    completeToStoppedTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completeToStoppedTransition;
+    executeToHoldingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_executeToHoldingTransition;
+    holdingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_holdingTransition;
+    holdingToHeldTransition: UAAnalyserChannel_OperatingModeSubStateMachine_holdingToHeldTransition;
+    heldToUnholdingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_heldToUnholdingTransition;
+    unholdingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unholdingTransition;
+    unholdingToHoldingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToHoldingTransition;
+    unholdingToExecuteTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToExecuteTransition;
+    executeToSuspendingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_executeToSuspendingTransition;
+    suspendingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendingTransition;
+    suspendingToSuspendedTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToSuspendedTransition;
+    suspendedToUnsuspendingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToUnsuspendingTransition;
+    unsuspendingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingTransition;
+    unsuspendingToSuspendingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToSuspendingTransition;
+    unsuspendingToExecuteTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToExecuteTransition;
+    stoppingToStoppedTransition: UAAnalyserChannel_OperatingModeSubStateMachine_stoppingToStoppedTransition;
+    abortingToAbortedTransition: UAAnalyserChannel_OperatingModeSubStateMachine_abortingToAbortedTransition;
+    abortedToClearingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_abortedToClearingTransition;
+    clearingToStoppedTransition: UAAnalyserChannel_OperatingModeSubStateMachine_clearingToStoppedTransition;
+    resettingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_resettingToStoppingTransition;
+    idleToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_idleToStoppingTransition;
+    startingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_startingToStoppingTransition;
+    executeToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_executeToStoppingTransition;
+    completingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completingToStoppingTransition;
+    completeToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completeToStoppingTransition;
+    suspendingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToStoppingTransition;
+    suspendedToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToStoppingTransition;
+    unsuspendingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToStoppingTransition;
+    holdingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_holdingToStoppingTransition;
+    heldToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_heldToStoppingTransition;
+    unholdingToStoppingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToStoppingTransition;
+    stoppedToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_stoppedToAbortingTransition;
+    resettingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_resettingToAbortingTransition;
+    idleToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_idleToAbortingTransition;
+    startingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_startingToAbortingTransition;
+    executeToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_executeToAbortingTransition;
+    completingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completingToAbortingTransition;
+    completeToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_completeToAbortingTransition;
+    suspendingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendingToAbortingTransition;
+    suspendedToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_suspendedToAbortingTransition;
+    unsuspendingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unsuspendingToAbortingTransition;
+    holdingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_holdingToAbortingTransition;
+    heldToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_heldToAbortingTransition;
+    unholdingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_unholdingToAbortingTransition;
+    stoppingToAbortingTransition: UAAnalyserChannel_OperatingModeSubStateMachine_stoppingToAbortingTransition;
+}
+export interface UAAnalyserChannel_OperatingModeSubStateMachine extends UAFiniteStateMachine, UAAnalyserChannel_OperatingModeSubStateMachine_Base {
+}

package/dist/ua_analyser_channel_operating_mode_sub_state_machine.js

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

package/dist/ua_analyser_channel_operating_mode_sub_state_machine.js.map

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

package/dist/ua_analyser_channel_operating_state.d.ts

@@ -0,0 +1,13 @@
+import { UAState, UAState_Base } from "node-opcua-nodeset-ua/source/ua_state";
+/**
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |ObjectType                                        |
+ * |typedDefinition |2:AnalyserChannelOperatingStateType ns=2;i=1004   |
+ * |isAbstract      |false                                             |
+ */
+export interface UAAnalyserChannelOperatingState_Base extends UAState_Base {
+}
+export interface UAAnalyserChannelOperatingState extends UAState, UAAnalyserChannelOperatingState_Base {
+}

package/dist/ua_analyser_channel_operating_state.js

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

package/dist/ua_analyser_channel_operating_state.js.map

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

package/dist/ua_analyser_channel_state_machine.d.ts

@@ -0,0 +1,60 @@
+import { UAFiniteStateMachine, UAFiniteStateMachine_Base } from "node-opcua-nodeset-ua/source/ua_finite_state_machine";
+import { UAInitialState } from "node-opcua-nodeset-ua/source/ua_initial_state";
+import { UATransition } from "node-opcua-nodeset-ua/source/ua_transition";
+import { UAAnalyserChannel_OperatingModeSubStateMachine } from "./ua_analyser_channel_operating_mode_sub_state_machine";
+import { UAAnalyserChannelOperatingState } from "./ua_analyser_channel_operating_state";
+import { UAAnalyserChannelLocalState } from "./ua_analyser_channel_local_state";
+import { UAAnalyserChannelMaintenanceState } from "./ua_analyser_channel_maintenance_state";
+/**
+ * Contains a nested state model that defines the
+ * top level states Operating, Local and Maintenance
+ *
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |ObjectType                                        |
+ * |typedDefinition |2:AnalyserChannelStateMachineType ns=2;i=1007     |
+ * |isAbstract      |false                                             |
+ */
+export interface UAAnalyserChannelStateMachine_Base extends UAFiniteStateMachine_Base {
+    operatingSubStateMachine: UAAnalyserChannel_OperatingModeSubStateMachine;
+    localSubStateMachine?: UAFiniteStateMachine;
+    maintenanceSubStateMachine?: UAFiniteStateMachine;
+    /**
+     * slaveMode
+     * The AnalyserDevice is in Local or Maintenance
+     * mode and all AnalyserChannels are in SlaveMode
+     */
+    slaveMode: UAInitialState;
+    /**
+     * operating
+     * The AnalyserChannel is in the Operating mode.
+     */
+    operating: UAAnalyserChannelOperatingState;
+    /**
+     * local
+     * The AnalyserChannel is in the Local mode. This
+     * mode is normally used to perform local physical
+     * maintenance on the analyser.
+     */
+    local: UAAnalyserChannelLocalState;
+    /**
+     * maintenance
+     * The AnalyserChannel is in the Maintenance mode.
+     * This mode is used to perform remote maintenance
+     * on the analyser like firmware upgrade.
+     */
+    maintenance: UAAnalyserChannelMaintenanceState;
+    slaveModeToOperatingTransition: UATransition;
+    operatingToLocalTransition: UATransition;
+    operatingToMaintenanceTransition: UATransition;
+    localToOperatingTransition: UATransition;
+    localToMaintenanceTransition: UATransition;
+    maintenanceToOperatingTransition: UATransition;
+    maintenanceToLocalTransition: UATransition;
+    operatingToSlaveModeTransition: UATransition;
+    localToSlaveModeTransition: UATransition;
+    maintenanceToSlaveModeTransition: UATransition;
+}
+export interface UAAnalyserChannelStateMachine extends UAFiniteStateMachine, UAAnalyserChannelStateMachine_Base {
+}

package/dist/ua_analyser_channel_state_machine.js

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

package/dist/ua_analyser_channel_state_machine.js.map

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

package/dist/ua_analyser_device.d.ts

@@ -0,0 +1,97 @@
+import { UAObject, UAMethod, UAProperty } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-variant";
+import { LocalizedText } from "node-opcua-data-model";
+import { UAString } from "node-opcua-basic-types";
+import { UADataItem } from "node-opcua-nodeset-ua/source/ua_data_item";
+import { UAFile } from "node-opcua-nodeset-ua/source/ua_file";
+import { UAFunctionalGroup } from "node-opcua-nodeset-di/source/ua_functional_group";
+import { UADevice, UADevice_Base } from "node-opcua-nodeset-di/source/ua_device";
+import { UAAnalyserDeviceStateMachine } from "./ua_analyser_device_state_machine";
+export interface UAAnalyserDevice_parameterSet extends UAObject {
+    /**
+     * diagnosticStatus
+     * General health status of the analyser
+     */
+    diagnosticStatus: UADataItem<any, any>;
+    /**
+     * configData
+     * Optional analyser device large configuration
+     */
+    configData?: UAFile;
+}
+export interface UAAnalyserDevice_methodSet extends UAObject {
+    getConfiguration: UAMethod;
+    setConfiguration: UAMethod;
+    getConfigDataDigest: UAMethod;
+    compareConfigDataDigest: UAMethod;
+    resetAllChannels: UAMethod;
+    startAllChannels: UAMethod;
+    stopAllChannels: UAMethod;
+    abortAllChannels: UAMethod;
+    gotoOperating: UAMethod;
+    gotoMaintenance: UAMethod;
+}
+export interface UAAnalyserDevice_identification extends UAFunctionalGroup {
+    /**
+     * manufacturer
+     * Name of the company that manufactured the device
+     */
+    manufacturer: UAProperty<LocalizedText, /*z*/ DataType.LocalizedText>;
+    /**
+     * model
+     * Model name of the device
+     */
+    model: UAProperty<LocalizedText, /*z*/ DataType.LocalizedText>;
+    /**
+     * serialNumber
+     * Identifier that uniquely identifies, within a
+     * manufacturer, a device instance
+     */
+    serialNumber: UAProperty<UAString, /*z*/ DataType.String>;
+}
+export interface UAAnalyserDevice_configuration extends UAFunctionalGroup {
+    /**
+     * configData
+     * Optional analyser device large configuration
+     */
+    configData?: UAFile;
+}
+export interface UAAnalyserDevice_status extends UAFunctionalGroup {
+    /**
+     * diagnosticStatus
+     * General health status of the analyser
+     */
+    diagnosticStatus: UADataItem<any, any>;
+}
+/**
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |ObjectType                                        |
+ * |typedDefinition |2:AnalyserDeviceType ns=2;i=1001                  |
+ * |isAbstract      |true                                              |
+ */
+export interface UAAnalyserDevice_Base extends UADevice_Base {
+    /**
+     * parameterSet
+     * Flat list of Parameters
+     */
+    parameterSet?: UAAnalyserDevice_parameterSet;
+    /**
+     * methodSet
+     * Flat list of Methods
+     */
+    methodSet: UAAnalyserDevice_methodSet;
+    /**
+     * identification
+     * Used to organize parameters for identification of
+     * this TopologyElement
+     */
+    identification: UAAnalyserDevice_identification;
+    configuration: UAAnalyserDevice_configuration;
+    status: UAAnalyserDevice_status;
+    factorySettings: UAFunctionalGroup;
+    analyserStateMachine: UAAnalyserDeviceStateMachine;
+}
+export interface UAAnalyserDevice extends Omit<UADevice, "parameterSet" | "methodSet" | "identification">, UAAnalyserDevice_Base {
+}

package/dist/ua_analyser_device.js

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

package/dist/ua_analyser_device.js.map

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

package/dist/ua_analyser_device_state_machine.d.ts

@@ -0,0 +1,57 @@
+import { UAFiniteStateMachine, UAFiniteStateMachine_Base } from "node-opcua-nodeset-ua/source/ua_finite_state_machine";
+import { UAInitialState } from "node-opcua-nodeset-ua/source/ua_initial_state";
+import { UAState } from "node-opcua-nodeset-ua/source/ua_state";
+import { UATransition } from "node-opcua-nodeset-ua/source/ua_transition";
+/**
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |ObjectType                                        |
+ * |typedDefinition |2:AnalyserDeviceStateMachineType ns=2;i=1002      |
+ * |isAbstract      |false                                             |
+ */
+export interface UAAnalyserDeviceStateMachine_Base extends UAFiniteStateMachine_Base {
+    /**
+     * powerup
+     * The AnalyserDevice is in its power-up sequence
+     * and cannot perform any other task.
+     */
+    powerup: UAInitialState;
+    /**
+     * operating
+     * The AnalyserDevice is in the Operating mode.
+     */
+    operating: UAState;
+    /**
+     * local
+     * The AnalyserDevice is in the Local mode. This
+     * mode is normally used to perform local physical
+     * maintenance on the analyser.
+     */
+    local: UAState;
+    /**
+     * maintenance
+     * The AnalyserDevice is in the Maintenance mode.
+     * This mode is used to perform remote maintenance
+     * on the analyser like firmware upgrade.
+     */
+    maintenance: UAState;
+    /**
+     * shutdown
+     * The AnalyserDevice is in its power-down sequence
+     * and cannot perform any other task.
+     */
+    shutdown: UAState;
+    powerupToOperatingTransition: UATransition;
+    operatingToLocalTransition: UATransition;
+    operatingToMaintenanceTransition: UATransition;
+    localToOperatingTransition: UATransition;
+    localToMaintenanceTransition: UATransition;
+    maintenanceToOperatingTransition: UATransition;
+    maintenanceToLocalTransition: UATransition;
+    operatingToShutdownTransition: UATransition;
+    localToShutdownTransition: UATransition;
+    maintenanceToShutdownTransition: UATransition;
+}
+export interface UAAnalyserDeviceStateMachine extends UAFiniteStateMachine, UAAnalyserDeviceStateMachine_Base {
+}

package/dist/ua_analyser_device_state_machine.js

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

package/dist/ua_analyser_device_state_machine.js.map

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

package/dist/ua_chemometric_model.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { UAProperty } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-variant";
+import { LocalizedText } from "node-opcua-data-model";
+import { UABaseDataVariable, UABaseDataVariable_Base } from "node-opcua-nodeset-ua/source/ua_base_data_variable";
+/**
+ * Hold the descriptions of a mathematical process
+ * and associated information to convert scaled data
+ * into one or more process values.
+ *
+ * |                |                                                  |
+ * |----------------|--------------------------------------------------|
+ * |namespace       |http://opcfoundation.org/UA/ADI/                  |
+ * |nodeClass       |VariableType                                      |
+ * |typedDefinition |2:ChemometricModelType ns=2;i=2007                |
+ * |dataType        |ByteString                                        |
+ * |dataType Name   |Buffer ns=0;i=15                                  |
+ * |isAbstract      |false                                             |
+ */
+export interface UAChemometricModel_Base<T extends Buffer> extends UABaseDataVariable_Base<T, /*e*/ DataType.ByteString> {
+    name: UAProperty<LocalizedText, /*z*/ DataType.LocalizedText>;
+    creationDate: UAProperty<Date, /*z*/ DataType.DateTime>;
+    modelDescription: UAProperty<LocalizedText, /*z*/ DataType.LocalizedText>;
+}
+export interface UAChemometricModel<T extends Buffer> extends UABaseDataVariable<T, /*n*/ DataType.ByteString>, UAChemometricModel_Base<T> {
+}