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

package/build/esm/cc/ProtectionCC.js

@@ -0,0 +1,669 @@
+var __decorate = (this && this.__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 ProtectionCCReport_1, ProtectionCCSupportedReport_1, ProtectionCCExclusiveControlReport_1, ProtectionCCTimeoutReport_1;
+function __assertType(argName, typeName, boundHasError) {
+    const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+    if (boundHasError()) {
+        throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+    }
+}
+const __assertType__LocalProtectionState = $o => {
+    function su__1__2__3_eu($o) {
+        return ![0, 1, 2].includes($o) ? {} : null;
+    }
+    return su__1__2__3_eu($o);
+};
+const __assertType__optional_RFProtectionState = $o => {
+    function su__1__2__3_eu($o) {
+        return ![0, 1, 2].includes($o) ? {} : null;
+    }
+    function optional_su__1__2__3_eu($o) {
+        if ($o !== undefined) {
+            const error = su__1__2__3_eu($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional_su__1__2__3_eu($o);
+};
+const __assertType__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+const __assertType__Timeout = $o => {
+    function _0($o) {
+        return !($o instanceof require("@zwave-js/core/safe").Timeout) ? {} : null;
+    }
+    return _0($o);
+};
+import { CommandClasses, MAX_NODES, MessagePriority, Timeout, ValueMetadata, ZWaveError, ZWaveErrorCodes, enumValuesToMetadataStates, parseBitMask, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, pick } from "@zwave-js/shared/safe";
+import { padStart } from "alcalzone-shared/strings/index.js";
+import { CCAPI, POLL_VALUE, SET_VALUE, throwUnsupportedProperty, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { LocalProtectionState, ProtectionCommand, RFProtectionState, } from "../lib/_Types.js";
+export const ProtectionCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses.Protection, {
+        ...V.staticProperty("exclusiveControlNodeId", {
+            ...ValueMetadata.UInt8,
+            min: 1,
+            max: MAX_NODES,
+            label: "Node ID with exclusive control",
+        }, { minVersion: 2 }),
+        ...V.staticPropertyWithName("localProtectionState", "local", {
+            ...ValueMetadata.Number,
+            label: "Local protection state",
+            states: enumValuesToMetadataStates(LocalProtectionState),
+        }),
+        ...V.staticPropertyWithName("rfProtectionState", "rf", {
+            ...ValueMetadata.Number,
+            label: "RF protection state",
+            states: enumValuesToMetadataStates(RFProtectionState),
+        }, { minVersion: 2 }),
+        ...V.staticProperty("timeout", {
+            ...ValueMetadata.UInt8,
+            label: "RF protection timeout",
+        }, { minVersion: 2 }),
+        ...V.staticProperty("supportsExclusiveControl", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsTimeout", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportedLocalStates", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportedRFStates", undefined, {
+            internal: true,
+        }),
+    }),
+});
+let ProtectionCCAPI = class ProtectionCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case ProtectionCommand.Get:
+                return this.isSinglecast();
+            case ProtectionCommand.Set:
+                return true; // This is mandatory
+            case ProtectionCommand.SupportedGet:
+                return this.version >= 2 && this.isSinglecast();
+            case ProtectionCommand.TimeoutGet:
+            case ProtectionCommand.TimeoutSet: {
+                return (this.isSinglecast()
+                    && this.tryGetValueDB()?.getValue(ProtectionCCValues.supportsTimeout.endpoint(this.endpoint.index)));
+            }
+            case ProtectionCommand.ExclusiveControlGet:
+            case ProtectionCommand.ExclusiveControlSet: {
+                return (this.isSinglecast()
+                    && this.tryGetValueDB()?.getValue(ProtectionCCValues.supportsExclusiveControl.endpoint(this.endpoint.index)));
+            }
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property }, value) {
+            const valueDB = this.tryGetValueDB();
+            if (property === "local") {
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                // We need to set both values together, so retrieve the other one from the value DB
+                const rf = valueDB?.getValue(ProtectionCCValues.rfProtectionState.endpoint(this.endpoint.index));
+                return this.set(value, rf);
+            }
+            else if (property === "rf") {
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                // We need to set both values together, so retrieve the other one from the value DB
+                const local = valueDB?.getValue(ProtectionCCValues.localProtectionState.endpoint(this.endpoint.index));
+                return this.set(local ?? LocalProtectionState.Unprotected, value);
+            }
+            else if (property === "exclusiveControlNodeId") {
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                return this.setExclusiveControl(value);
+            }
+            else {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    get [POLL_VALUE]() {
+        return async function ({ property }) {
+            switch (property) {
+                case "local":
+                case "rf":
+                    return (await this.get())?.[property];
+                case "exclusiveControlNodeId":
+                    return this.getExclusiveControl();
+                default:
+                    throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get() {
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.Get);
+        const cc = new ProtectionCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, ["local", "rf"]);
+        }
+    }
+    async set(local, rf) {
+        __assertType("local", "LocalProtectionState", __assertType__LocalProtectionState.bind(void 0, local));
+        __assertType("rf", "(optional) RFProtectionState", __assertType__optional_RFProtectionState.bind(void 0, rf));
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.Set);
+        const cc = new ProtectionCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            local,
+            rf,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getSupported() {
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.SupportedGet);
+        const cc = new ProtectionCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "supportsExclusiveControl",
+                "supportsTimeout",
+                "supportedLocalStates",
+                "supportedRFStates",
+            ]);
+        }
+    }
+    async getExclusiveControl() {
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.ExclusiveControlGet);
+        const cc = new ProtectionCCExclusiveControlGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.exclusiveControlNodeId;
+    }
+    async setExclusiveControl(nodeId) {
+        __assertType("nodeId", "number", __assertType__number.bind(void 0, nodeId));
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.ExclusiveControlSet);
+        const cc = new ProtectionCCExclusiveControlSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            exclusiveControlNodeId: nodeId,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getTimeout() {
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.TimeoutGet);
+        const cc = new ProtectionCCTimeoutGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.timeout;
+    }
+    async setTimeout(timeout) {
+        __assertType("timeout", "Timeout", __assertType__Timeout.bind(void 0, timeout));
+        this.assertSupportsCommand(ProtectionCommand, ProtectionCommand.TimeoutSet);
+        const cc = new ProtectionCCTimeoutSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            timeout,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+};
+ProtectionCCAPI = __decorate([
+    API(CommandClasses.Protection)
+], ProtectionCCAPI);
+export { ProtectionCCAPI };
+let ProtectionCC = class ProtectionCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses.Protection, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        // We need to do some queries after a potential timeout
+        // In this case, do now mark this CC as interviewed completely
+        let hadCriticalTimeout = false;
+        // First find out what the device supports
+        if (api.version >= 2) {
+            ctx.logNode(node.id, {
+                message: "querying protection capabilities...",
+                direction: "outbound",
+            });
+            const resp = await api.getSupported();
+            if (resp) {
+                const logMessage = `received protection capabilities:
+exclusive control:       ${resp.supportsExclusiveControl}
+timeout:                 ${resp.supportsTimeout}
+local protection states: ${resp.supportedLocalStates
+                    .map((local) => getEnumMemberName(LocalProtectionState, local))
+                    .map((str) => `\n· ${str}`)
+                    .join("")}
+RF protection states:    ${resp.supportedRFStates
+                    .map((local) => getEnumMemberName(RFProtectionState, local))
+                    .map((str) => `\n· ${str}`)
+                    .join("")}`;
+                ctx.logNode(node.id, {
+                    message: logMessage,
+                    direction: "inbound",
+                });
+            }
+            else {
+                hadCriticalTimeout = true;
+            }
+        }
+        await this.refreshValues(ctx);
+        // Remember that the interview is complete
+        if (!hadCriticalTimeout)
+            this.setInterviewComplete(ctx, true);
+    }
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses.Protection, ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        const supportsExclusiveControl = !!this.getValue(ctx, ProtectionCCValues.supportsExclusiveControl);
+        const supportsTimeout = !!this.getValue(ctx, ProtectionCCValues.supportsTimeout);
+        // Query the current state
+        ctx.logNode(node.id, {
+            message: "querying protection status...",
+            direction: "outbound",
+        });
+        const protectionResp = await api.get();
+        if (protectionResp) {
+            let logMessage = `received protection status:
+local: ${getEnumMemberName(LocalProtectionState, protectionResp.local)}`;
+            if (protectionResp.rf != undefined) {
+                logMessage += `
+rf     ${getEnumMemberName(RFProtectionState, protectionResp.rf)}`;
+            }
+            ctx.logNode(node.id, {
+                message: logMessage,
+                direction: "inbound",
+            });
+        }
+        if (supportsTimeout) {
+            // Query the current timeout
+            ctx.logNode(node.id, {
+                message: "querying protection timeout...",
+                direction: "outbound",
+            });
+            const timeout = await api.getTimeout();
+            if (timeout) {
+                ctx.logNode(node.id, {
+                    message: `received timeout: ${timeout.toString()}`,
+                    direction: "inbound",
+                });
+            }
+        }
+        if (supportsExclusiveControl) {
+            // Query the current timeout
+            ctx.logNode(node.id, {
+                message: "querying exclusive control node...",
+                direction: "outbound",
+            });
+            const nodeId = await api.getExclusiveControl();
+            if (nodeId != undefined) {
+                ctx.logNode(node.id, {
+                    message: (nodeId !== 0
+                        ? `Node ${padStart(nodeId.toString(), 3, "0")}`
+                        : `no node`) + ` has exclusive control`,
+                    direction: "inbound",
+                });
+            }
+        }
+    }
+};
+ProtectionCC = __decorate([
+    commandClass(CommandClasses.Protection),
+    implementedVersion(2),
+    ccValues(ProtectionCCValues)
+], ProtectionCC);
+export { ProtectionCC };
+let ProtectionCCSet = class ProtectionCCSet extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        this.local = options.local;
+        this.rf = options.rf;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new ProtectionCCSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    local;
+    rf;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.local & 0b1111,
+            (this.rf ?? RFProtectionState.Unprotected) & 0b1111,
+        ]);
+        const ccVersion = getEffectiveCCVersion(ctx, this);
+        if (ccVersion < 2 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+            // When forcing CC version 1, only include the local state
+            this.payload = this.payload.subarray(0, 1);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            local: getEnumMemberName(LocalProtectionState, this.local),
+        };
+        if (this.rf != undefined) {
+            message.rf = getEnumMemberName(RFProtectionState, this.rf);
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ProtectionCCSet = __decorate([
+    CCCommand(ProtectionCommand.Set),
+    useSupervision()
+], ProtectionCCSet);
+export { ProtectionCCSet };
+let ProtectionCCReport = ProtectionCCReport_1 = class ProtectionCCReport extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.local = options.local;
+        this.rf = options.rf;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const local = raw.payload[0] & 0b1111;
+        let rf;
+        if (raw.payload.length >= 2) {
+            rf = raw.payload[1] & 0b1111;
+        }
+        return new ProtectionCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            local,
+            rf,
+        });
+    }
+    local;
+    rf;
+    toLogEntry(ctx) {
+        const message = {
+            local: getEnumMemberName(LocalProtectionState, this.local),
+        };
+        if (this.rf != undefined) {
+            message.rf = getEnumMemberName(RFProtectionState, this.rf);
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(ProtectionCCValues.localProtectionState)
+], ProtectionCCReport.prototype, "local", void 0);
+__decorate([
+    ccValue(ProtectionCCValues.rfProtectionState)
+], ProtectionCCReport.prototype, "rf", void 0);
+ProtectionCCReport = ProtectionCCReport_1 = __decorate([
+    CCCommand(ProtectionCommand.Report)
+], ProtectionCCReport);
+export { ProtectionCCReport };
+let ProtectionCCGet = class ProtectionCCGet extends ProtectionCC {
+};
+ProtectionCCGet = __decorate([
+    CCCommand(ProtectionCommand.Get),
+    expectedCCResponse(ProtectionCCReport)
+], ProtectionCCGet);
+export { ProtectionCCGet };
+let ProtectionCCSupportedReport = ProtectionCCSupportedReport_1 = class ProtectionCCSupportedReport extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.supportsTimeout = options.supportsTimeout;
+        this.supportsExclusiveControl = options.supportsExclusiveControl;
+        this.supportedLocalStates = options.supportedLocalStates;
+        this.supportedRFStates = options.supportedRFStates;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 5);
+        const supportsTimeout = !!(raw.payload[0] & 0b1);
+        const supportsExclusiveControl = !!(raw.payload[0] & 0b10);
+        const supportedLocalStates = parseBitMask(raw.payload.subarray(1, 3), LocalProtectionState.Unprotected);
+        const supportedRFStates = parseBitMask(raw.payload.subarray(3, 5), RFProtectionState.Unprotected);
+        return new ProtectionCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportsTimeout,
+            supportsExclusiveControl,
+            supportedLocalStates,
+            supportedRFStates,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        // update metadata (partially) for the local and rf values
+        const localStateValue = ProtectionCCValues.localProtectionState;
+        this.setMetadata(ctx, localStateValue, {
+            ...localStateValue.meta,
+            states: enumValuesToMetadataStates(LocalProtectionState, this.supportedLocalStates),
+        });
+        const rfStateValue = ProtectionCCValues.rfProtectionState;
+        this.setMetadata(ctx, rfStateValue, {
+            ...rfStateValue.meta,
+            states: enumValuesToMetadataStates(RFProtectionState, this.supportedRFStates),
+        });
+        return true;
+    }
+    supportsExclusiveControl;
+    supportsTimeout;
+    supportedLocalStates;
+    supportedRFStates;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supports exclusive control": this.supportsExclusiveControl,
+                "supports timeout": this.supportsTimeout,
+                "local protection states": this.supportedLocalStates
+                    .map((local) => getEnumMemberName(LocalProtectionState, local))
+                    .map((str) => `\n· ${str}`)
+                    .join(""),
+                "RF protection states": this.supportedRFStates
+                    .map((rf) => getEnumMemberName(RFProtectionState, rf))
+                    .map((str) => `\n· ${str}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(ProtectionCCValues.supportsExclusiveControl)
+], ProtectionCCSupportedReport.prototype, "supportsExclusiveControl", void 0);
+__decorate([
+    ccValue(ProtectionCCValues.supportsTimeout)
+], ProtectionCCSupportedReport.prototype, "supportsTimeout", void 0);
+__decorate([
+    ccValue(ProtectionCCValues.supportedLocalStates)
+], ProtectionCCSupportedReport.prototype, "supportedLocalStates", void 0);
+__decorate([
+    ccValue(ProtectionCCValues.supportedRFStates)
+], ProtectionCCSupportedReport.prototype, "supportedRFStates", void 0);
+ProtectionCCSupportedReport = ProtectionCCSupportedReport_1 = __decorate([
+    CCCommand(ProtectionCommand.SupportedReport)
+], ProtectionCCSupportedReport);
+export { ProtectionCCSupportedReport };
+let ProtectionCCSupportedGet = class ProtectionCCSupportedGet extends ProtectionCC {
+};
+ProtectionCCSupportedGet = __decorate([
+    CCCommand(ProtectionCommand.SupportedGet),
+    expectedCCResponse(ProtectionCCSupportedReport)
+], ProtectionCCSupportedGet);
+export { ProtectionCCSupportedGet };
+let ProtectionCCExclusiveControlReport = ProtectionCCExclusiveControlReport_1 = class ProtectionCCExclusiveControlReport extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.exclusiveControlNodeId = options.exclusiveControlNodeId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const exclusiveControlNodeId = raw.payload[0];
+        return new ProtectionCCExclusiveControlReport_1({
+            nodeId: ctx.sourceNodeId,
+            exclusiveControlNodeId,
+        });
+    }
+    exclusiveControlNodeId;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "exclusive control node id": this.exclusiveControlNodeId,
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(ProtectionCCValues.exclusiveControlNodeId)
+], ProtectionCCExclusiveControlReport.prototype, "exclusiveControlNodeId", void 0);
+ProtectionCCExclusiveControlReport = ProtectionCCExclusiveControlReport_1 = __decorate([
+    CCCommand(ProtectionCommand.ExclusiveControlReport)
+], ProtectionCCExclusiveControlReport);
+export { ProtectionCCExclusiveControlReport };
+let ProtectionCCExclusiveControlGet = class ProtectionCCExclusiveControlGet extends ProtectionCC {
+};
+ProtectionCCExclusiveControlGet = __decorate([
+    CCCommand(ProtectionCommand.ExclusiveControlGet),
+    expectedCCResponse(ProtectionCCExclusiveControlReport)
+], ProtectionCCExclusiveControlGet);
+export { ProtectionCCExclusiveControlGet };
+let ProtectionCCExclusiveControlSet = class ProtectionCCExclusiveControlSet extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        this.exclusiveControlNodeId = options.exclusiveControlNodeId;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new ProtectionCCExclusiveControlSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    exclusiveControlNodeId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.exclusiveControlNodeId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "exclusive control node id": this.exclusiveControlNodeId,
+            },
+        };
+    }
+};
+ProtectionCCExclusiveControlSet = __decorate([
+    CCCommand(ProtectionCommand.ExclusiveControlSet),
+    expectedCCResponse(ProtectionCCReport),
+    useSupervision()
+], ProtectionCCExclusiveControlSet);
+export { ProtectionCCExclusiveControlSet };
+let ProtectionCCTimeoutReport = ProtectionCCTimeoutReport_1 = class ProtectionCCTimeoutReport extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.timeout = options.timeout;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const timeout = Timeout.parse(raw.payload[0]);
+        return new ProtectionCCTimeoutReport_1({
+            nodeId: ctx.sourceNodeId,
+            timeout,
+        });
+    }
+    timeout;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { timeout: this.timeout.toString() },
+        };
+    }
+};
+__decorate([
+    ccValue(ProtectionCCValues.timeout)
+], ProtectionCCTimeoutReport.prototype, "timeout", void 0);
+ProtectionCCTimeoutReport = ProtectionCCTimeoutReport_1 = __decorate([
+    CCCommand(ProtectionCommand.TimeoutReport)
+], ProtectionCCTimeoutReport);
+export { ProtectionCCTimeoutReport };
+let ProtectionCCTimeoutGet = class ProtectionCCTimeoutGet extends ProtectionCC {
+};
+ProtectionCCTimeoutGet = __decorate([
+    CCCommand(ProtectionCommand.TimeoutGet),
+    expectedCCResponse(ProtectionCCTimeoutReport)
+], ProtectionCCTimeoutGet);
+export { ProtectionCCTimeoutGet };
+let ProtectionCCTimeoutSet = class ProtectionCCTimeoutSet extends ProtectionCC {
+    constructor(options) {
+        super(options);
+        this.timeout = options.timeout;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new ProtectionCCTimeoutSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    timeout;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.timeout.serialize()]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { timeout: this.timeout.toString() },
+        };
+    }
+};
+ProtectionCCTimeoutSet = __decorate([
+    CCCommand(ProtectionCommand.TimeoutSet),
+    expectedCCResponse(ProtectionCCReport),
+    useSupervision()
+], ProtectionCCTimeoutSet);
+export { ProtectionCCTimeoutSet };
+//# sourceMappingURL=ProtectionCC.js.map