node-opcua-alarm-condition 2.119.0

package/dist/client_alarm_tools_dump_event.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpEvent = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const node_opcua_data_model_1 = require("node-opcua-data-model");
+const node_opcua_variant_1 = require("node-opcua-variant");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const traceLog = (0, node_opcua_debug_1.make_traceLog)("ClientAlarmTool");
+/**
+ *
+ * @param session
+ * @param fields
+ * @param eventFields
+ */
+async function dumpEvent(session, fields, eventFields) {
+    async function getBrowseName(_session, nodeId) {
+        const dataValue = await _session.read({
+            attributeId: node_opcua_data_model_1.AttributeIds.BrowseName,
+            nodeId
+        });
+        if (dataValue.statusCode.isGood()) {
+            const browseName = dataValue.value.value.name;
+            return browseName;
+        }
+        else {
+            return "???";
+        }
+    }
+    function w(str, l) {
+        return (str || "").toString().padEnd(l, " ").substring(0, l);
+    }
+    async function __dumpEvent1(_session, _fields, variant, index) {
+        if (variant.dataType === node_opcua_variant_1.DataType.Null) {
+            return;
+        }
+        if (variant.dataType === node_opcua_variant_1.DataType.NodeId) {
+            const name = await getBrowseName(_session, variant.value);
+            traceLog(chalk_1.default.yellow(w(name, 30), w(_fields[index], 25)), chalk_1.default.cyan(w(node_opcua_variant_1.DataType[variant.dataType], 10).toString()), chalk_1.default.cyan.bold(name), "(", w(variant.value, 20), ")");
+        }
+        else {
+            // tslint:disable-next-line: no-console
+            traceLog(chalk_1.default.yellow(w("", 30), w(_fields[index], 25)), chalk_1.default.cyan(w(node_opcua_variant_1.DataType[variant.dataType], 10).toString()), variant.value);
+        }
+    }
+    async function __dumpEvent(_session, _fields, _eventFields) {
+        let index = 0;
+        const promises = [];
+        for (const variant of _eventFields) {
+            promises.push(__dumpEvent1(_session, _fields, variant, index));
+            index++;
+        }
+        await Promise.all(promises);
+    }
+    await __dumpEvent(session, fields, eventFields);
+}
+exports.dumpEvent = dumpEvent;
+//# sourceMappingURL=client_alarm_tools_dump_event.js.map

package/dist/client_alarm_tools_dump_event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_alarm_tools_dump_event.js","sourceRoot":"","sources":["../source/client_alarm_tools_dump_event.ts"],"names":[],"mappings":"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"}

package/dist/event_stuff.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { NodeId } from "node-opcua-nodeid";
+import { Variant } from "node-opcua-variant";
+export interface TVariant<T> extends Variant {
+    value: T;
+}
+export interface TTwoStateStatus extends TVariant<string> {
+    id: TVariant<boolean>;
+}
+export interface EventStuff {
+    conditionId: TVariant<NodeId>;
+    eventType: TVariant<NodeId>;
+    eventId: TVariant<Buffer>;
+    retain: TVariant<boolean>;
+    activeState: TTwoStateStatus;
+    ackedState: TTwoStateStatus;
+    confirmedState: TTwoStateStatus;
+    conditionName?: TVariant<string>;
+}
+/**
+ * @private
+ */
+export declare function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff;

package/dist/event_stuff.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsToJson = void 0;
+const node_opcua_utils_1 = require("node-opcua-utils");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
+/**
+ * @private
+ */
+function fieldsToJson(fields, eventFields, flat) {
+    function setProperty(_data, fieldName, value) {
+        let name;
+        if (!fieldName || value === null) {
+            return;
+        }
+        if (!flat) {
+            const f = fieldName.split(".");
+            if (f.length === 1) {
+                fieldName = (0, node_opcua_utils_1.lowerFirstLetter)(fieldName);
+                _data[fieldName] = value;
+            }
+            else {
+                for (let i = 0; i < f.length - 1; i++) {
+                    name = (0, node_opcua_utils_1.lowerFirstLetter)(f[i]);
+                    _data[name] = _data[name] || {};
+                    _data = _data[name];
+                }
+                name = (0, node_opcua_utils_1.lowerFirstLetter)(f[f.length - 1]);
+                _data[name] = value;
+            }
+        }
+        else {
+            const name = fieldName.split(".").map(node_opcua_utils_1.lowerFirstLetter).join(".");
+            _data[name] = value;
+        }
+    }
+    if (fields.length > eventFields.length) {
+        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
+    }
+    const data = {};
+    for (let index = 0; index < fields.length; index++) {
+        const variant = eventFields[index];
+        setProperty(data, fields[index], variant);
+    }
+    return data;
+}
+exports.fieldsToJson = fieldsToJson;
+//# sourceMappingURL=event_stuff.js.map

