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

package/build/cjs/cc/SoundSwitchCC.js

@@ -0,0 +1,661 @@
+"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 SoundSwitchCC_exports = {};
+__export(SoundSwitchCC_exports, {
+  SoundSwitchCC: () => SoundSwitchCC,
+  SoundSwitchCCAPI: () => SoundSwitchCCAPI,
+  SoundSwitchCCConfigurationGet: () => SoundSwitchCCConfigurationGet,
+  SoundSwitchCCConfigurationReport: () => SoundSwitchCCConfigurationReport,
+  SoundSwitchCCConfigurationSet: () => SoundSwitchCCConfigurationSet,
+  SoundSwitchCCToneInfoGet: () => SoundSwitchCCToneInfoGet,
+  SoundSwitchCCToneInfoReport: () => SoundSwitchCCToneInfoReport,
+  SoundSwitchCCTonePlayGet: () => SoundSwitchCCTonePlayGet,
+  SoundSwitchCCTonePlayReport: () => SoundSwitchCCTonePlayReport,
+  SoundSwitchCCTonePlaySet: () => SoundSwitchCCTonePlaySet,
+  SoundSwitchCCTonesNumberGet: () => SoundSwitchCCTonesNumberGet,
+  SoundSwitchCCTonesNumberReport: () => SoundSwitchCCTonesNumberReport,
+  SoundSwitchCCValues: () => SoundSwitchCCValues
+});
+module.exports = __toCommonJS(SoundSwitchCC_exports);
+var import_safe = require("@zwave-js/core/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_safe3 = require("@zwave-js/shared/safe");
+var import_math = require("alcalzone-shared/math/index.js");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Values = require("../lib/Values.js");
+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 SoundSwitchCCTonesNumberReport_1, SoundSwitchCCToneInfoReport_1, SoundSwitchCCToneInfoGet_1, SoundSwitchCCConfigurationSet_1, SoundSwitchCCConfigurationReport_1, SoundSwitchCCTonePlaySet_1, SoundSwitchCCTonePlayReport_1;
+function __assertType(argName, typeName, boundHasError) {
+  const { ZWaveError: ZWaveError2, ZWaveErrorCodes: ZWaveErrorCodes2 } = require("@zwave-js/core");
+  if (boundHasError()) {
+    throw new ZWaveError2(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes2.Argument_Invalid);
+  }
+}
+const __assertType__number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  return _number($o);
+};
+const __assertType__optional_number = ($o) => {
+  function _number($o2) {
+    return typeof $o2 !== "number" ? {} : null;
+  }
+  function optional__number($o2) {
+    if ($o2 !== void 0) {
+      const error = _number($o2);
+      if (error)
+        return error;
+    }
+    return null;
+  }
+  return optional__number($o);
+};
+const SoundSwitchCCValues = Object.freeze({
+  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Sound Switch"], {
+    ...import_Values.V.staticProperty("volume", {
+      ...import_safe.ValueMetadata.UInt8,
+      min: 0,
+      max: 100,
+      unit: "%",
+      label: "Volume",
+      allowManualEntry: true,
+      states: {
+        0: "default"
+      }
+    }),
+    ...import_Values.V.staticProperty("toneId", {
+      ...import_safe.ValueMetadata.UInt8,
+      label: "Play Tone",
+      valueChangeOptions: ["volume"]
+    }),
+    ...import_Values.V.staticProperty("defaultVolume", {
+      ...import_safe.ValueMetadata.Number,
+      min: 0,
+      max: 100,
+      unit: "%",
+      label: "Default volume"
+    }),
+    ...import_Values.V.staticProperty("defaultToneId", {
+      ...import_safe.ValueMetadata.Number,
+      min: 1,
+      max: 254,
+      label: "Default tone ID"
+    })
+  })
+});
+let SoundSwitchCCAPI = class SoundSwitchCCAPI2 extends import_API.CCAPI {
+  supportsCommand(cmd) {
+    switch (cmd) {
+      case import_Types.SoundSwitchCommand.TonesNumberGet:
+      case import_Types.SoundSwitchCommand.ToneInfoGet:
+      case import_Types.SoundSwitchCommand.ConfigurationGet:
+      case import_Types.SoundSwitchCommand.TonePlayGet:
+        return this.isSinglecast();
+      case import_Types.SoundSwitchCommand.ConfigurationSet:
+      case import_Types.SoundSwitchCommand.TonePlaySet:
+        return true;
+    }
+    return super.supportsCommand(cmd);
+  }
+  async getToneCount() {
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.TonesNumberGet);
+    const cc = new SoundSwitchCCTonesNumberGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    return response?.toneCount;
+  }
+  async getToneInfo(toneId) {
+    __assertType("toneId", "number", __assertType__number.bind(void 0, toneId));
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.ToneInfoGet);
+    const cc = new SoundSwitchCCToneInfoGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      toneId
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response)
+      return (0, import_safe3.pick)(response, ["duration", "name"]);
+  }
+  async setConfiguration(defaultToneId, defaultVolume) {
+    __assertType("defaultToneId", "number", __assertType__number.bind(void 0, defaultToneId));
+    __assertType("defaultVolume", "number", __assertType__number.bind(void 0, defaultVolume));
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.ConfigurationSet);
+    const cc = new SoundSwitchCCConfigurationSet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      defaultToneId,
+      defaultVolume
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getConfiguration() {
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.ConfigurationGet);
+    const cc = new SoundSwitchCCConfigurationGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, ["defaultToneId", "defaultVolume"]);
+    }
+  }
+  async play(toneId, volume) {
+    __assertType("toneId", "number", __assertType__number.bind(void 0, toneId));
+    __assertType("volume", "(optional) number", __assertType__optional_number.bind(void 0, volume));
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.TonePlaySet);
+    if (toneId === 0) {
+      throw new import_safe.ZWaveError(`Tone ID must be > 0. Use stopPlaying to stop the tone.`, import_safe.ZWaveErrorCodes.Argument_Invalid);
+    }
+    const cc = new SoundSwitchCCTonePlaySet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      toneId,
+      volume
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  async stopPlaying() {
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.TonePlaySet);
+    const cc = new SoundSwitchCCTonePlaySet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      toneId: 0,
+      volume: 0
+    });
+    return this.host.sendCommand(cc, this.commandOptions);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getPlaying() {
+    this.assertSupportsCommand(import_Types.SoundSwitchCommand, import_Types.SoundSwitchCommand.TonePlayGet);
+    const cc = new SoundSwitchCCTonePlayGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe3.pick)(response, ["toneId", "volume"]);
+    }
+  }
+  get [import_API.SET_VALUE]() {
+    return async function({ property }, value, options) {
+      if (property === "defaultToneId") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        return this.setConfiguration(value, 255);
+      } else if (property === "defaultVolume") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        return this.setConfiguration(
+          0,
+          /* keep current tone */
+          value
+        );
+      } else if (property === "volume") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        this.tryGetValueDB()?.setValue(SoundSwitchCCValues.volume.endpoint(this.endpoint.index), value, { source: "driver", updateTimestamp: false });
+      } else if (property === "toneId") {
+        if (typeof value !== "number") {
+          (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
+        }
+        let result;
+        if (value > 0) {
+          const volume = options?.volume !== void 0 ? options.volume : this.tryGetValueDB()?.getValue(SoundSwitchCCValues.volume.endpoint(this.endpoint.index));
+          result = await this.play(value, volume);
+        } else {
+          result = await this.stopPlaying();
+        }
+        if (this.isSinglecast() && !(0, import_safe.supervisedCommandSucceeded)(result)) {
+          this.schedulePoll({ property }, value, {
+            transition: "fast"
+          });
+        }
+        return result;
+      } else {
+        (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+  get [import_API.POLL_VALUE]() {
+    return async function({ property }) {
+      switch (property) {
+        case "defaultToneId":
+        case "defaultVolume":
+          return (await this.getConfiguration())?.[property];
+        case "toneId":
+        case "volume":
+          return (await this.getPlaying())?.[property];
+        default:
+          (0, import_API.throwUnsupportedProperty)(this.ccId, property);
+      }
+    };
+  }
+};
+SoundSwitchCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Sound Switch"])
+], SoundSwitchCCAPI);
+let SoundSwitchCC = class SoundSwitchCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_safe.CommandClasses["Sound Switch"], ctx, endpoint).withOptions({
+      priority: import_safe.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      endpoint: this.endpointIndex,
+      message: `Interviewing ${this.ccName}...`,
+      direction: "none"
+    });
+    ctx.logNode(node.id, {
+      message: "requesting tone count...",
+      direction: "outbound"
+    });
+    const toneCount = await api.getToneCount();
+    if (toneCount != void 0) {
+      const logMessage = `supports ${toneCount} tones`;
+      ctx.logNode(node.id, {
+        message: logMessage,
+        direction: "inbound"
+      });
+    } else {
+      ctx.logNode(node.id, {
+        endpoint: this.endpointIndex,
+        message: "Querying tone count timed out, skipping interview...",
+        level: "warn"
+      });
+      return;
+    }
+    ctx.logNode(node.id, {
+      message: "requesting current sound configuration...",
+      direction: "outbound"
+    });
+    const config = await api.getConfiguration();
+    if (config) {
+      const logMessage = `received current sound configuration:
+default tone ID: ${config.defaultToneId}
+default volume: ${config.defaultVolume}`;
+      ctx.logNode(node.id, {
+        message: logMessage,
+        direction: "inbound"
+      });
+    }
+    const metadataStates = {};
+    for (let toneId = 1; toneId <= toneCount; toneId++) {
+      ctx.logNode(node.id, {
+        message: `requesting info for tone #${toneId}`,
+        direction: "outbound"
+      });
+      const info = await api.getToneInfo(toneId);
+      if (!info)
+        continue;
+      const logMessage = `received info for tone #${toneId}:
+name:     ${info.name}
+duration: ${info.duration} seconds`;
+      ctx.logNode(node.id, {
+        message: logMessage,
+        direction: "inbound"
+      });
+      metadataStates[toneId] = `${info.name} (${info.duration} sec)`;
+    }
+    this.setMetadata(ctx, SoundSwitchCCValues.defaultToneId, {
+      ...SoundSwitchCCValues.defaultToneId.meta,
+      min: 1,
+      max: toneCount,
+      states: metadataStates
+    });
+    this.setMetadata(ctx, SoundSwitchCCValues.toneId, {
+      ...SoundSwitchCCValues.toneId.meta,
+      min: 0,
+      max: toneCount,
+      states: {
+        0: "off",
+        ...metadataStates,
+        [255]: "default"
+      }
+    });
+    this.setInterviewComplete(ctx, true);
+  }
+};
+SoundSwitchCC = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Sound Switch"]),
+  (0, import_CommandClassDecorators.implementedVersion)(2),
+  (0, import_CommandClassDecorators.ccValues)(SoundSwitchCCValues)
+], SoundSwitchCC);
+let SoundSwitchCCTonesNumberReport = SoundSwitchCCTonesNumberReport_1 = class SoundSwitchCCTonesNumberReport2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.toneCount = options.toneCount;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const toneCount = raw.payload[0];
+    return new SoundSwitchCCTonesNumberReport_1({
+      nodeId: ctx.sourceNodeId,
+      toneCount
+    });
+  }
+  toneCount;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.toneCount]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "# of tones": this.toneCount }
+    };
+  }
+};
+SoundSwitchCCTonesNumberReport = SoundSwitchCCTonesNumberReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.TonesNumberReport)
+], SoundSwitchCCTonesNumberReport);
+let SoundSwitchCCTonesNumberGet = class SoundSwitchCCTonesNumberGet2 extends SoundSwitchCC {
+};
+SoundSwitchCCTonesNumberGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.TonesNumberGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SoundSwitchCCTonesNumberReport)
+], SoundSwitchCCTonesNumberGet);
+let SoundSwitchCCToneInfoReport = SoundSwitchCCToneInfoReport_1 = class SoundSwitchCCToneInfoReport2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.toneId = options.toneId;
+    this.duration = options.duration;
+    this.name = options.name;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 4);
+    const toneId = raw.payload[0];
+    const duration = raw.payload.readUInt16BE(1);
+    const nameLength = raw.payload[3];
+    (0, import_safe.validatePayload)(raw.payload.length >= 4 + nameLength);
+    const name = raw.payload.subarray(4, 4 + nameLength).toString("utf8");
+    return new SoundSwitchCCToneInfoReport_1({
+      nodeId: ctx.sourceNodeId,
+      toneId,
+      duration,
+      name
+    });
+  }
+  toneId;
+  duration;
+  name;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.concat([
+      import_safe2.Bytes.from([this.toneId, 0, 0, this.name.length]),
+      import_safe2.Bytes.from(this.name, "utf8")
+    ]);
+    this.payload.writeUInt16BE(this.duration, 1);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "tone id": this.toneId,
+        duration: `${this.duration} seconds`,
+        name: this.name
+      }
+    };
+  }
+};
+SoundSwitchCCToneInfoReport = SoundSwitchCCToneInfoReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.ToneInfoReport)
+], SoundSwitchCCToneInfoReport);
+const testResponseForSoundSwitchToneInfoGet = (sent, received) => {
+  return received.toneId === sent.toneId;
+};
+let SoundSwitchCCToneInfoGet = SoundSwitchCCToneInfoGet_1 = class SoundSwitchCCToneInfoGet2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.toneId = options.toneId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const toneId = raw.payload[0];
+    return new SoundSwitchCCToneInfoGet_1({
+      nodeId: ctx.sourceNodeId,
+      toneId
+    });
+  }
+  toneId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.toneId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { "tone id": this.toneId }
+    };
+  }
+};
+SoundSwitchCCToneInfoGet = SoundSwitchCCToneInfoGet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.ToneInfoGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SoundSwitchCCToneInfoReport, testResponseForSoundSwitchToneInfoGet)
+], SoundSwitchCCToneInfoGet);
+let SoundSwitchCCConfigurationSet = SoundSwitchCCConfigurationSet_1 = class SoundSwitchCCConfigurationSet2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.defaultVolume = options.defaultVolume;
+    this.defaultToneId = options.defaultToneId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const defaultVolume = raw.payload[0];
+    const defaultToneId = raw.payload[1];
+    return new SoundSwitchCCConfigurationSet_1({
+      nodeId: ctx.sourceNodeId,
+      defaultVolume,
+      defaultToneId
+    });
+  }
+  defaultVolume;
+  defaultToneId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.defaultVolume, this.defaultToneId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "default volume": `${this.defaultVolume} %`,
+        "default tone id": this.defaultToneId
+      }
+    };
+  }
+};
+SoundSwitchCCConfigurationSet = SoundSwitchCCConfigurationSet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.ConfigurationSet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], SoundSwitchCCConfigurationSet);
+let SoundSwitchCCConfigurationReport = SoundSwitchCCConfigurationReport_1 = class SoundSwitchCCConfigurationReport2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.defaultVolume = options.defaultVolume;
+    this.defaultToneId = options.defaultToneId;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 2);
+    const defaultVolume = (0, import_math.clamp)(raw.payload[0], 0, 100);
+    const defaultToneId = raw.payload[1];
+    return new SoundSwitchCCConfigurationReport_1({
+      nodeId: ctx.sourceNodeId,
+      defaultVolume,
+      defaultToneId
+    });
+  }
+  defaultVolume;
+  defaultToneId;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.defaultVolume, this.defaultToneId]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        "default volume": `${this.defaultVolume} %`,
+        "default tone id": this.defaultToneId
+      }
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(SoundSwitchCCValues.defaultVolume)
+], SoundSwitchCCConfigurationReport.prototype, "defaultVolume", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(SoundSwitchCCValues.defaultToneId)
+], SoundSwitchCCConfigurationReport.prototype, "defaultToneId", void 0);
+SoundSwitchCCConfigurationReport = SoundSwitchCCConfigurationReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.ConfigurationReport)
+], SoundSwitchCCConfigurationReport);
+let SoundSwitchCCConfigurationGet = class SoundSwitchCCConfigurationGet2 extends SoundSwitchCC {
+};
+SoundSwitchCCConfigurationGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.ConfigurationGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SoundSwitchCCConfigurationReport)
+], SoundSwitchCCConfigurationGet);
+let SoundSwitchCCTonePlaySet = SoundSwitchCCTonePlaySet_1 = class SoundSwitchCCTonePlaySet2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.toneId = options.toneId;
+    this.volume = options.volume;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const toneId = raw.payload[0];
+    let volume;
+    if (toneId !== 0 && raw.payload.length >= 2) {
+      volume = raw.payload[1];
+    }
+    return new SoundSwitchCCTonePlaySet_1({
+      nodeId: ctx.sourceNodeId,
+      toneId,
+      volume
+    });
+  }
+  toneId;
+  volume;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.toneId, this.volume ?? 0]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "tone id": this.toneId
+    };
+    if (this.volume != void 0) {
+      message.volume = this.volume === 0 ? "default" : `${this.volume} %`;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+SoundSwitchCCTonePlaySet = SoundSwitchCCTonePlaySet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.TonePlaySet),
+  (0, import_CommandClassDecorators.useSupervision)()
+], SoundSwitchCCTonePlaySet);
+let SoundSwitchCCTonePlayReport = SoundSwitchCCTonePlayReport_1 = class SoundSwitchCCTonePlayReport2 extends SoundSwitchCC {
+  constructor(options) {
+    super(options);
+    this.toneId = options.toneId;
+    this.volume = options.volume;
+  }
+  static from(raw, ctx) {
+    (0, import_safe.validatePayload)(raw.payload.length >= 1);
+    const toneId = raw.payload[0];
+    let volume;
+    if (toneId !== 0 && raw.payload.length >= 2) {
+      volume = raw.payload[1];
+    }
+    return new SoundSwitchCCTonePlayReport_1({
+      nodeId: ctx.sourceNodeId,
+      toneId,
+      volume
+    });
+  }
+  toneId;
+  volume;
+  serialize(ctx) {
+    this.payload = import_safe2.Bytes.from([this.toneId, this.volume ?? 0]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const message = {
+      "tone id": this.toneId
+    };
+    if (this.volume != void 0) {
+      message.volume = this.volume === 0 ? "default" : `${this.volume} %`;
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(SoundSwitchCCValues.toneId)
+], SoundSwitchCCTonePlayReport.prototype, "toneId", void 0);
+__decorate([
+  (0, import_CommandClassDecorators.ccValue)(SoundSwitchCCValues.volume)
+], SoundSwitchCCTonePlayReport.prototype, "volume", void 0);
+SoundSwitchCCTonePlayReport = SoundSwitchCCTonePlayReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.TonePlayReport)
+], SoundSwitchCCTonePlayReport);
+let SoundSwitchCCTonePlayGet = class SoundSwitchCCTonePlayGet2 extends SoundSwitchCC {
+};
+SoundSwitchCCTonePlayGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SoundSwitchCommand.TonePlayGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SoundSwitchCCTonePlayReport)
+], SoundSwitchCCTonePlayGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SoundSwitchCC,
+  SoundSwitchCCAPI,
+  SoundSwitchCCConfigurationGet,
+  SoundSwitchCCConfigurationReport,
+  SoundSwitchCCConfigurationSet,
+  SoundSwitchCCToneInfoGet,
+  SoundSwitchCCToneInfoReport,
+  SoundSwitchCCTonePlayGet,
+  SoundSwitchCCTonePlayReport,
+  SoundSwitchCCTonePlaySet,
+  SoundSwitchCCTonesNumberGet,
+  SoundSwitchCCTonesNumberReport,
+  SoundSwitchCCValues
+});
+//# sourceMappingURL=SoundSwitchCC.js.map