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

package/build/cjs/cc/CRC16CC.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CRC16CC_exports = {};
+__export(CRC16CC_exports, {
+  CRC16CC: () => CRC16CC,
+  CRC16CCAPI: () => CRC16CCAPI,
+  CRC16CCCommandEncapsulation: () => CRC16CCCommandEncapsulation
+});
+module.exports = __toCommonJS(CRC16CC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_Types = require("../lib/_Types.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CRC16CCCommandEncapsulation_1;
+const headerBuffer = import_safe2.Bytes.from([
+  import_safe.CommandClasses["CRC-16 Encapsulation"],
+  import_Types.CRC16Command.CommandEncapsulation
+]);
+let CRC16CCAPI = class CRC16CCAPI2 extends import_API.CCAPI {
+  supportsCommand(_cmd) {
+    return true;
+  }
+  async sendEncapsulated(encapsulatedCC) {
+    this.assertSupportsCommand(import_Types.CRC16Command, import_Types.CRC16Command.CommandEncapsulation);
+    const cc = new CRC16CCCommandEncapsulation({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      encapsulated: encapsulatedCC
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+};
+CRC16CCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["CRC-16 Encapsulation"])
+], CRC16CCAPI);
+let CRC16CC = class CRC16CC2 extends import_CommandClass.CommandClass {
+  /** Tests if a command should be supervised and thus requires encapsulation */
+  static requiresEncapsulation(cc) {
+    return !!(cc.encapsulationFlags & import_safe.EncapsulationFlags.CRC16) && !(cc instanceof CRC16CCCommandEncapsulation);
+  }
+  /** Encapsulates a command in a CRC-16 CC */
+  static encapsulate(cc) {
+    const ret = new CRC16CCCommandEncapsulation({
+      nodeId: cc.nodeId,
+      encapsulated: cc
+    });
+    ret.encapsulationFlags = cc.encapsulationFlags & ~import_safe.EncapsulationFlags.CRC16;
+    return ret;
+  }
+};
+CRC16CC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["CRC-16 Encapsulation"]),
+  (0, import_CommandClassDecorators.implementedVersion)(1)
+], CRC16CC);
+function getCCResponseForCommandEncapsulation(sent) {
+  if (sent.encapsulated?.expectsCCResponse()) {
+    return CRC16CCCommandEncapsulation;
+  }
+}
+let CRC16CCCommandEncapsulation = CRC16CCCommandEncapsulation_1 = class CRC16CCCommandEncapsulation2 extends CRC16CC {
+  constructor(options) {
+    super(options);
+    this.encapsulated = options.encapsulated;
+    this.encapsulated.encapsulatingCC = this;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 3);
+    const ccBuffer = raw.payload.subarray(0, -2);
+    let expectedCRC = (0, import_safe.CRC16_CCITT)(headerBuffer);
+    expectedCRC = (0, import_safe.CRC16_CCITT)(ccBuffer, expectedCRC);
+    const actualCRC = raw.payload.readUInt16BE(raw.payload.length - 2);
+    (0, import_safe.validatePayload)(expectedCRC === actualCRC);
+    const encapsulated = import_CommandClass.CommandClass.parse(ccBuffer, ctx);
+    return new CRC16CCCommandEncapsulation_1({
+      nodeId: ctx.sourceNodeId,
+      encapsulated
+    });
+  }
+  encapsulated;
+  serialize(ctx) {
+    const commandBuffer = this.encapsulated.serialize(ctx);
+    this.payload = import_safe2.Bytes.concat([commandBuffer, new import_safe2.Bytes(2)]);
+    let crc = (0, import_safe.CRC16_CCITT)(headerBuffer);
+    crc = (0, import_safe.CRC16_CCITT)(commandBuffer, crc);
+    this.payload.writeUInt16BE(crc, this.payload.length - 2);
+    return super.serialize(ctx);
+  }
+  computeEncapsulationOverhead() {
+    return super.computeEncapsulationOverhead() + 2;
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      // Hide the default payload line
+      message: void 0
+    };
+  }
+};
+CRC16CCCommandEncapsulation = CRC16CCCommandEncapsulation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.CRC16Command.CommandEncapsulation),
+  (0, import_CommandClassDecorators.expectedCCResponse)(getCCResponseForCommandEncapsulation, () => "checkEncapsulated")
+], CRC16CCCommandEncapsulation);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRC16CC,
+  CRC16CCAPI,
+  CRC16CCCommandEncapsulation
+});
+//# sourceMappingURL=CRC16CC.js.map