package/dist/event_stuff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event_stuff.js","sourceRoot":"","sources":["../source/event_stuff.ts"],"names":[],"mappings":";;;AACA,uDAAoD;AAGpD,uDAAmD;AACnD,MAAM,UAAU,GAAG,IAAA,kCAAe,EAAC,UAAU,CAAC,CAAC;AAoB/C;;GAEG;AACH,SAAgB,YAAY,CAAC,MAAgB,EAAE,WAAsB,EAAE,IAAc;IAEjF,SAAS,WAAW,CAAC,KAA8B,EAAE,SAAiB,EAAE,KAAc;QAClF,IAAI,IAAY,CAAC;QACjB,IAAI,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC/B,OAAO;QACX,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjB,SAAS,GAAG,IAAA,mCAAgB,EAAC,SAAS,CAAC,CAAC;gBACxC,KAAK,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;YAC7B,CAAC;iBAAM,CAAC;gBACJ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBACpC,IAAI,GAAG,IAAA,mCAAgB,EAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC9B,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;oBAChC,KAAK,GAAG,KAAK,CAAC,IAAI,CAA4B,CAAC;gBACnD,CAAC;gBACD,IAAI,GAAG,IAAA,mCAAgB,EAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBACzC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YACxB,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,mCAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClE,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC;IACL,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC;QACrC,UAAU,CAAC,+CAA+C,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnG,CAAC;IACD,MAAM,IAAI,GAAQ,EAAE,CAAC;IACrB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACjD,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;QACnC,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AApCD,oCAoCC"}

package/dist/extract_condition_fields.d.ts

@@ -0,0 +1,3 @@
+import { NodeIdLike } from "node-opcua-nodeid";
+import { ISessionForExtractField } from "node-opcua-pseudo-session";
+export declare function extractConditionFields(session: ISessionForExtractField, conditionNodeId: NodeIdLike): Promise<string[]>;

package/dist/extract_condition_fields.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConditionFields = void 0;
+const node_opcua_pseudo_session_1 = require("node-opcua-pseudo-session");
+async function extractConditionFields(session, conditionNodeId) {
+    // conditionNodeId could be a Object of type ConditionType
+    // or it could be directly a ObjectType which is a subType of ConditionType
+    const p = await (0, node_opcua_pseudo_session_1.extractFields)(session, conditionNodeId);
+    const fields1 = (0, node_opcua_pseudo_session_1.simpleBrowsePathsToString)(p.map((a) => a.path));
+    // add this field which will always be added
+    fields1.push("ConditionId");
+    return fields1;
+}
+exports.extractConditionFields = extractConditionFields;
+//# sourceMappingURL=extract_condition_fields.js.map

