node-opcua-address-space 2.72.2 → 2.74.0

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -9,21 +9,18 @@ import { DataValue } from "node-opcua-data-value";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType, VariantOptions } from "node-opcua-variant";
-import { UAAlarmCondition_Base } from "node-opcua-nodeset-ua";
+import { UAShelvedStateMachine } from "node-opcua-nodeset-ua";
 import { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-address-space-base";
 
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
-import { UAShelvedStateMachineEx, _clear_timer_if_any } from "../state_machine/ua_shelving_state_machine_ex";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { UAShelvedStateMachineExImpl, _clear_timer_if_any } from "../state_machine/ua_shelving_state_machine_ex";
 import { AddressSpacePrivate } from "../address_space_private";
+import { ConditionInfo } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import { UAAlarmConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
 
-import { ConditionInfo } from "./condition_info";
-import {
-    UAAcknowledgeableConditionEx,
-    UAAcknowledgeableConditionHelper,
-    UAAcknowledgeableConditionImpl
-} from "./ua_acknowledgeable_condition_impl";
-import { InstantiateConditionOptions } from "./ua_condition_impl";
+import { ConditionInfoImpl } from "./condition_info_impl";
+import { UAAcknowledgeableConditionImpl } from "./ua_acknowledgeable_condition_impl";
 
 function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
     alarmNode.suppressedOrShelved.setValueFromSource({
@@ -31,45 +28,10 @@ function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
         value: alarmNode.isSuppressedOrShelved()
     });
 }
-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(): any | null;
-    updateState(): void;
-    getCurrentConditionInfo(): ConditionInfo;
-
-    installInputNodeMonitoring(inputNode: BaseNode | NodeId): void;
-}
-
-export declare interface UAAlarmConditionEx extends UAAlarmConditionHelper, UAAlarmCondition_Base, UAAcknowledgeableConditionEx {
-    on(eventName: string, eventHandler: any): this;
-
-    enabledState: UATwoStateVariableEx;
-    activeState: UATwoStateVariableEx;
-    ackedState: UATwoStateVariableEx;
-    confirmedState?: UATwoStateVariableEx;
-
-    suppressedState?: UATwoStateVariableEx;
-
-    outOfServiceState?: UATwoStateVariableEx;
-    shelvingState?: UAShelvedStateMachineEx;
-    silenceState?: UATwoStateVariableEx;
-    latchedState?: UATwoStateVariableEx;
-}
-
 export declare interface UAAlarmConditionImpl extends UAAlarmConditionEx, UAAcknowledgeableConditionImpl {
     on(eventName: string, eventHandler: any): this;
 }
 