package/build/cjs/cc/CRC16CC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/cc/CRC16CC.ts"],
+  "sourcesContent": ["import {\n\tCRC16_CCITT,\n\tCommandClasses,\n\tEncapsulationFlags,\n\ttype MaybeNotKnown,\n\ttype MessageOrCCLogEntry,\n\ttype WithAddress,\n\tvalidatePayload,\n} from \"@zwave-js/core/safe\";\nimport type {\n\tCCEncodingContext,\n\tCCParsingContext,\n\tGetValueDB,\n} from \"@zwave-js/host/safe\";\nimport { CCAPI } from \"../lib/API.js\";\nimport { type CCRaw, CommandClass } from \"../lib/CommandClass.js\";\nimport {\n\tAPI,\n\tCCCommand,\n\tcommandClass,\n\texpectedCCResponse,\n\timplementedVersion,\n} from \"../lib/CommandClassDecorators.js\";\n\nimport { Bytes } from \"@zwave-js/shared/safe\";\nimport { CRC16Command } from \"../lib/_Types.js\";\n\nconst headerBuffer = Bytes.from([\n\tCommandClasses[\"CRC-16 Encapsulation\"],\n\tCRC16Command.CommandEncapsulation,\n]);\n\n// @noSetValueAPI\n// @noInterview This CC only has a single encapsulation command\n\n// Encapsulation CCs are used internally and too frequently that we\n// want to pay the cost of validating each call\n/* eslint-disable @zwave-js/ccapi-validate-args */\n\n@API(CommandClasses[\"CRC-16 Encapsulation\"])\nexport class CRC16CCAPI extends CCAPI {\n\tpublic supportsCommand(_cmd: CRC16Command): MaybeNotKnown<boolean> {\n\t\t// switch (cmd) {\n\t\t// \tcase CRC16Command.CommandEncapsulation:\n\t\treturn true; // This is mandatory\n\t\t// }\n\t\t// return super.supportsCommand(cmd);\n\t}\n\n\tpublic async sendEncapsulated(encapsulatedCC: CommandClass): Promise<void> {\n\t\tthis.assertSupportsCommand(\n\t\t\tCRC16Command,\n\t\t\tCRC16Command.CommandEncapsulation,\n\t\t);\n\n\t\tconst cc = new CRC16CCCommandEncapsulation({\n\t\t\tnodeId: this.endpoint.nodeId,\n\t\t\tendpointIndex: this.endpoint.index,\n\t\t\tencapsulated: encapsulatedCC,\n\t\t});\n\t\tawait this.host.sendCommand(cc, this.commandOptions);\n\t}\n}\n\n@commandClass(CommandClasses[\"CRC-16 Encapsulation\"])\n@implementedVersion(1)\nexport class CRC16CC extends CommandClass {\n\tdeclare ccCommand: CRC16Command;\n\n\t/** Tests if a command should be supervised and thus requires encapsulation */\n\tpublic static requiresEncapsulation(cc: CommandClass): boolean {\n\t\treturn (\n\t\t\t!!(cc.encapsulationFlags & EncapsulationFlags.CRC16)\n\t\t\t&& !(cc instanceof CRC16CCCommandEncapsulation)\n\t\t);\n\t}\n\n\t/** Encapsulates a command in a CRC-16 CC */\n\tpublic static encapsulate(\n\t\tcc: CommandClass,\n\t): CRC16CCCommandEncapsulation {\n\t\tconst ret = new CRC16CCCommandEncapsulation({\n\t\t\tnodeId: cc.nodeId,\n\t\t\tencapsulated: cc,\n\t\t});\n\n\t\t// Copy the encapsulation flags from the encapsulated command\n\t\t// but omit CRC-16, since we're doing that right now\n\t\tret.encapsulationFlags = cc.encapsulationFlags\n\t\t\t& ~EncapsulationFlags.CRC16;\n\n\t\treturn ret;\n\t}\n}\n\n// @publicAPI\nexport interface CRC16CCCommandEncapsulationOptions {\n\tencapsulated: CommandClass;\n}\n\nfunction getCCResponseForCommandEncapsulation(\n\tsent: CRC16CCCommandEncapsulation,\n) {\n\tif (sent.encapsulated?.expectsCCResponse()) {\n\t\treturn CRC16CCCommandEncapsulation;\n\t}\n}\n\n@CCCommand(CRC16Command.CommandEncapsulation)\n@expectedCCResponse(\n\tgetCCResponseForCommandEncapsulation,\n\t() => \"checkEncapsulated\",\n)\nexport class CRC16CCCommandEncapsulation extends CRC16CC {\n\tpublic constructor(\n\t\toptions: WithAddress<CRC16CCCommandEncapsulationOptions>,\n\t) {\n\t\tsuper(options);\n\t\tthis.encapsulated = options.encapsulated;\n\t\tthis.encapsulated.encapsulatingCC = this as any;\n\t}\n\n\tpublic static from(\n\t\traw: CCRaw,\n\t\tctx: CCParsingContext,\n\t): CRC16CCCommandEncapsulation {\n\t\tvalidatePayload(raw.payload.length >= 3);\n\n\t\tconst ccBuffer = raw.payload.subarray(0, -2);\n\n\t\t// Verify the CRC\n\t\tlet expectedCRC = CRC16_CCITT(headerBuffer);\n\t\texpectedCRC = CRC16_CCITT(ccBuffer, expectedCRC);\n\t\tconst actualCRC = raw.payload.readUInt16BE(\n\t\t\traw.payload.length - 2,\n\t\t);\n\t\tvalidatePayload(expectedCRC === actualCRC);\n\n\t\tconst encapsulated = CommandClass.parse(ccBuffer, ctx);\n\t\treturn new CRC16CCCommandEncapsulation({\n\t\t\tnodeId: ctx.sourceNodeId,\n\t\t\tencapsulated,\n\t\t});\n\t}\n\n\tpublic encapsulated: CommandClass;\n\n\tpublic serialize(ctx: CCEncodingContext): Bytes {\n\t\tconst commandBuffer = this.encapsulated.serialize(ctx);\n\t\t// Reserve 2 bytes for the CRC\n\t\tthis.payload = Bytes.concat([commandBuffer, new Bytes(2)]);\n\n\t\t// Compute and save the CRC16 in the payload\n\t\t// The CC header is included in the CRC computation\n\t\tlet crc = CRC16_CCITT(headerBuffer);\n\t\tcrc = CRC16_CCITT(commandBuffer, crc);\n\t\tthis.payload.writeUInt16BE(crc, this.payload.length - 2);\n\n\t\treturn super.serialize(ctx);\n\t}\n\n\tprotected computeEncapsulationOverhead(): number {\n\t\t// CRC16 adds two bytes CRC to the default overhead\n\t\treturn super.computeEncapsulationOverhead() + 2;\n\t}\n\n\tpublic toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry {\n\t\treturn {\n\t\t\t...super.toLogEntry(ctx),\n\t\t\t// Hide the default payload line\n\t\t\tmessage: undefined,\n\t\t};\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kBAQO;AAMP,iBAAsB;AACtB,0BAAyC;AACzC,oCAMO;AAEP,IAAAA,eAAsB;AACtB,mBAA6B;;;;;;;;AAE7B,MAAM,eAAe,mBAAM,KAAK;EAC/B,2BAAe,sBAAsB;EACrC,0BAAa;CACb;AAUM,IAAM,aAAN,MAAMC,oBAAmB,iBAAK;EAC7B,gBAAgB,MAAkB;AAGxC,WAAO;EAGR;EAEO,MAAM,iBAAiB,gBAA4B;AACzD,SAAK,sBACJ,2BACA,0BAAa,oBAAoB;AAGlC,UAAM,KAAK,IAAI,4BAA4B;MAC1C,QAAQ,KAAK,SAAS;MACtB,eAAe,KAAK,SAAS;MAC7B,cAAc;KACd;AACD,UAAM,KAAK,KAAK,YAAY,IAAI,KAAK,cAAc;EACpD;;AArBY,aAAU,WAAA;MADtB,mCAAI,2BAAe,sBAAsB,CAAC;GAC9B,UAAU;AA0BhB,IAAM,UAAN,MAAMC,iBAAgB,iCAAY;;EAIjC,OAAO,sBAAsB,IAAgB;AACnD,WACC,CAAC,EAAE,GAAG,qBAAqB,+BAAmB,UAC3C,EAAE,cAAc;EAErB;;EAGO,OAAO,YACb,IAAgB;AAEhB,UAAM,MAAM,IAAI,4BAA4B;MAC3C,QAAQ,GAAG;MACX,cAAc;KACd;AAID,QAAI,qBAAqB,GAAG,qBACzB,CAAC,+BAAmB;AAEvB,WAAO;EACR;;AA1BY,UAAO,WAAA;MAFnB,4CAAa,2BAAe,sBAAsB,CAAC;MACnD,kDAAmB,CAAC;GACR,OAAO;AAkCpB,SAAS,qCACR,MAAiC;AAEjC,MAAI,KAAK,cAAc,kBAAiB,GAAI;AAC3C,WAAO;EACR;AACD;AAOO,IAAM,8BAA2B,gCAAjC,MAAMC,qCAAoC,QAAO;EACvD,YACC,SAAwD;AAExD,UAAM,OAAO;AACb,SAAK,eAAe,QAAQ;AAC5B,SAAK,aAAa,kBAAkB;EACrC;EAEO,OAAO,KACb,KACA,KAAqB;AAErB,qCAAgB,IAAI,QAAQ,UAAU,CAAC;AAEvC,UAAM,WAAW,IAAI,QAAQ,SAAS,GAAG,EAAE;AAG3C,QAAI,kBAAc,yBAAY,YAAY;AAC1C,sBAAc,yBAAY,UAAU,WAAW;AAC/C,UAAM,YAAY,IAAI,QAAQ,aAC7B,IAAI,QAAQ,SAAS,CAAC;AAEvB,qCAAgB,gBAAgB,SAAS;AAEzC,UAAM,eAAe,iCAAa,MAAM,UAAU,GAAG;AACrD,WAAO,IAAI,8BAA4B;MACtC,QAAQ,IAAI;MACZ;KACA;EACF;EAEO;EAEA,UAAU,KAAsB;AACtC,UAAM,gBAAgB,KAAK,aAAa,UAAU,GAAG;AAErD,SAAK,UAAU,mBAAM,OAAO,CAAC,eAAe,IAAI,mBAAM,CAAC,CAAC,CAAC;AAIzD,QAAI,UAAM,yBAAY,YAAY;AAClC,cAAM,yBAAY,eAAe,GAAG;AACpC,SAAK,QAAQ,cAAc,KAAK,KAAK,QAAQ,SAAS,CAAC;AAEvD,WAAO,MAAM,UAAU,GAAG;EAC3B;EAEU,+BAA4B;AAErC,WAAO,MAAM,6BAA4B,IAAK;EAC/C;EAEO,WAAW,KAAgB;AACjC,WAAO;MACN,GAAG,MAAM,WAAW,GAAG;;MAEvB,SAAS;;EAEX;;AA3DY,8BAA2B,gCAAA,WAAA;MALvC,yCAAU,0BAAa,oBAAoB;MAC3C,kDACA,sCACA,MAAM,mBAAmB;GAEb,2BAA2B;",
+  "names": ["import_safe", "CRC16CCAPI", "CRC16CC", "CRC16CCCommandEncapsulation"]
+}

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

