node-opcua-address-space 2.51.0

package/dist/src/alarms_and_conditions/ua_certificate_expiration_alarm.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UACertificateExpirationAlarm = void 0;
+const node_opcua_variant_1 = require("node-opcua-variant");
+const ua_system_off_normal_alarm_1 = require("./ua_system_off_normal_alarm");
+/**
+ * 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.
+ *
+ * @class UACertificateExpirationAlarm
+ * @extends UASystemOffNormalAlarm
+ * @constructor
+ *
+ *
+ */
+class UACertificateExpirationAlarm extends ua_system_off_normal_alarm_1.UASystemOffNormalAlarm {
+    static instantiate(namespace, options, data) {
+        return ua_system_off_normal_alarm_1.UASystemOffNormalAlarm.instantiate(namespace, "CertificateExpirationAlarmType", options, data);
+    }
+    getExpirationDate() {
+        return this.expirationDate.readValue().value.value;
+    }
+    setExpirationDate(value) {
+        return this.expirationDate.setValueFromSource({
+            dataType: node_opcua_variant_1.DataType.DateTime,
+            value
+        });
+    }
+}
+exports.UACertificateExpirationAlarm = UACertificateExpirationAlarm;
+//# sourceMappingURL=ua_certificate_expiration_alarm.js.map

package/dist/src/alarms_and_conditions/ua_certificate_expiration_alarm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_certificate_expiration_alarm.js","sourceRoot":"","sources":["../../../src/alarms_and_conditions/ua_certificate_expiration_alarm.ts"],"names":[],"mappings":";;;AAMA,2DAA8C;AAO9C,6EAAsE;AAEtE;;;;;;;;;;GAUG;AACH,MAAa,4BAA6B,SAAQ,mDAAsB;IAE7D,MAAM,CAAC,WAAW,CACrB,SAAoB,EACpB,OAAY,EACZ,IAAS;QAET,OAAO,mDAAsB,CAAC,WAAW,CACvC,SAAS,EACT,gCAAgC,EAChC,OAAO,EAAE,IAAI,CAAiC,CAAC;IACrD,CAAC;IAEM,iBAAiB;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;IACvD,CAAC;IAEM,iBAAiB,CAAC,KAAW;QAChC,OAAO,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC;YAC1C,QAAQ,EAAE,6BAAQ,CAAC,QAAQ;YAC3B,KAAK;SACR,CAAC,CAAC;IACP,CAAC;CACJ;AAvBD,oEAuBC"}