-export interface InstantiateAlarmConditionOptions extends InstantiateConditionOptions {
-    maxTimeShelved?: number;
-    inputNode: BaseNode | NodeId;
-}
 export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl implements UAAlarmConditionEx {
     public static MaxDuration = Math.pow(2, 31);
 
@@ -161,7 +123,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
          * @type ShelvingStateMachine
          */
         if (alarmNode.shelvingState) {
-            UAShelvedStateMachineEx.promote(alarmNode.shelvingState);
+            UAShelvedStateMachineExImpl.promote(alarmNode.shelvingState);
         }
 
         // SuppressedOrShelved : Mandatory
@@ -221,7 +183,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
 
     public dispose(): void {
         if (this.shelvingState) {
-            _clear_timer_if_any(this.shelvingState);
+            _clear_timer_if_any(this.shelvingState as any as UAShelvedStateMachineExImpl);
         }
         super.dispose();
     }
@@ -403,7 +365,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         const oldMessage = this.currentBranch().getMessage();
         const oldRetain = this.currentBranch().getRetain();
 
-        const oldConditionInfo = new ConditionInfo({
+        const oldConditionInfo = new ConditionInfoImpl({
             message: oldMessage,
             quality: oldQuality,
             retain: oldRetain,
@@ -448,14 +410,14 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         oldCondition: ConditionInfo
     ): ConditionInfo {
         if (!stateData) {
-            return new ConditionInfo({
+            return new ConditionInfoImpl({
                 message: "Back to normal",
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 0
             });
         } else {
-            return new ConditionInfo({
+            return new ConditionInfoImpl({
                 message: "Condition value is " + value + " and state is " + stateData,
                 quality: StatusCodes.Good,
                 retain: true,

package/src/alarms_and_conditions/ua_base_event_impl.ts

@@ -8,11 +8,8 @@ import { BaseNode } from "node-opcua-address-space-base";
 import { UABaseEvent_Base, UABaseEvent } from "node-opcua-nodeset-ua";
 
 import { UAObjectImpl } from "../ua_object_impl";
+import { UABaseEventHelper } from "../../source/interfaces/alarms_and_conditions/ua_condition_ex";
 
-export interface UABaseEventHelper {
-    setSourceName(name: string): void;
-    setSourceNode(node: NodeId | BaseNode): void;
-}
 export interface UABaseEventEx extends UABaseEvent_Base, UABaseEventHelper {}
 export declare interface UABaseEventImpl extends UABaseEventEx {}
 

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -4,46 +4,43 @@
 import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
 import { DateTime, minOPCUADate } from "node-opcua-basic-types";
 import { make_warningLog } from "node-opcua-debug";
+import { NodeId } from "node-opcua-nodeid";
 import { DataType, VariantOptions } from "node-opcua-variant";
-import { UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
-import { INamespace, UAObject } from "node-opcua-address-space-base";
+import { INamespace, UAObject, UAProperty } from "node-opcua-address-space-base";
 import { ObjectTypeIds } from "node-opcua-constants";
-import { AccessRestrictionsFlag, makeAccessLevelExFlag } from "node-opcua-data-model";
+import { makeAccessLevelExFlag } from "node-opcua-data-model";
+import { UACertificateExpirationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_certificate_expiration_alarm_ex";
+import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { registerNodePromoter } from "../../source/loader/register_node_promoter";
-import { InstantiateOffNormalAlarmOptions, UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
-export interface UACertificateExpirationAlarmEx
-    extends Omit<
-        UACertificateExpirationAlarm_Base,
-        | "ackedState"
-        | "activeState"
-        | "confirmedState"
-        | "enabledState"
-        | "latchedState"
-        | "limitState"
-        | "outOfServiceState"
-        | "shelvingState"
-        | "silenceState"
-        | "suppressedState"
-    > {
-    getExpirationDate(): DateTime;
-    setExpirationDate(value: Date): void;
-    getExpirationLimit(): number;
-    setExpirationLimit(value: number): void;
-    setCertificate(certificate: Certificate | null): void;
-    getCertificate(): Certificate | null;
+export function instantiateCertificateExpirationAlarm(
+    namespace: INamespace,
+    alarmType: "CertificateExpirationAlarmType",
+    options: InstantiateOffNormalAlarmOptions,
+    data?: Record<string, VariantOptions>
+
+): UACertificateExpirationAlarmEx {
+    return UACertificateExpirationAlarmImpl.instantiate(namespace,alarmType, options, data);
 }
 
-export declare interface UACertificateExpirationAlarmImpl extends UACertificateExpirationAlarmEx, UASystemOffNormalAlarmImpl {}
+
+interface UACertificateExpirationAlarmImpl {
+    expirationDate: UAProperty<Date, /*z*/DataType.DateTime>;
+    expirationLimit?: UAProperty<number, /*z*/DataType.Double>;
+    certificateType: UAProperty<NodeId, /*z*/DataType.NodeId>;
+    certificate: UAProperty<Buffer, /*z*/DataType.ByteString>;
+}
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
-export class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
+class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
+
+
     public static instantiate(
         namespace: INamespace,
         alarmType: "CertificateExpirationAlarmType",

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -5,7 +5,7 @@
 import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
-import { ByteString, UAString, UInt16 } from "node-opcua-basic-types";
+import { ByteString } from "node-opcua-basic-types";
 import { randomGuid } from "node-opcua-basic-types";
 import {
     AttributeIds,
@@ -19,7 +19,7 @@ import {
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
-import { minDate } from "node-opcua-factory";
+import { minDate } from "node-opcua-basic-types";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
 import { CallMethodResultOptions, TimeZoneDataType } from "node-opcua-types";
@@ -33,69 +33,26 @@ import {
     UAObject,
     InstantiateObjectOptions
 } from "node-opcua-address-space-base";
-import { UACondition_Base, UAConditionVariable, UACondition } from "node-opcua-nodeset-ua";
+import { UAConditionVariable } from "node-opcua-nodeset-ua";
 
 import { ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { UAConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_condition_ex";
+import { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
+import { InstantiateConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_condition_options";
+
 import { AddressSpacePrivate } from "../address_space_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { UAObjectImpl } from "../ua_object_impl";
 import { UAVariableImpl } from "../ua_variable_impl";
 import { UAConditionType } from "../ua_condition_type";
-import { UABaseEventHelper, UABaseEventImpl } from "./ua_base_event_impl";
-import { ConditionSnapshot } from "./condition_snapshot";
+import { UABaseEventImpl } from "./ua_base_event_impl";
+import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
+
 
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
-export type AddCommentEventHandler = (eventId: Buffer | null, comment: LocalizedText, branch: ConditionSnapshot) => void;
-export interface UAConditionHelper {
-    on(eventName: string, eventHandler: (...args: any[]) => void): this;
-    // -- Events
-    on(eventName: "addComment", eventHandler: AddCommentEventHandler): this;
-    on(eventName: "branch_deleted", eventHandler: (branchId: string) => void): this;
-}
-export interface UAConditionHelper extends UABaseEventHelper {
-    getBranchCount(): number;
-    getBranches(): ConditionSnapshot[];
-    getBranchIds(): NodeId[];
-    createBranch(): ConditionSnapshot;
-    deleteBranch(branch: ConditionSnapshot): void;
-    getEnabledState(): boolean;
-    getEnabledStateAsString(): string;
-    setEnabledState(requestedEnabledState: boolean): 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;
-}
-
-export interface UAConditionEx extends UAObject, UACondition_Base, UAConditionHelper {
-    enabledState: UATwoStateVariableEx;
-    on(eventName: string, eventHandler: any): this;
-    //
-    // conditionClassId: UAProperty<NodeId, /*c*/DataType.NodeId>;
-    // conditionClassName: UAProperty<LocalizedText, /*c*/DataType.LocalizedText>;
-    // conditionSubClassId?: UAProperty<NodeId, /*c*/DataType.NodeId>;
-    // conditionSubClassName?: UAProperty<LocalizedText, /*c*/DataType.LocalizedText>;
-    // conditionName: UAProperty<UAString, /*c*/DataType.String>;
-    // branchId: UAProperty<NodeId, /*c*/DataType.NodeId>;
-    // retain: UAProperty<boolean, /*c*/DataType.Boolean>;
-    // quality: UAConditionVariable<StatusCode, /*c*/DataType.StatusCode>;
-    // lastSeverity: UAConditionVariable<UInt16, /*c*/DataType.UInt16>;
-    // comment: UAConditionVariable<LocalizedText, /*c*/DataType.LocalizedText>;
-    // clientUserId: UAProperty<UAString, /*c*/DataType.String>;
-    // disable: UAMethod;
-    // enable: UAMethod;
-    // addComment: UAMethod;
-    // conditionRefresh: UAMethod;
-    // conditionRefresh2: UAMethod;
-}
 export declare interface UAConditionImpl extends UAConditionEx, UABaseEventImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -217,7 +174,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
             });
             return;
         }
-        assert(branch instanceof ConditionSnapshot);
+        assert(branch instanceof ConditionSnapshotImpl);
 
         const statusCode = inner_func(eventId, comment, branch, conditionNode);
 
@@ -246,8 +203,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
      */
     public post_initialize(): void {
         assert(!this._branch0);
-        this._branch0 = new ConditionSnapshot(this, new NodeId());
-
+        this._branch0 = new ConditionSnapshotImpl(this, new NodeId());
         // the condition OPCUA object alway reflects the default branch states
         // so we set a mechanism that automatically keeps self in sync
         // with the default branch.
@@ -281,7 +237,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
      */
     public createBranch(): ConditionSnapshot {
         const branchId = _create_new_branch_id();
-        const snapshot = new ConditionSnapshot(this, branchId);
+        const snapshot = new ConditionSnapshotImpl(this, branchId);
         this._branches[branchId.toString()] = snapshot;
         return snapshot;
     }
@@ -469,7 +425,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));
 
-        assert(branch instanceof ConditionSnapshot);
+        assert(branch instanceof ConditionSnapshotImpl);
 
         this._assert_valid();
 
@@ -477,7 +433,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
         const conditionOfNode = this.conditionOfNode();
 
         if (conditionOfNode) {
-            const eventData = branch._constructEventData();
+            const eventData = (branch as ConditionSnapshotImpl)._constructEventData();
 
             this.emit("event", eventData);
 
@@ -688,11 +644,7 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
     }
 }
 
-export interface InstantiateConditionOptions extends InstantiateObjectOptions {
-    conditionOf?: UAObject | BaseNode | NodeId | null;
-    conditionClass?: UAObject | BaseNode | NodeId | null;
-    conditionName?: string;
-}
+
 /**
  * instantiate a Condition.
  * this will create the unique EventId and will set eventType
@@ -1191,7 +1143,7 @@ function _add_comment_method(
         (conditionEventId: ByteString, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UAConditionImpl) => {
             assert(inputArguments instanceof Array);
             assert(conditionEventId instanceof Buffer || conditionEventId === null);
-            assert(branch instanceof ConditionSnapshot);
+            assert(branch instanceof ConditionSnapshotImpl);
             branch.setComment(comment);
 
             const sourceName = "Method/AddComment";

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -6,56 +6,9 @@ import { NodeId } from "node-opcua-nodeid";
 import { UADiscreteAlarm, UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
 import { VariantOptions } from "node-opcua-variant";
 import { INamespace, UAEventType } from "node-opcua-address-space-base";
-import {
-    InstantiateAlarmConditionOptions,
-    UAAlarmConditionEx,
-    UAAlarmConditionHelper,
-    UAAlarmConditionImpl
-} from "./ua_alarm_condition_impl";
-
-export interface UADiscreteAlarmHelper extends UAAlarmConditionHelper {
-    on(eventName: string, eventHandle: any): this;
-}
-export interface UADiscreteAlarmEx
-    extends UAAlarmConditionEx,
-        Omit<
-            UADiscreteAlarm_Base,
-            | "suppressedState"
-            | "silenceState"
-            | "shelvingState"
-            | "outOfServiceState"
-            | "latchedState"
-            | "confirmedState"
-            | "ackedState"
-            | "comfirmedState"
-            | "activeState"
-            | "enabledState"
-        >,
-        UADiscreteAlarmHelper {}
-/*=
- *      +----------------------+
- *      | UAAlarmCondition     |
- *      +----------------------+
- *               ^
- *               |
- *      +--------+---------+
- *      | UADiscreteAlarm  |
- *      +------------------+
- *               ^
- *               |
- *      +--------+---------+
- *      | UAOffNormalAlarm |
- *      +------------------+
- *               ^
- *               |
- *      +--------+---------+
- *      |   UATripAlarm    |
- *      +------------------+
- *
- *
- *
- */
-
+import { UADiscreteAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+import { UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
 /**
  * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
  * Alarm may take on only a certain number of possible values (e.g. true/false,

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -9,41 +9,26 @@ import { UAExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
 import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { AddressSpace } from "../address_space";
 import { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import { InstantiateExclusiveLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options";
+import { InstallSetPointOptions } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
 import {
     DeviationAlarmHelper_getSetpointNodeNode,
     DeviationAlarmHelper_getSetpointValue,
     DeviationAlarmHelper_install_setpoint,
     DeviationAlarmHelper_onSetpointDataValueChange,
-    DeviationStuff,
-    InstallSetPointOptions
 } from "./deviation_alarm_helper";
 
-import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-import { InstantiateLimitAlarmOptions, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-
-export interface UAExclusiveDeviationAlarmEx
-    extends Omit<
-            UAExclusiveDeviationAlarm_Base,
-            | "ackedState"
-            | "activeState"
-            | "confirmedState"
-            | "enabledState"
-            | "latchedState"
-            | "limitState"
-            | "outOfServiceState"
-            | "shelvingState"
-            | "silenceState"
-            | "suppressedState"
-        >,
-        UAExclusiveLimitAlarmEx,
-        DeviationStuff {}
+import {  UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+import {  UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+
+
 
 export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviationAlarmEx, UAExclusiveLimitAlarmImpl {
     on(eventName: string, eventHandler: any): this;
     get addressSpace(): AddressSpace;
 }
 
-export interface InstantiateExclusiveLimitAlarmOptions extends InstantiateLimitAlarmOptions, InstallSetPointOptions {}
 export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
     public static instantiate(
         namespace: NamespacePrivate,

package/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

@@ -3,9 +3,9 @@
  */
 import { NodeId } from "node-opcua-nodeid";
 import { VariantOptions } from "node-opcua-variant";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
 import { NamespacePrivate } from "../namespace_private";
 import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
-import { InstantiateLimitAlarmOptions } from "./ua_limit_alarm_impl";
 
 export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
     public static instantiate(

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -4,37 +4,16 @@
 import { assert } from "node-opcua-assert";
 import { NodeId } from "node-opcua-nodeid";
 import { UAObject } from "node-opcua-address-space-base";
-import { UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
 import { VariantOptions } from "node-opcua-variant";
 import { UAEventType } from "node-opcua-address-space-base";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { NamespacePrivate } from "../namespace_private";
 import { promoteToStateMachine } from "../state_machine/finite_state_machine";
-import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
-import { UAExclusiveLimitStateMachineEx } from "../../source/interfaces/state_machine/ua_exclusive_limit_state_machine_type_ex";
-import { InstantiateLimitAlarmOptions, UALimitAlarmEx, UALimitAlarmHelper, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import {  UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 const validState = ["HighHigh", "High", "Low", "LowLow", null];
 
-export interface UAExclusiveLimitAlarmHelper extends UALimitAlarmHelper {}
-export interface UAExclusiveLimitAlarmEx
-    extends Omit<UAExclusiveLimitAlarm_Base, "limitState">,
-        UALimitAlarmEx,
-        UAExclusiveLimitAlarmHelper {
-    on(eventName: string, eventHandler: any): this;
-
-    ackedState: UATwoStateVariableEx;
-    activeState: UATwoStateVariableEx;
-    confirmedState?: UATwoStateVariableEx;
-    enabledState: UATwoStateVariableEx;
-    latchedState?: UATwoStateVariableEx;
-    outOfServiceState?: UATwoStateVariableEx;
-    silenceState?: UATwoStateVariableEx;
-    suppressedState?: UATwoStateVariableEx;
-    //
-    limitState: UAExclusiveLimitStateMachineEx;
-    shelvingState?: UAShelvedStateMachineEx;
-}
 export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {}
 
 export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -2,7 +2,8 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
-import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+import { UAExclusiveLimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
 
 export interface UAExclusiveRateOfChangeAlarmEx
     extends Omit<

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -8,43 +8,17 @@ import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { UALimitAlarm_Base } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType, VariantOptions } from "node-opcua-variant";
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { UAShelvedStateMachineEx } from "../../source";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { UALimitAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_limit_alarm_ex";
 import { NamespacePrivate } from "../namespace_private";
-import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
 import {
-    InstantiateAlarmConditionOptions,
-    UAAlarmConditionEx,
-    UAAlarmConditionHelper,
     UAAlarmConditionImpl
 } from "./ua_alarm_condition_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
-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 {
-    on(eventName: string, eventHandler: any): this;
-
-    enabledState: UATwoStateVariableEx;
-    ackedState: UATwoStateVariableEx;
-    confirmedState?: UATwoStateVariableEx;
-    activeState: UATwoStateVariableEx;
-    latchedState?: UATwoStateVariableEx;
-    outOfServiceState?: UATwoStateVariableEx;
-    silenceState?: UATwoStateVariableEx;
-    shelvingState?: UAShelvedStateMachineEx;
-    suppressedState?: UATwoStateVariableEx;
-}
 
 export declare interface UALimitAlarmImpl extends UALimitAlarmEx, UAAlarmConditionImpl {
     on(eventName: string, eventHandler: any): this;
@@ -61,16 +35,11 @@ const uaLimitAlarmInputSupportedDataType: DataType[] = [
     DataType.UInt32
 ];
 
-export interface InstantiateLimitAlarmOptions extends InstantiateAlarmConditionOptions {
-    highHighLimit: number;
-    highLimit: number;
-    lowLimit: number;
-    lowLowLimit: number;
-    inputNode: UAVariable;
+export interface UALimitAlarmImpl extends UALimitAlarmEx  {
+    shelvingState?: UAShelvedStateMachineEx;
 }
-
 export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
-    /**
+   /**
      * @method (static)UALimitAlarm.instantiate
      * @param namespace {INamespace}
      * @param limitAlarmTypeId

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -6,46 +6,20 @@ import { assert } from "node-opcua-assert";
 
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType, VariantOptions } from "node-opcua-variant";
-import { UANonExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
-import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
+import { VariantOptions } from "node-opcua-variant";
+import { UAVariable } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../namespace_private";
 import { AddressSpace } from "../address_space";
+import { InstantiateLimitAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_limit_alarm_options";
+import { UANonExclusiveDeviationAlarmEx } from "../../source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
 import {
     DeviationAlarmHelper_getSetpointNodeNode,
     DeviationAlarmHelper_getSetpointValue,
     DeviationAlarmHelper_install_setpoint,
-    DeviationAlarmHelper_onSetpointDataValueChange,
-    DeviationStuff
+    DeviationAlarmHelper_onSetpointDataValueChange
 } from "./deviation_alarm_helper";
-import { InstantiateLimitAlarmOptions, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
-import { UANonExclusiveLimitAlarmEx, UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
-
-export interface UANonExclusiveDeviationAlarmEx
-    extends Omit<
-            UANonExclusiveDeviationAlarm_Base,
-            | "ackedState"
-            | "activeState"
-            | "confirmedState"
-            | "enabledState"
-            | "latchedState"
-            | "limitState"
-            | "outOfServiceState"
-            | "shelvingState"
-            | "silenceState"
-            | "suppressedState"
-            //
-            | "highHighState"
-            | "highState"
-            | "lowState"
-            | "lowLowState"
-        >,
-        UANonExclusiveLimitAlarmEx,
-        DeviationStuff {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-    setpointNodeNode: UAVariable;
-}
-
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
 export declare interface UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl, UANonExclusiveDeviationAlarmEx {
     on(eventName: string, eventHandler: any): this;
     get addressSpace(): AddressSpace;