package/dist/extract_condition_fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract_condition_fields.js","sourceRoot":"","sources":["../source/extract_condition_fields.ts"],"names":[],"mappings":";;;AACA,yEAA8G;AAEvG,KAAK,UAAU,sBAAsB,CAAC,OAAgC,EAAE,eAA2B;IACtG,0DAA0D;IAC1D,2EAA2E;IAC3E,MAAM,CAAC,GAAG,MAAM,IAAA,yCAAa,EAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,IAAA,qDAAyB,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAChE,4CAA4C;IAC5C,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC5B,OAAO,OAAO,CAAC;AACnB,CAAC;AARD,wDAQC"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./acknowledge_all_conditions";
+export * from "./call_condition_refresh";
+export * from "./call_method_condition";
+export * from "./client_alarm_list";
+export * from "./client_alarm_tools_dump_event";
+export * from "./client_alarm";
+export * from "./event_stuff";
+export * from "./extract_condition_fields";

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./acknowledge_all_conditions"), exports);
+__exportStar(require("./call_condition_refresh"), exports);
+__exportStar(require("./call_method_condition"), exports);
+__exportStar(require("./client_alarm_list"), exports);
+__exportStar(require("./client_alarm_tools_dump_event"), exports);
+__exportStar(require("./client_alarm"), exports);
+__exportStar(require("./event_stuff"), exports);
+__exportStar(require("./extract_condition_fields"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+DAA6C;AAC7C,2DAAyC;AACzC,0DAAwC;AACxC,sDAAoC;AACpC,kEAAgD;AAChD,iDAA+B;AAC/B,gDAA8B;AAC9B,6DAA2C"}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "node-opcua-alarm-condition",
+    "version": "2.119.0",
+    "description": "pure nodejs OPCUA SDK - module pseudo-session",
+    "scripts": {
+        "clean": "npx rimraf node_modules dist *.tsbuildinfo",
+        "build": "tsc -b",
+        "lint": "eslint source/**/*.ts",
+        "test": "echo mocha test"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "dependencies": {
+        "node-opcua-assert": "2.105.0",
+        "node-opcua-basic-types": "2.119.0",
+        "node-opcua-constants": "2.114.0",
+        "node-opcua-data-model": "2.119.0",
+        "node-opcua-debug": "2.118.0",
+        "node-opcua-nodeid": "2.118.0",
+        "node-opcua-pseudo-session": "2.119.0",
+        "node-opcua-service-browse": "2.119.0",
+        "node-opcua-service-filter": "2.119.0",
+        "node-opcua-service-read": "2.119.0",
+        "node-opcua-service-subscription": "2.119.0",
+        "node-opcua-service-translate-browse-path": "2.119.0",
+        "node-opcua-status-code": "2.117.0",
+        "node-opcua-types": "2.119.0",
+        "node-opcua-utils": "2.117.0",
+        "node-opcua-variant": "2.119.0",
+        "thenify": "^3.3.1"
+    },
+    "author": "Etienne Rossignon",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/node-opcua/node-opcua.git"
+    },
+    "keywords": [
+        "OPCUA",
+        "opcua",
+        "m2m",
+        "iot",
+        "opc ua",
+        "internet of things"
+    ],
+    "homepage": "http://node-opcua.github.io/",
+    "gitHead": "f985d1ada89600c33696c541e6ba3c78a1a7f340",
+    "files": [
+        "dist",
+        "source"
+    ]
+}

package/source/acknowledge_all_conditions.ts

@@ -0,0 +1,193 @@
+import { resolveNodeId } from "node-opcua-nodeid";
+import { constructEventFilter } from "node-opcua-service-filter";
+import { AttributeIds, ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
+import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "node-opcua-service-subscription";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant } from "node-opcua-variant";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+
+import { IBasicSessionAsync } from "node-opcua-pseudo-session";
+import { IBasicSessionEx } from "node-opcua-pseudo-session";
+
+import { EventStuff, fieldsToJson } from "./event_stuff";
+import { extractConditionFields } from "./extract_condition_fields";
+import { acknowledgeCondition, confirmCondition } from "./call_method_condition";
+import { callConditionRefresh } from "./call_condition_refresh";
+
+const doDebug = checkDebugFlag(__filename);
+const debugLog = make_debugLog(__filename);
+const errorLog = make_errorLog(__filename);
+
+/**
+ *
+ * @param session
+ * @param eventStuff
+ * @param comment
+ */
+
+async function acknowledgeConditionEV(session: IBasicSessionAsync, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
+    const conditionId = eventStuff.conditionId?.value;
+    const eventId = eventStuff.eventId?.value;
+    try {
+        return await acknowledgeCondition(session, conditionId, eventId, comment);
+    } catch (err) {
+        errorLog(`conditionId: ${conditionId?.toString()}`);
+        errorLog("Acknowledging Condition has failed !", err);
+        return StatusCodes.BadInternalError;
+    }
+}
+
+async function confirmConditionEV(session: IBasicSessionAsync, eventStuff: EventStuff, comment: string): Promise<StatusCode> {
+    const conditionId = eventStuff.conditionId?.value;
+    const eventId = eventStuff.eventId?.value;
+    try {
+        return await confirmCondition(session, conditionId, eventId, comment);
+    } catch (err) {
+        errorLog(`conditionId: ${conditionId?.toString()}`);
+        errorLog("Confirming Condition has failed !", err);
+        return StatusCodes.BadInternalError;
+    }
+}
+
+export type FindActiveConditions = () => Promise<EventStuff[]>;
+
+/**
+ * Enumerate all events
+ * @param session
+ */
+export async function findActiveConditions(session: IBasicSessionEx): Promise<EventStuff[]> {
+    const request: CreateSubscriptionRequestOptions = {
+        maxNotificationsPerPublish: 10000,
+        priority: 6,
+        publishingEnabled: true,
+        requestedLifetimeCount: 1000,
+        requestedMaxKeepAliveCount: 100,
+        requestedPublishingInterval: 100
+    };
+
+    const subscription = await session.createSubscription2(request);
+
+    const itemToMonitor: ReadValueIdOptions = {
+        attributeId: AttributeIds.EventNotifier,
+        nodeId: resolveNodeId("Server") // i=2253session
+    };
+
+    const fields = await extractConditionFields(session, "AcknowledgeableConditionType");
+
+    // note: we may want to have this select clause
+    //  Or(OfType("AcknowledgeableConditionType"), OfType("RefreshStartEventType"), OfType("RefreshEndEventType"))
+    const eventFilter = constructEventFilter(fields);
+
+    const monitoringParameters: MonitoringParametersOptions = {
+        discardOldest: false,
+        filter: eventFilter,
+        queueSize: 100,
+        samplingInterval: 0
+    };
+
+    const event_monitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
+
+    const acknowledgeableConditions: EventStuff[] = [];
+
+    let refreshStartEventHasBeenReceived = false;
+    let RefreshEndEventHasBeenReceived = false;
+
+    const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
+    const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
+
+    await new Promise<void>((resolve, reject) => {
+        // now create a event monitored Item
+        event_monitoringItem.on("changed", (_eventFields: any) => {
+            const eventFields = _eventFields as Variant[];
+
+            try {
+                if (RefreshEndEventHasBeenReceived) {
+                    return;
+                }
+
+                // dumpEvent(session, fields, eventFields);
+                const pojo = fieldsToJson(fields, eventFields) as any;
+
+                // make sure we only start recording event after the RefreshStartEvent has been received
+                if (!refreshStartEventHasBeenReceived) {
+                    if (pojo.eventType.value.toString() === RefreshStartEventType) {
+                        refreshStartEventHasBeenReceived = true;
+                    }
+                    return;
+                }
+                if (pojo.eventType.value.toString() === RefreshEndEventType) {
+                    RefreshEndEventHasBeenReceived = true;
+                    resolve();
+                    return;
+                }
+                if (!pojo.conditionId.value) {
+                    // not a Acknowledgeable condition
+                    return;
+                }
+
+                if (pojo.ackedState.id.dataType === DataType.Boolean) {
+                    acknowledgeableConditions.push(pojo as EventStuff);
+                }
+            } catch (err) {
+                errorLog("Error !!", err);
+            }
+        });
+        // async call without waiting !
+        try {
+            callConditionRefresh(session, subscription.subscriptionId);
+        } catch (err) {
+            // it is possible that server do not implement conditionRefresh ...
+            errorLog("Server may not implement conditionRefresh", (err as Error).message);
+        }
+    });
+
+    // now shut down subscription
+    await subscription.terminate();
+
+    return acknowledgeableConditions;
+}
+
+// let conditions = await findActiveConditions(session);
+// if (conditions.length === 0) {
+//     debugLog("Warning: cannot find conditions ");
+// }
+
+export async function acknowledgeAllConditions(session: IBasicSessionEx, message: string): Promise<void> {
+    try {
+        let conditions: EventStuff[] = await findActiveConditions(session);
+        // filter acknowledgeable conditions (no acked yet)
+        conditions = conditions.filter((pojo) => pojo.ackedState.id.value === false);
+
+        const promises: Array<Promise<StatusCode>> = [];
+        for (const eventStuff of conditions) {
+            promises.push(acknowledgeConditionEV(session, eventStuff, message));
+        }
+        const result = await Promise.all(promises);
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("Acked all results: ", result.map((e) => e.toString()).join(" "));
+        }
+    } catch (err) {
+        errorLog("Error", err);
+    }
+}
+
+export async function confirmAllConditions(session: IBasicSessionEx, message: string): Promise<void> {
+    try {
+        let conditions: EventStuff[] = await findActiveConditions(session);
+        // filter acknowledgeable conditions (no acked yet)
+        conditions = conditions.filter((pojo) => pojo.confirmedState.id.value === false);
+
+        const promises: Array<Promise<any>> = [];
+        for (const eventStuff of conditions) {
+            promises.push(confirmConditionEV(session, eventStuff, message));
+        }
+        const result = await Promise.all(promises);
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("Confirm all results: ", result.map((e) => e.toString()).join(" "));
+        }
+    } catch (err) {
+        errorLog("Error", err);
+    }
+}

