node-opcua-address-space 2.72.2 → 2.73.0

package/source/interfaces/alarms_and_conditions/ua_condition_ex.ts

@@ -0,0 +1,67 @@
+import { BaseNode, UAObject, UAVariable } from "node-opcua-address-space-base";
+import { LocalizedText } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { UACondition_Base } from "node-opcua-nodeset-ua";
+import { StatusCode } from "node-opcua-status-code";
+import { TimeZoneDataType } from "node-opcua-types";
+import { UATwoStateVariableEx } from "../../ua_two_state_variable_ex";
+import { ConditionInfoOptions } from "./condition_info_i";
+import { ConditionSnapshot } from "./condition_snapshot";
+
+
+
+export interface UABaseEventHelper {
+    setSourceName(name: string): void;
+    setSourceNode(node: NodeId | BaseNode): void;
+}
+
+
+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;
+}

package/source/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.ts

@@ -0,0 +1,45 @@
+import { UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAAlarmConditionEx, UAAlarmConditionHelper } from "./ua_alarm_condition_ex";
+
+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    |
+ *      +------------------+
+ *
+ *
+ *
+ */

package/source/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.ts

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

package/source/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.ts

@@ -0,0 +1,25 @@
+import { UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+import { UATwoStateVariableEx } from "../../ua_two_state_variable_ex";
+import { UAExclusiveLimitStateMachineEx } from "../state_machine/ua_exclusive_limit_state_machine_type_ex";
+import { UAShelvedStateMachineEx } from "../state_machine/ua_shelved_state_machine_ex";
+import { UALimitAlarmEx, UALimitAlarmHelper } from "./ua_limit_alarm_ex";
+
+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;
+}

package/source/interfaces/alarms_and_conditions/ua_limit_alarm_ex.ts

@@ -0,0 +1,28 @@
+import { UALimitAlarm_Base } from "node-opcua-nodeset-ua";
+import { UATwoStateVariableEx } from "../../ua_two_state_variable_ex";
+import { UAShelvedStateMachineEx } from "../state_machine/ua_shelved_state_machine_ex";
+import { UAAlarmConditionHelper, UAAlarmConditionEx } from "./ua_alarm_condition_ex";
+
+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;
+}

package/source/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.ts

@@ -0,0 +1,31 @@
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-basic-types";
+import { NodeId } from "node-opcua-nodeid";
+import { UANonExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+import { DeviationStuff } from "./deviation_stuff";
+import { UANonExclusiveLimitAlarmEx } from "./ua_non_exclusive_limit_alarm_ex";
+
+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;
+}

package/source/interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex.ts

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

package/source/interfaces/state_machine/ua_shelved_state_machine_ex.ts

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

package/source/loader/load_nodeset2.ts

@@ -29,12 +29,12 @@ import {
     QualifiedNameOptions,
     stringToQualifiedName
 } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
-import { DataTypeFactory, findSimpleType, getStandardDataTypeFactory } from "node-opcua-factory";
+import { getBuiltInType } from "node-opcua-factory";
 import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { Argument } from "node-opcua-service-call";