@@ -0,0 +1,210 @@
+import { CommandClasses, type MaybeNotKnown, type MessageOrCCLogEntry, type SupervisionResult, type WithAddress } from "@zwave-js/core/safe";
+import type { CCEncodingContext, CCParsingContext, GetValueDB } from "@zwave-js/host/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { CCAPI, POLL_VALUE, type PollValueImplementation, SET_VALUE, type SetValueImplementation } from "../lib/API.js";
+import { type CCRaw, CommandClass, type InterviewContext, type PersistValuesContext } from "../lib/CommandClass.js";
+import { CentralSceneCommand, CentralSceneKeys } from "../lib/_Types.js";
+export declare const CentralSceneCCValues: Readonly<{
+    scene: ((sceneNumber: number) => {
+        readonly meta: {
+            readonly label: `Scene ${string}`;
+            readonly writeable: false;
+            readonly min: 0;
+            readonly max: 255;
+            readonly type: "number";
+            readonly readable: true;
+        };
+        readonly id: {
+            commandClass: (typeof CommandClasses)["Central Scene"];
+            property: "scene";
+            propertyKey: string;
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["Central Scene"];
+            readonly endpoint: number;
+            readonly property: "scene";
+            readonly propertyKey: string;
+        };
+    }) & {
+        is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly options: {
+            readonly secret: false;
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+            readonly stateful: false;
+        };
+    };
+    slowRefresh: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["Central Scene"];
+            property: "slowRefresh";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["Central Scene"];
+            readonly endpoint: number;
+            readonly property: "slowRefresh";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").ValueID) => boolean;
+        readonly meta: {
+            readonly label: "Send held down notifications at a slow rate";
+            readonly description: "When this is true, KeyHeldDown notifications are sent every 55s. When this is false, the notifications are sent every 200ms.";
+            readonly type: "boolean";
+            readonly readable: true;
+            readonly writeable: true;
+        };
+        readonly options: {
+            readonly internal: false;
+            readonly minVersion: 1;
+            readonly secret: false;
+            readonly stateful: true;
+            readonly supportsEndpoints: true;
+            readonly autoCreate: true;
+        };
+    };
+    supportedKeyAttributes: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["Central Scene"];
+            property: "supportedKeyAttributes";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["Central Scene"];
+            readonly endpoint: number;
+            readonly property: "supportedKeyAttributes";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").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;
+        };
+    };
+    supportsSlowRefresh: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["Central Scene"];
+            property: "supportsSlowRefresh";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["Central Scene"];
+            readonly endpoint: number;
+            readonly property: "supportsSlowRefresh";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").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;
+        };
+    };
+    sceneCount: {
+        readonly id: {
+            commandClass: (typeof CommandClasses)["Central Scene"];
+            property: "sceneCount";
+        };
+        readonly endpoint: (endpoint?: number | undefined) => {
+            readonly commandClass: (typeof CommandClasses)["Central Scene"];
+            readonly endpoint: number;
+            readonly property: "sceneCount";
+        };
+        readonly is: (valueId: import("@zwave-js/core/safe").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;
+        };
+    };
+}>;
+export declare class CentralSceneCCAPI extends CCAPI {
+    supportsCommand(cmd: CentralSceneCommand): MaybeNotKnown<boolean>;
+    getSupported(): Promise<Pick<CentralSceneCCSupportedReport, "sceneCount" | "supportsSlowRefresh" | "supportedKeyAttributes"> | undefined>;
+    getConfiguration(): Promise<Pick<CentralSceneCCConfigurationReport, "slowRefresh"> | undefined>;
+    setConfiguration(slowRefresh: boolean): Promise<SupervisionResult | undefined>;
+    protected get [SET_VALUE](): SetValueImplementation;
+    protected get [POLL_VALUE](): PollValueImplementation;
+}
+export declare class CentralSceneCC extends CommandClass {
+    ccCommand: CentralSceneCommand;
+    determineRequiredCCInterviews(): readonly CommandClasses[];
+    skipEndpointInterview(): boolean;
+    interview(ctx: InterviewContext): Promise<void>;
+}
+export interface CentralSceneCCNotificationOptions {
+    sequenceNumber: number;
+    keyAttribute: CentralSceneKeys;
+    sceneNumber: number;
+    slowRefresh?: boolean;
+}
+export declare class CentralSceneCCNotification extends CentralSceneCC {
+    constructor(options: WithAddress<CentralSceneCCNotificationOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): CentralSceneCCNotification;
+    persistValues(ctx: PersistValuesContext): boolean;
+    readonly sequenceNumber: number;
+    readonly keyAttribute: CentralSceneKeys;
+    readonly sceneNumber: number;
+    readonly slowRefresh: boolean | undefined;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export interface CentralSceneCCSupportedReportOptions {
+    sceneCount: number;
+    supportsSlowRefresh: MaybeNotKnown<boolean>;
+    supportedKeyAttributes: Record<number, readonly CentralSceneKeys[]>;
+}
+export declare class CentralSceneCCSupportedReport extends CentralSceneCC {
+    constructor(options: WithAddress<CentralSceneCCSupportedReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): CentralSceneCCSupportedReport;
+    persistValues(ctx: PersistValuesContext): boolean;
+    readonly sceneCount: number;
+    readonly supportsSlowRefresh: MaybeNotKnown<boolean>;
+    private _supportedKeyAttributes;
+    get supportedKeyAttributes(): ReadonlyMap<number, readonly CentralSceneKeys[]>;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class CentralSceneCCSupportedGet extends CentralSceneCC {
+}
+export interface CentralSceneCCConfigurationReportOptions {
+    slowRefresh: boolean;
+}
+export declare class CentralSceneCCConfigurationReport extends CentralSceneCC {
+    constructor(options: WithAddress<CentralSceneCCConfigurationReportOptions>);
+    static from(raw: CCRaw, ctx: CCParsingContext): CentralSceneCCConfigurationReport;
+    readonly slowRefresh: boolean;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+export declare class CentralSceneCCConfigurationGet extends CentralSceneCC {
+}
+export interface CentralSceneCCConfigurationSetOptions {
+    slowRefresh: boolean;
+}
+export declare class CentralSceneCCConfigurationSet extends CentralSceneCC {
+    constructor(options: WithAddress<CentralSceneCCConfigurationSetOptions>);
+    static from(_raw: CCRaw, _ctx: CCParsingContext): CentralSceneCCConfigurationSet;
+    slowRefresh: boolean;
+    serialize(ctx: CCEncodingContext): Bytes;
+    toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
+}
+//# sourceMappingURL=CentralSceneCC.d.ts.map