package/source/call_condition_refresh.ts

@@ -0,0 +1,42 @@
+import assert from "node-opcua-assert";
+import { DataType, StatusCode, StatusCodes } from "node-opcua-basic-types";
+import { resolveNodeId } from "node-opcua-nodeid";
+import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
+import { CallMethodRequest } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import { IBasicSessionAsync, CallMethodRequestLike } from "node-opcua-pseudo-session";
+
+const doDebug = false;
+const debugLog = make_debugLog("A&E");
+const warningLog = make_warningLog("A&E");
+
+export async function callConditionRefresh(session: IBasicSessionAsync, subscriptionId: number): Promise<StatusCode> {
+    assert(isFinite(subscriptionId), "May be subscription is not yet initialized");
+    const conditionTypeNodeId = resolveNodeId("ConditionType");
+    let conditionRefreshId = resolveNodeId("ConditionType_ConditionRefresh");
+    // find conditionRefreshId
+    const browsePath = makeBrowsePath(conditionTypeNodeId, ".ConditionRefresh");
+    const translateResult = await session.translateBrowsePath(browsePath);
+
+    // istanbul ignore next
+    if (translateResult.targets && translateResult.targets.length > 0) {
+        conditionRefreshId = translateResult.targets[0].targetId;
+    } else {
+        // cannot find conditionRefreshId
+        return StatusCodes.BadInternalError;
+    }
+    const methodToCall: CallMethodRequestLike = {
+        inputArguments: [new Variant({ dataType: DataType.UInt32, value: subscriptionId })],
+        methodId: conditionRefreshId,
+        objectId: conditionTypeNodeId
+    };
+
+    doDebug && debugLog("Calling method ", new CallMethodRequest(methodToCall).toString());
+    const callResult = await session.call(methodToCall);
+    // istanbul ignore next
+    if (callResult.statusCode.isNotGood()) {
+        warningLog(new CallMethodRequest(methodToCall).toString());
+    }
+    return callResult.statusCode;
+}

