@zwave-js/cc 14.0.0-beta.1 → 14.0.0-beta.5

package/build/cjs/cc/NotificationCC.d.ts

@@ -0,0 +1,479 @@
+import { type Notification, type NotificationState, type WithAddress } from "@zwave-js/core";
+import { CommandClasses, type ControlsCC, Duration, type EndpointId, type GetEndpoint, type MaybeNotKnown, type MessageOrCCLogEntry, type NodeId, type SinglecastCC, type SupervisionResult, type SupportsCC, type ValueID, type ValueMetadataNumeric } from "@zwave-js/core/safe";
+import type { CCEncodingContext, CCParsingContext, GetDeviceConfig, GetNode, GetSupportedCCVersion, GetValueDB } from "@zwave-js/host/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { POLL_VALUE, PhysicalCCAPI, type PollValueImplementation } from "../lib/API.js";
+import { CCRaw, CommandClass, type InterviewContext, type PersistValuesContext, type RefreshValuesContext } from "../lib/CommandClass.js";
+import { NotificationCommand } from "../lib/_Types.js";
+export declare const NotificationCCValues: Readonly<{
+    notificationVariable: ((notificationName: string, variableName: string) => {
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: string;
+            propertyKey: string;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: string;
+            readonly propertyKey: string;
+        };
+    }) & {
+        is: (valueId: ValueID) => boolean;
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    unknownNotificationVariable: ((notificationType: number, notificationName: string) => {
+        readonly meta: {
+            readonly label: `${string}: Unknown value`;
+            readonly ccSpecific: {
+                readonly notificationType: number;
+            };
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: string;
+            propertyKey: "unknown";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: string;
+            readonly propertyKey: "unknown";
+        };
+    }) & {
+        is: (valueId: ValueID) => boolean;
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    unknownNotificationType: ((notificationType: number) => {
+        readonly meta: {
+            readonly label: `Unknown notification (${string})`;
+            readonly ccSpecific: {
+                readonly notificationType: number;
+            };
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: string;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: string;
+        };
+    }) & {
+        is: (valueId: ValueID) => boolean;
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    supportedNotificationEvents: ((notificationType: number) => {
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "supportedNotificationEvents";
+            propertyKey: number;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "supportedNotificationEvents";
+            readonly propertyKey: number;
+        };
+    }) & {
+        is: (valueId: ValueID) => boolean;
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly autoCreate: true;
+            readonly internal: true;
+            readonly supportsEndpoints: false;
+        };
+    };
+    doorTiltState: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "Access Control";
+            propertyKey: "Door tilt state";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "Access Control";
+            readonly propertyKey: "Door tilt state";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Door tilt state";
+            readonly states: {
+                readonly 0: "Window/door is not tilted";
+                readonly 1: "Window/door is tilted";
+            };
+            readonly ccSpecific: {
+                readonly notificationType: 6;
+            };
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: false;
+        };
+    };
+    doorStateSimple: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "Access Control";
+            propertyKey: "Door state (simple)";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "Access Control";
+            readonly propertyKey: "Door state (simple)";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Door state (simple)";
+            readonly states: {
+                readonly 22: "Window/door is open";
+                readonly 23: "Window/door is closed";
+            };
+            readonly ccSpecific: {
+                readonly notificationType: 6;
+            };
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: (ctx: GetValueDB, endpoint: EndpointId) => boolean;
+        };
+    };
+    alarmLevel: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "alarmLevel";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "alarmLevel";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Alarm Level";
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    alarmType: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "alarmType";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "alarmType";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Alarm Type";
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    lastRefresh: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "lastRefresh";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "lastRefresh";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly internal: true;
+        };
+    };
+    notificationMode: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "notificationMode";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "notificationMode";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly autoCreate: true;
+            readonly internal: true;
+            readonly supportsEndpoints: false;
+        };
+    };
+    supportedNotificationTypes: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "supportedNotificationTypes";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "supportedNotificationTypes";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly autoCreate: true;
+            readonly internal: true;
+            readonly supportsEndpoints: false;
+        };
+    };
+    supportsV1Alarm: {
+        readonly id: {
+            commandClass: CommandClasses.Notification;
+            property: "supportsV1Alarm";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: CommandClasses.Notification;
+            readonly endpoint: number;
+            readonly property: "supportsV1Alarm";
+        };
+        readonly is: (valueId: ValueID) => boolean;
+        readonly meta: {
+            readonly type: "any";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly stateful: true;
+            readonly secret: false;
+            readonly minVersion: 1;
+            readonly autoCreate: true;
+            readonly internal: true;
+            readonly supportsEndpoints: false;
+        };
+    };
+}>;
+export declare class NotificationCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd: NotificationCommand): MaybeNotKnown<boolean>;
+    protected get [POLL_VALUE](): PollValueImplementation;
+    sendReport(options: NotificationCCReportOptions): Promise<SupervisionResult | undefined>;
+    get(options: NotificationCCGetOptions): Promise<Pick<NotificationCCReport, "alarmLevel" | "notificationStatus" | "notificationEvent" | "eventParameters" | "sequenceNumber"> | undefined>;
+    set(notificationType: number, notificationStatus: boolean): Promise<SupervisionResult | undefined>;
+    getSupported(): Promise<Pick<NotificationCCSupportedReport, "supportsV1Alarm" | "supportedNotificationTypes"> | undefined>;
+    getSupportedEvents(notificationType: number): Promise<MaybeNotKnown<readonly number[]>>;
+}
+export declare function getNotificationEnumBehavior(notification: Notification, valueConfig: NotificationState): "none" | "extend" | "replace";
+export declare function getNotificationStateValueWithEnum(stateValue: number, enumValue: number): number;
+/**
+ * Returns the metadata to use for a known notification value.
+ * Can be used to extend a previously defined metadata,
+ * e.g. for V2 notifications that don't allow discovering supported events.
+ */
+export declare function getNotificationValueMetadata(previous: ValueMetadataNumeric | undefined, notification: Notification, valueConfig: NotificationState): ValueMetadataNumeric;
+export declare class NotificationCC extends CommandClass {
+    ccCommand: NotificationCommand;
+    determineRequiredCCInterviews(): readonly CommandClasses[];
+    private determineNotificationMode;
+    /** Whether the node implements push or pull notifications */
+    static getNotificationMode(ctx: GetValueDB, node: NodeId): MaybeNotKnown<"push" | "pull">;
+    interview(ctx: InterviewContext): Promise<void>;
+    refreshValues(ctx: RefreshValuesContext): Promise<void>;
+    shouldRefreshValues(this: SinglecastCC<this>, ctx: GetValueDB & GetSupportedCCVersion & GetDeviceConfig & GetNode<NodeId & GetEndpoint<EndpointId & SupportsCC & ControlsCC>>): boolean;
+}
+export interface NotificationCCSetOptions {
+    notificationType: number;
+    notificationStatus: boolean;
+}
+export declare class NotificationCCSet extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCSetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCSet;
+    notificationType: number;
+    notificationStatus: boolean;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export type NotificationCCReportOptions = {
+    alarmType?: number;
+    alarmLevel?: number;
+    notificationType?: number;
+    notificationEvent?: number;
+    notificationStatus?: number;
+    eventParameters?: Uint8Array;
+    sequenceNumber?: number;
+};
+export declare class NotificationCCReport extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCReport;
+    persistValues(ctx: PersistValuesContext): boolean;
+    alarmType: number | undefined;
+    alarmLevel: number | undefined;
+    notificationType: number | undefined;
+    notificationStatus: boolean | number | undefined;
+    notificationEvent: number | undefined;
+    eventParameters: Uint8Array | Duration | Record<string, number> | number | undefined;
+    sequenceNumber: number | undefined;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+    private parseEventParameters;
+    serialize(ctx: CCEncodingContext): Bytes;
+}
+export type NotificationCCGetOptions = {
+    alarmType: number;
+} | {
+    notificationType: number;
+    notificationEvent?: number;
+};
+export declare class NotificationCCGet extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCGetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCGet;
+    /** Proprietary V1/V2 alarm type */
+    alarmType: number | undefined;
+    /** Regulated V3+ notification type */
+    notificationType: number | undefined;
+    notificationEvent: number | undefined;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface NotificationCCSupportedReportOptions {
+    supportsV1Alarm: boolean;
+    supportedNotificationTypes: number[];
+}
+export declare class NotificationCCSupportedReport extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCSupportedReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCSupportedReport;
+    supportsV1Alarm: boolean;
+    supportedNotificationTypes: number[];
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class NotificationCCSupportedGet extends NotificationCC {
+}
+export interface NotificationCCEventSupportedReportOptions {
+    notificationType: number;
+    supportedEvents: number[];
+}
+export declare class NotificationCCEventSupportedReport extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCEventSupportedReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCEventSupportedReport;
+    persistValues(ctx: PersistValuesContext): boolean;
+    notificationType: number;
+    supportedEvents: number[];
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface NotificationCCEventSupportedGetOptions {
+    notificationType: number;
+}
+export declare class NotificationCCEventSupportedGet extends NotificationCC {
+    constructor(options: WithAddress<NotificationCCEventSupportedGetOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): NotificationCCEventSupportedGet;
+    notificationType: number;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+//# sourceMappingURL=NotificationCC.d.ts.map