package/dist/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { DateTime } from "node-opcua-basic-types";
+import { UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
+import { INamespace } from "node-opcua-address-space-base";
+import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
+export interface UACertificateExpirationAlarmEx extends Omit<UACertificateExpirationAlarm_Base, "ackedState" | "activeState" | "confirmedState" | "enabledState" | "latchedState" | "limitState" | "outOfServiceState" | "shelvingState" | "silenceState" | "suppressedState"> {
+}
+export declare interface UACertificateExpirationAlarmImpl extends UACertificateExpirationAlarmEx, UASystemOffNormalAlarmImpl {
+}
+/**
+ * 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 declare class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
+    static instantiate(namespace: INamespace, options: any, data: any): UACertificateExpirationAlarmImpl;
+    getExpirationDate(): DateTime;
+    setExpirationDate(value: Date): void;
+}

package/dist/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UACertificateExpirationAlarmImpl = void 0;
+const node_opcua_variant_1 = require("node-opcua-variant");
+const ua_system_off_normal_alarm_impl_1 = require("./ua_system_off_normal_alarm_impl");
+/**
+ * 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.
+ */
+class UACertificateExpirationAlarmImpl extends ua_system_off_normal_alarm_impl_1.UASystemOffNormalAlarmImpl {
+    static instantiate(namespace, options, data) {
+        return ua_system_off_normal_alarm_impl_1.UASystemOffNormalAlarmImpl.instantiate(namespace, "CertificateExpirationAlarmType", options, data);
+    }
+    getExpirationDate() {
+        return this.expirationDate.readValue().value.value;
+    }
+    setExpirationDate(value) {
+        return this.expirationDate.setValueFromSource({
+            dataType: node_opcua_variant_1.DataType.DateTime,
+            value
+        });
+    }
+}
+exports.UACertificateExpirationAlarmImpl = UACertificateExpirationAlarmImpl;
+//# sourceMappingURL=ua_certificate_expiration_alarm_impl.js.map

package/dist/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua_certificate_expiration_alarm_impl.js","sourceRoot":"","sources":["../../../src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts"],"names":[],"mappings":";;;AAIA,2DAA8C;AAG9C,uFAA+E;AAiB/E;;;;GAIG;AACH,MAAa,gCAAiC,SAAQ,4DAA0B;IACrE,MAAM,CAAC,WAAW,CAAC,SAAqB,EAAE,OAAY,EAAE,IAAS;QACpE,OAAO,4DAA0B,CAAC,WAAW,CACzC,SAAS,EACT,gCAAgC,EAChC,OAAO,EACP,IAAI,CAC6B,CAAC;IAC1C,CAAC;IAEM,iBAAiB;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC;IACvD,CAAC;IAEM,iBAAiB,CAAC,KAAW;QAChC,OAAO,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC;YAC1C,QAAQ,EAAE,6BAAQ,CAAC,QAAQ;YAC3B,KAAK;SACR,CAAC,CAAC;IACP,CAAC;CACJ;AApBD,4EAoBC"}

package/dist/src/alarms_and_conditions/ua_condition_base.d.ts

@@ -0,0 +1,191 @@
+/// <reference types="node" />
+import { ByteString, DateTime } from "node-opcua-basic-types";
+import { UInt16 } from "node-opcua-basic-types";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCode } from "node-opcua-status-code";
+import { TimeZoneDataType } from "node-opcua-types";
+import { DataType, VariantLike } from "node-opcua-variant";
+import { Namespace, SessionContext, UAEventType, UAMethod, UAVariableT } from "../../source";
+import { ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+import { AddressSpacePrivate } from "../address_space_private";
+import { UAObject } from "../ua_object";
+import { UATwoStateVariable } from "../state_machine/ua_two_state_variable";
+import { UAVariable } from "../ua_variable";
+import { BaseEventType } from "./base_event_type";
+import { ConditionSnapshot } from "./condition_snapshot";
+export interface UAConditionBase extends BaseEventType {
+    on(eventName: string, eventHandler: (...args: any[]) => void): this;
+    on(eventName: "addComment", eventHandler: (eventId: Buffer | null, comment: LocalizedText, branch: ConditionSnapshot) => void): this;
+    on(eventName: "branch_deleted", eventHandler: (branchId: string) => void): this;
+}
+export interface UAConditionBase {
+    enabledState: UATwoStateVariable;
+    receiveTime: UAVariableT<Date, DataType.DateTime>;
+    localTime: UAVariableT<any, DataType.ExtensionObject>;
+    message: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    severity: UAVariableT<UInt16, DataType.UInt16>;
+    time: UAVariableT<DateTime, DataType.DateTime>;
+    branchId: UAVariableT<NodeId, DataType.NodeId>;
+    eventType: UAVariableT<NodeId, DataType.NodeId>;
+    conditionClassId: UAVariableT<NodeId, DataType.NodeId>;
+    conditionClassName: UAVariableT<LocalizedText, DataType.LocalizedText>;
+    conditionName: UAVariableT<string, DataType.String>;
+    quality: UAConditionVariable<StatusCode, DataType.StatusCode>;
+    comment: UAConditionVariable<LocalizedText, DataType.LocalizedText>;
+    lastSeverity: UAConditionVariable<StatusCode, DataType.StatusCode>;
+    retain: UAVariableT<boolean, DataType.Boolean>;
+    enable: UAMethod;
+    disable: UAMethod;
+    addComment: UAMethod;
+}
+/**
+ * @class UAConditionBase
+ * @constructor
+ * @extends BaseEventType
+ *
+ *
+ *   └─ ConditionType
+ *    ├─ DialogConditionType
+ *    └─ AcknowledgeableConditionType
+ *       └─ AlarmConditionType
+ *          ├─ LimitAlarmType
+ *          │  ├─ ExclusiveLimitAlarmType
+ *          │  │  ├─ ExclusiveLevelAlarmType
+ *          │  │  ├─ ExclusiveDeviationAlarmType
+ *          │  │  └─ ExclusiveRateOfChangeAlarmType
+ *          │  └─ NonExclusiveLimitAlarmType
+ *          │     ├─ NonExclusiveLevelAlarmType
+ *          │     ├─ NonExclusiveDeviationAlarmType
+ *          │     └─ NonExclusiveRateOfChangeAlarmType
+ *          └─ DiscreteAlarmType
+ *             ├─ OffNormalAlarmType
+ *             │  ├─ SystemOffNormalAlarmType
+ *             │  │  └─ CertificateExpirationAlarmType
+ *             │  └─ TripAlarmType
+ *
+ */
+export declare class UAConditionBase extends BaseEventType {
+    static defaultSeverity: number;
+    static typeDefinition: NodeId;
+    static instantiate(namespace: Namespace, conditionTypeId: NodeId | string | UAEventType, options: any, data: any): UAConditionBase;
+    static install_condition_refresh_handle(addressSpace: AddressSpacePrivate): void;
+    /**
+     *
+     * Helper method to handle condition methods that takes a branchId and a comment
+     *
+     */
+    static with_condition_method(inputArguments: VariantLike[], context: SessionContext, callback: (err: Error | null, result?: {
+        statusCode: StatusCode;
+    }) => void, inner_func: (eventId: ByteString, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UAConditionBase) => StatusCode): void;
+    private _branch0;
+    private _previousRetainFlag;
+    private _branches;
+    /**
+     * @method initialize
+     * @private
+     */
+    initialize(): void;
+    /**
+     * @method post_initialize
+     * @private
+     */
+    post_initialize(): void;
+    getBranchCount(): number;
+    getBranches(): ConditionSnapshot[];
+    getBranchIds(): NodeId[];
+    /**
+     * @method createBranch
+     * @return {ConditionSnapshot}
+     */
+    createBranch(): ConditionSnapshot;
+    /**
+     *  @method deleteBranch
+     *  @param branch {ConditionSnapshot}
+     */
+    deleteBranch(branch: ConditionSnapshot): void;
+    /**
+     * @method getEnabledState
+     * @return {Boolean}
+     */
+    getEnabledState(): boolean;
+    /**
+     * @method getEnabledStateAsString
+     * @return {String}
+     */
+    getEnabledStateAsString(): string;
+    /**
+     * @method _setEnabledState
+     * @param requestedEnabledState {Boolean}
+     * @return {StatusCode} StatusCodes.Good if successful or BadConditionAlreadyEnabled/BadConditionAlreadyDisabled
+     * @private
+     */
+    _setEnabledState(requestedEnabledState: boolean): StatusCode;
+    /**
+     *
+     * @method setEnabledState
+     * @param requestedEnabledState {Boolean}
+     * @private
+     */
+    setEnabledState(requestedEnabledState: boolean): StatusCode;
+    /**
+     * @method setReceiveTime
+     * @param time {Date}
+     */
+    setReceiveTime(time: Date): void;
+    /**
+     * @method setLocalTime (optional)
+     * @param time
+     */
+    setLocalTime(time: TimeZoneDataType): void;
+    /**
+     * @method setTime
+     * @param time {Date}
+     */
+    setTime(time: Date): void;
+    _assert_valid(): void;
+    /**
+     * @method conditionOfNode
+     * @return {UAObject}
+     */
+    conditionOfNode(): UAObject | UAVariable | null;
+    /**
+     * @method raiseConditionEvent
+     * Raise a Instance Event
+     * (see also UAObject#raiseEvent to raise a transient event)
+     * @param branch the condition branch to raise
+     * @param renewEventId true if event Id of the condition branch should be renewed
+     */
+    raiseConditionEvent(branch: ConditionSnapshot, renewEventId: boolean): void;
+    /**
+     *
+     * @method raiseNewCondition
+     * @param conditionInfo {ConditionInfo}
+     *
+     */
+    raiseNewCondition(conditionInfo: ConditionInfoOptions): void;
+    raiseNewBranchState(branch: ConditionSnapshot): void;
+    /**
+     * @method currentBranch
+     * @return {ConditionSnapshot}
+     */
+    currentBranch(): ConditionSnapshot;
+    _resend_conditionEvents(): 1 | 0;
+    /**
+     * @method _raiseAuditConditionCommentEvent
+     * @param sourceName {string}
+     * @param conditionEventId    {Buffer}
+     * @param comment    {LocalizedText}
+     * @private
+     */
+    _raiseAuditConditionCommentEvent(sourceName: string, conditionEventId: Buffer, comment: LocalizedTextLike): void;
+    protected _findBranchForEventId(eventId: Buffer): ConditionSnapshot | null;
+    protected evaluateConditionsAfterEnabled(): void;
+}
+export interface UAConditionBase extends BaseEventType {
+    eventId: UAVariable;
+}
+interface UAConditionVariable<T, DT extends DataType> extends UAVariableT<T, DT> {
+    sourceTimestamp: UAVariableT<DateTime, DataType.DateTime>;
+}
+export {};