package/source/call_method_condition.ts

@@ -0,0 +1,86 @@
+import assert from "node-opcua-assert";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeId, NodeIdLike, coerceNodeId, resolveNodeId } from "node-opcua-nodeid";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { CallMethodRequest } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+import { IBasicSessionAsync, findMethodId } from "node-opcua-pseudo-session";
+import { MethodIds } from "node-opcua-constants";
+
+
+
+
+export async function callMethodCondition(
+    session: IBasicSessionAsync,
+    methodName: string,
+    conditionId: NodeIdLike,
+    eventId: Buffer,
+    comment: LocalizedTextLike,
+   
+): Promise<StatusCode>
+{
+    conditionId = coerceNodeId(conditionId);
+    assert(conditionId instanceof NodeId);
+    assert(eventId instanceof Buffer);
+    assert(typeof comment === "string" || comment instanceof LocalizedText);
+
+    comment = LocalizedText.coerce(comment) || new LocalizedText();    
+    const r = await findMethodId(session, conditionId, methodName);
+
+    let methodId = r.methodId;
+    if (!methodId) {
+        // https://reference.opcfoundation.org/Core/Part9/v104/docs/5.7.3#_Ref224987672
+        //  The Acknowledge Method is used to acknowledge an Event Notification for a Condition instance
+        //  state where AckedState is False. Normally, the NodeId of the object instance is passed as the
+        //  ObjectId to the Call Service. However, some Servers do not expose Condition instances in the AddressSpace.
+        //  Therefore, Servers shall allow Clients to call the Acknowledge Method by specifying ConditionId as the ObjectId.
+        //  The Method cannot be called with an ObjectId of the AcknowledgeableConditionType Node.
+        //
+        // The Confirm Method is used to confirm an Event Notifications for a Condition instance state where ConfirmedState is False.
+
+        switch (methodName) {
+            case "Acknowledge":
+                methodId = resolveNodeId(MethodIds.AcknowledgeableConditionType_Acknowledge);
+                break;
+            case "Confirm":
+                methodId = resolveNodeId(MethodIds.AcknowledgeableConditionType_Confirm);
+                break;
+            default:
+                return StatusCodes.BadNodeIdUnknown;
+        }
+    }
+    const methodToCalls = [];
+
+    methodToCalls.push(
+        new CallMethodRequest({
+            inputArguments: [
+                /* eventId */ new Variant({ dataType: "ByteString", value: eventId }),
+                /* comment */ new Variant({ dataType: "LocalizedText", value: comment })
+            ],
+            methodId,
+            objectId: conditionId
+        })
+    );
+
+   const results =  await session.call(methodToCalls);
+   const statusCode = results![0].statusCode;
+   return statusCode;
+ }
+
+
+ export async function acknowledgeCondition(
+    session: IBasicSessionAsync,
+    conditionId: NodeIdLike,
+    eventId: Buffer,
+    comment: LocalizedTextLike
+): Promise<StatusCode> {
+    return await callMethodCondition(session, "Acknowledge", conditionId, eventId, comment);
+}
+export async function confirmCondition(
+    session: IBasicSessionAsync,
+    conditionId: NodeIdLike,
+    eventId: Buffer,
+    comment: LocalizedTextLike
+): Promise<StatusCode> {
+    return await callMethodCondition(session, "Confirm", conditionId, eventId, comment);
+}