-import { CallbackT, ErrorCallback } from "node-opcua-status-code";
+import { ErrorCallback } from "node-opcua-status-code";
 import { EnumFieldOptions, EnumValueType, Range, StructureFieldOptions } from "node-opcua-types";
 import { DataType, Variant, VariantArrayType, VariantOptions } from "node-opcua-variant";
 import {
@@ -89,10 +89,6 @@ function convertAccessLevel(accessLevel?: string | null): AccessLevelFlag {
 
 type Task = (addressSpace: IAddressSpace) => Promise<void>;
 
-function makeDefaultVariant2(addressSpace: IAddressSpace, dataTypeNode: NodeId, valueRank: number): VariantOptions | undefined {
-    const variant: VariantOptions = { dataType: DataType.Null };
-    return variant;
-}
 function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, valueRank: number): VariantOptions | undefined {
     let variant: VariantOptions = { dataType: DataType.Null };
 
@@ -104,19 +100,18 @@ function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, v
             return undefined;
         }
 
-        //  addressSpace.findCorrespondingBasicDataType(dataTypeNode);
         if (basicDataType === DataType.ExtensionObject) {
-            // console.log("xxxxxxxxxx ", dataTypeNode.toString(addressSpace as any));
             return { dataType: DataType.ExtensionObject, value: null };
         }
-        const dv = findSimpleType(DataType[basicDataType]).defaultValue;
-        if (dv === undefined || dv === null) {
-            // return
+        const builtInType = getBuiltInType(DataType[basicDataType]);
+        if (builtInType === undefined || builtInType === null) {
+            errorLog("Cannot find builtInType for ", basicDataType);
             return { dataType: DataType.Null };
         }
-        let arrayType: VariantArrayType;
+        const dv = builtInType.defaultValue;
         const value = typeof dv === "function" ? dv() : dv;
-        //  if (dataType === DataType.ByteString ) { value = Buffer.alloc(0) }
+ 
+        let arrayType: VariantArrayType;
         /*
          *  * n > 1                     : the Value is an array with the specified number of dimensions.
          *  * OneDimension (1):           The value is an array with one dimension.
@@ -142,7 +137,6 @@ function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, v
                 variant = { dataType: basicDataType, value: [], arrayType, dimensions: [] };
                 break;
         }
-        // console.log(variant, DataType[dataType], valueRank);
     }
     return variant;
 }
@@ -1690,6 +1684,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             doDebug && debugLog(chalk.bgGreenBright("Performing DataType extraction -------------------------------------------"));
             assert(!addressSpace1.suspendBackReference);
             await ensureDatatypeExtracted(addressSpace);
+            const dataTypeManager = (addressSpace as AddressSpacePrivate).getDataTypeManager();
 
             /// ----------------------------------------------------------------------------------------
             doDebug && debugLog(chalk.bgGreenBright("DataType extraction done ") + chalk.green("DONE"));
@@ -1698,7 +1693,6 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                 if (dataTypeNodeId.namespace === 0) {
                     continue;
                 }
-                const dataTypeManager = (addressSpace as AddressSpacePrivate).getDataTypeManager();
                 const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
             }
             pendingSimpleTypeToRegister.splice(0);

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,7 +1,7 @@
 import { Byte, coerceInt64, coerceUInt64, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32, UInt64 } from "node-opcua-basic-types";
-import { LocalizedTextLike, LocalizedTextOptions } from "node-opcua-data-model";
+import { LocalizedTextOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
+import { coerceNodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";

package/source/namespace_alarm_and_condition.ts

@@ -1,15 +1,21 @@
 import { UAEventType } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-import { UAAcknowledgeableConditionEx } from "../src/alarms_and_conditions/ua_acknowledgeable_condition_impl";
-import { UAAlarmConditionEx } from "../src/alarms_and_conditions/ua_alarm_condition_impl";
-import { UAConditionEx } from "../src/alarms_and_conditions/ua_condition_impl";
-import { UADiscreteAlarmEx } from "../src/alarms_and_conditions/ua_discrete_alarm_impl";
-import { UAExclusiveDeviationAlarmEx } from "../src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl";
-import { UAExclusiveLimitAlarmEx } from "../src/alarms_and_conditions/ua_exclusive_limit_alarm_impl";
-import { UALimitAlarmEx } from "../src/alarms_and_conditions/ua_limit_alarm_impl";
-import { UANonExclusiveDeviationAlarmEx } from "../src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl";
-import { UANonExclusiveLimitAlarmEx } from "../src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl";
-import { UAOffNormalAlarmEx } from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import { 
+    UAOffNormalAlarmEx 
+} from "../src/alarms_and_conditions/ua_off_normal_alarm_impl";
+import { 
+    UAAcknowledgeableConditionEx 
+} from "./interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import {
+    UAAlarmConditionEx,
+} from "./interfaces/alarms_and_conditions/ua_alarm_condition_ex";
+import { UAConditionEx } from "./interfaces/alarms_and_conditions/ua_condition_ex";
+import { UADiscreteAlarmEx } from "./interfaces/alarms_and_conditions/ua_discrete_alarm_ex";
+import { UAExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex";
+import { UAExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex";
+import { UALimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_limit_alarm_ex";
+import { UANonExclusiveDeviationAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex";
+import { UANonExclusiveLimitAlarmEx } from "./interfaces/alarms_and_conditions/ua_non_exclusive_limit_alarm_ex";
 
 export interface INamespaceAlarmAndCondition {
     // --- Alarms & Conditions -------------------------------------------------

package/src/address_space_private.ts

@@ -60,7 +60,7 @@ export interface AddressSpacePrivate extends IAddressSpace {
 
     getExtensionObjectConstructor(dataType: NodeId | UADataType): ExtensionObjectConstructorFuncWithSchema;
 
-    constructExtensionObject(dataType: UADataType | NodeId, options?: any): ExtensionObject;
+    constructExtensionObject(dataType: UADataType | NodeId, options?: Record<string, unknown>): ExtensionObject;
 
     normalizeReferenceType(params: AddReferenceOpts | UAReference): UAReference;
 

package/src/alarms_and_conditions/condition.ts

@@ -1,23 +1,20 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-// tslint:disable:no-console
-// tslint:disable:no-var-requires
 require("set-prototype-of");
 import { assert } from "node-opcua-assert";
 import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { minDate } from "node-opcua-factory";
+import { minDate } from "node-opcua-basic-types";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
-
-import { ConditionSnapshot } from "./condition_snapshot";
+import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
 
 export function _setAckedState(
-    self: ConditionSnapshot,
+    self: ConditionSnapshotImpl,
     requestedAckedState: boolean,
     conditionEventId?: Buffer,
     comment?: string | LocalizedText | LocalizedTextLike
 ): StatusCode {
-    assert(self instanceof ConditionSnapshot);
+    assert(self instanceof ConditionSnapshotImpl);
 
     const ackedState = self.getAckedState();
 

package/src/alarms_and_conditions/{condition_info.ts → condition_info_impl.ts}

@@ -5,15 +5,9 @@ import { assert } from "node-opcua-assert";
 import { UInt16 } from "node-opcua-basic-types";
 import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
 import { StatusCode } from "node-opcua-status-code";
-import { ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import { ConditionInfo, ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+
 
-export interface ConditionInfo {
-    message: LocalizedText | null;
-    quality: StatusCode | null;
-    severity: UInt16 | null;
-    retain: boolean | null;
-    isDifferentFrom(otherConditionInfo: ConditionInfo): boolean;
-}
 /**
  * @class ConditionInfo
  * @param options  {Object}
@@ -23,7 +17,7 @@ export interface ConditionInfo {
  * @param options.retain   {Boolean} retain flag
  * @constructor
  */
-export class ConditionInfo {
+export class ConditionInfoImpl implements ConditionInfo {
     public message: LocalizedText | null = null;
     public quality: StatusCode | null = null;
     public severity: UInt16 | null = 0;

package/src/alarms_and_conditions/{condition_snapshot.ts → condition_snapshot_impl.ts}

@@ -15,8 +15,9 @@ import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { SimpleAttributeOperand, TimeZoneDataType } from "node-opcua-types";
 import * as utils from "node-opcua-utils";
 import { DataType, Variant } from "node-opcua-variant";
-import { UtcTime } from "../../source/interfaces/state_machine/ua_state_machine_type";
 
+import { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
+import { UtcTime } from "../../source/interfaces/state_machine/ua_state_machine_type";
 import { EventData } from "../event_data";
 import { UATwoStateVariableImpl } from "../state_machine/ua_two_state_variable";
 import { _setAckedState } from "./condition";
@@ -25,9 +26,6 @@ import { UAConditionImpl } from "./ua_condition_impl";
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 
-export interface ConditionSnapshot {
-    on(eventName: "value_changed", eventHandler: (node: UAVariable, variant: Variant) => void): this;
-}
 
 function normalizeName(str: string): string {
     return str.split(".").map(utils.lowerFirstLetter).join(".");
@@ -149,8 +147,7 @@ const _varTable = {
     sourceNode: 1,
     time: 1
 };
-
-export class ConditionSnapshot extends EventEmitter {
+export class ConditionSnapshotImpl extends EventEmitter implements ConditionSnapshot {
     public static normalizeName = normalizeName;
 
     public condition: BaseNode;
@@ -719,8 +716,8 @@ export class ConditionSnapshot extends EventEmitter {
     public _set_twoStateVariable(varName: string, value: boolean): void {
         value = !!value;
 
-        const hrKey = ConditionSnapshot.normalizeName(varName);
-        const idKey = ConditionSnapshot.normalizeName(varName) + ".id";
+        const hrKey = ConditionSnapshotImpl.normalizeName(varName);
+        const idKey = ConditionSnapshotImpl.normalizeName(varName) + ".id";
 
         const variant = new Variant({ dataType: DataType.Boolean, value });
         this._map[idKey] = variant;
@@ -753,7 +750,7 @@ export class ConditionSnapshot extends EventEmitter {
     }
 
     protected _get_twoStateVariable(varName: string): any {
-        const key = ConditionSnapshot.normalizeName(varName) + ".id";
+        const key = ConditionSnapshotImpl.normalizeName(varName) + ".id";
         const variant = this._map[key];
 
         // istanbul ignore next

package/src/alarms_and_conditions/deviation_alarm_helper.ts

@@ -3,24 +3,15 @@
  */
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import { IAddressSpace, BaseNode, UAVariable, UAVariableT } from "node-opcua-address-space-base";
+import { UAVariable } from "node-opcua-address-space-base";
 
 import { AddressSpacePrivate } from "../address_space_private";
+import { DeviationStuff } from "../../source/interfaces/alarms_and_conditions/deviation_stuff";
+import { InstallSetPointOptions } from "../../source/interfaces/alarms_and_conditions/install_setpoint_options";
 
-export interface DeviationStuff {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-    setpointNodeNode: UAVariable;
-    _onSetpointDataValueChange(dataValue: DataValue): void;
-    _setStateBasedOnInputValue(value: any): void;
-    getSetpointNodeNode(): UAVariable;
-    getInputNodeValue(): any;
-    getSetpointValue(): number | null;
 
-    readonly addressSpace: IAddressSpace;
-}
 
 export function DeviationAlarmHelper_getSetpointNodeNode(this: DeviationStuff): UAVariable {
     assert(this.setpointNode.readValue().value.dataType === DataType.NodeId);
@@ -43,9 +34,6 @@ export function DeviationAlarmHelper_onSetpointDataValueChange(this: DeviationSt
     this._setStateBasedOnInputValue(this.getInputNodeValue());
 }
 
-export interface InstallSetPointOptions {
-    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
-}
 export function DeviationAlarmHelper_install_setpoint(this: DeviationStuff, options: InstallSetPointOptions): void {
     // must provide a set point property
     assert(Object.prototype.hasOwnProperty.call(options, "setpointNode"), "must provide a setpointNode");

package/src/alarms_and_conditions/index.ts

@@ -1,8 +1,8 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-export * from "./condition_info";
-export * from "./condition_snapshot";
+export * from "./condition_info_impl";
+export * from "./condition_snapshot_impl";
 export * from "./ua_condition_impl";
 export * from "./ua_acknowledgeable_condition_impl";
 export * from "./ua_discrete_alarm_impl";

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -10,39 +10,16 @@ import { DataType, VariantLike, VariantOptions } from "node-opcua-variant";
 import { INamespace, RaiseEventData, ISessionContext, UAEventType, UAMethod } from "node-opcua-address-space-base";
 import { CallMethodResultOptions } from "node-opcua-service-call";
 
-import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
 import { AddressSpacePrivate } from "../address_space_private";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
+import { UAAcknowledgeableConditionEx } from "../../source/interfaces/alarms_and_conditions/ua_acknowledgeable_condition_ex";
+import { ConditionSnapshot } from "../../source/interfaces/alarms_and_conditions/condition_snapshot";
+import { InstantiateAlarmConditionOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_alarm_condition_options";
+
 import { _setAckedState } from "./condition";
-import { ConditionSnapshot } from "./condition_snapshot";
-import { UAConditionHelper, UAConditionImpl, UAConditionEx } from "./ua_condition_impl";
-import { InstantiateAlarmConditionOptions } from "./ua_alarm_condition_impl";
-
-export interface UAAcknowledgeableConditionHelper extends UAConditionHelper {
-    ///
-    on(eventName: string, eventHandler: (...args: any[]) => void): this;
-
-    on(
-        eventName: "acknowledged" | "confirmed",
-        eventHandler: (eventId: Buffer | null, comment: LocalizedText, branch: ConditionSnapshot) => void
-    ): this;
-}
-export interface UAAcknowledgeableConditionHelper {
-    autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void;
-    acknowledgeAndAutoConfirmBranch(branch: ConditionSnapshot, comment: string | LocalizedTextLike | LocalizedText): void;
-}
-export interface UAAcknowledgeableConditionEx
-    extends UAAcknowledgeableCondition_Base,
-        UAAcknowledgeableConditionHelper,
-        UAConditionEx {
-    on(eventName: string, eventHandler: any): this;
+import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
+import {  UAConditionImpl } from "./ua_condition_impl";
 
-    enabledState: UATwoStateVariableEx;
-    ackedState: UATwoStateVariableEx;
-    confirmedState?: UATwoStateVariableEx;
-    acknowledge: UAMethod;
-    confirm?: UAMethod;
-}
 
 export declare interface UAAcknowledgeableConditionImpl extends UAAcknowledgeableConditionEx, UAConditionImpl {
     on(eventName: string, eventHandler: any): this;
@@ -196,7 +173,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     ): StatusCode {
         assert(typeof message === "string");
 
-        const statusCode = _setAckedState(branch, true, conditionEventId, comment);
+        const statusCode = _setAckedState(branch as ConditionSnapshotImpl, true, conditionEventId, comment);
         if (statusCode !== StatusCodes.Good) {
             return statusCode;
         }
@@ -274,7 +251,7 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
      * @param comment
      */
     public autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void {
-        assert(branch instanceof ConditionSnapshot);
+        assert(branch instanceof ConditionSnapshotImpl);
         if (!this.confirmedState) {
             // no confirmedState => ignoring
             return;
@@ -309,7 +286,7 @@ function _acknowledge_method(
         inputArguments,
         context,
         callback,
-        (conditionEventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UACondition) => {
+        (conditionEventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UAConditionImpl) => {
             const ackConditionNode = conditionNode as UAAcknowledgeableConditionImpl;
             // precondition checking
             assert(!conditionEventId || conditionEventId instanceof Buffer, "must have a valid eventId or  null");
@@ -334,7 +311,7 @@ function _confirm_method(inputArguments: VariantLike[], context: ISessionContext
         inputArguments,
         context,
         callback,
-        (eventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UACondition) => {
+        (eventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UAConditionImpl) => {
             assert(eventId instanceof Buffer);
             assert(branch.getEventId() instanceof Buffer);
             assert(branch.getEventId().toString("hex") === eventId.toString("hex"));