package/source/client_alarm.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from "events";
+import { assert } from "node-opcua-assert";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { StatusCode } from "node-opcua-status-code";
+import { DataType, Variant } from "node-opcua-variant";
+import { IBasicSessionAsync} from "node-opcua-pseudo-session";
+import { EventStuff} from "./event_stuff";
+import { acknowledgeCondition, confirmCondition } from "./call_method_condition";
+
+
+
+export interface ClientAlarm {
+    conditionId: NodeId;
+    eventType: NodeId;
+    fields: EventStuff;
+    on(eventName: "changed", eventHandler: () => void): this;
+    acknowledge(session: IBasicSessionAsync, comment: string): Promise<StatusCode>;
+    confirm(session: IBasicSessionAsync, comment: string): Promise<StatusCode>;
+    getField(fieldName: string): Variant | null;
+}
+
+/**
+ * describes a OPCUA Alarm as seen in the client side
+ */
+export class ClientAlarm extends EventEmitter {
+    public conditionId: NodeId;
+    public eventType: NodeId;
+    public eventId: Buffer;
+    public fields: EventStuff;
+
+    public constructor(eventFields: EventStuff) {
+        super();
+        this.conditionId = resolveNodeId(eventFields.conditionId.value);
+        this.eventType = resolveNodeId(eventFields.eventType.value);
+        this.eventId = eventFields.eventId.value;
+        this.fields = eventFields;
+        this.update(eventFields);
+    }
+    public async acknowledge(session: IBasicSessionAsync, comment: string): Promise<StatusCode> {
+        return await acknowledgeCondition(session, this.conditionId, this.eventId, comment);
+    }
+    public async confirm(session: IBasicSessionAsync, comment: string): Promise<StatusCode> {
+        return await confirmCondition(session, this.conditionId, this.eventId, comment);
+    }
+    public update(eventFields: EventStuff): void {
+        assert(this.conditionId.toString() === resolveNodeId(eventFields.conditionId.value).toString());
+        assert(this.eventType.toString() === resolveNodeId(eventFields.eventType.value).toString());
+        this.eventId = eventFields.eventId.value;
+        this.fields = eventFields;
+    }
+    public getRetain(): boolean {
+        return this.fields.retain.value;
+    }
+    public toString(): string {
+        return (
+            this.constructor.name +
+            ": " +
+            this.conditionId.toString() +
+            " " +
+            this.eventType.toString() +
+            " " +
+            Object.entries(this.fields)
+                .filter(([key, value]) => value.dataType !== DataType.Null)
+                .map(([key, value]) => key.padEnd(30) + "=" + value.toString())
+                .join("\n") +
+            "\n\n"
+        );
+    }
+
+    public getField(fieldName: string): Variant | null {
+        return (this.fields as any)[fieldName] || null;
+    }
+}