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

package/build/esm/cc/MultiChannelCC.js

@@ -0,0 +1,1127 @@
+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 MultiChannelCCEndPointReport_1, MultiChannelCCCapabilityReport_1, MultiChannelCCCapabilityGet_1, MultiChannelCCEndPointFindReport_1, MultiChannelCCEndPointFind_1, MultiChannelCCAggregatedMembersReport_1, MultiChannelCCCommandEncapsulation_1, MultiChannelCCV1Report_1, MultiChannelCCV1CommandEncapsulation_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__number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    return _number($o);
+};
+import { CommandClasses, MessagePriority, ZWaveError, ZWaveErrorCodes, encodeApplicationNodeInformation, encodeBitMask, getCCName, getGenericDeviceClass, getSpecificDeviceClass, parseApplicationNodeInformation, parseBitMask, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { distinct } from "alcalzone-shared/arrays/index.js";
+import { CCAPI } from "../lib/API.js";
+import { CommandClass, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, } from "../lib/CommandClassDecorators.js";
+import { isEncapsulatingCommandClass, isMultiEncapsulatingCommandClass, } from "../lib/EncapsulatingCommandClass.js";
+import { V } from "../lib/Values.js";
+import { MultiChannelCommand } from "../lib/_Types.js";
+// TODO: Handle removal reports of dynamic endpoints
+export const MultiChannelCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Multi Channel"], {
+        ...V.staticProperty("endpointIndizes", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("individualEndpointCount", "individualCount", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("aggregatedEndpointCount", "aggregatedCount", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("endpointCountIsDynamic", "countIsDynamic", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("endpointsHaveIdenticalCapabilities", "identicalCapabilities", undefined, {
+            internal: true,
+            supportsEndpoints: false,
+        }),
+        ...V.staticPropertyWithName("endpointCCs", "commandClasses", undefined, { internal: true }),
+        ...V.staticPropertyWithName("endpointDeviceClass", "deviceClass", undefined, { internal: true }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["Multi Channel"], {
+        ...V.dynamicPropertyAndKeyWithName("aggregatedEndpointMembers", "members", (endpointIndex) => endpointIndex, ({ property, propertyKey }) => property === "members" && typeof propertyKey === "number", undefined, { internal: true }),
+    }),
+});
+// @noSetValueAPI
+/**
+ * Many devices unnecessarily use endpoints when they could (or do) provide all functionality via the root device.
+ * This function gives an estimate if this is the case (i.e. all endpoints have a different device class)
+ */
+function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
+    // Gather all device classes
+    const deviceClasses = new Map();
+    for (const endpoint of endpointIndizes) {
+        const devClassValueId = MultiChannelCCValues.endpointDeviceClass
+            .endpoint(endpoint);
+        const deviceClass = ctx.getValueDB(nodeId).getValue(devClassValueId);
+        if (deviceClass) {
+            deviceClasses.set(endpoint, {
+                generic: deviceClass.generic,
+                specific: deviceClass.specific,
+            });
+        }
+    }
+    // Endpoints may be useless if all of them have different device classes
+    const distinctDeviceClasses = distinct([...deviceClasses.values()].map(({ generic, specific }) => generic * 256 + specific));
+    if (distinctDeviceClasses.length !== endpointIndizes.length) {
+        // There are endpoints with the same device class, so they are not unnecessary
+        return false;
+    }
+    // Endpoints are necessary if more than 1 of them has a switch-type device class
+    const switchTypeDeviceClasses = [
+        0x10, // Binary Switch
+        0x11, // Multilevel Switch
+        0x12, // Remote Switch
+        0x13, // Toggle Switch
+    ];
+    const numSwitchEndpoints = [...deviceClasses.values()].filter(({ generic }) => switchTypeDeviceClasses.includes(generic)).length;
+    if (numSwitchEndpoints > 1)
+        return false;
+    return true;
+}
+let MultiChannelCCAPI = class MultiChannelCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            // Legacy commands:
+            case MultiChannelCommand.GetV1:
+                return this.isSinglecast() && this.version === 1;
+            case MultiChannelCommand.CommandEncapsulationV1:
+                return this.version === 1;
+            // The specs start at version 3 but according to OZW,
+            // these do seem to be supported in version 2
+            case MultiChannelCommand.EndPointGet:
+            case MultiChannelCommand.CapabilityGet:
+                return this.version >= 2 && this.isSinglecast();
+            case MultiChannelCommand.CommandEncapsulation:
+                return this.version >= 2;
+            case MultiChannelCommand.EndPointFind:
+                return this.version >= 3 && this.isSinglecast();
+            case MultiChannelCommand.AggregatedMembersGet:
+                return this.version >= 4 && this.isSinglecast();
+        }
+        return super.supportsCommand(cmd);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getEndpoints() {
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.EndPointGet);
+        const cc = new MultiChannelCCEndPointGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return {
+                isDynamicEndpointCount: response.countIsDynamic,
+                identicalCapabilities: response.identicalCapabilities,
+                individualEndpointCount: response.individualCount,
+                aggregatedEndpointCount: response.aggregatedCount,
+            };
+        }
+    }
+    async getEndpointCapabilities(endpoint) {
+        __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.CapabilityGet);
+        const cc = new MultiChannelCCCapabilityGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            requestedEndpoint: endpoint,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            const generic = getGenericDeviceClass(response.genericDeviceClass);
+            const specific = getSpecificDeviceClass(response.genericDeviceClass, response.specificDeviceClass);
+            return {
+                isDynamic: response.isDynamic,
+                wasRemoved: response.wasRemoved,
+                supportedCCs: response.supportedCCs,
+                generic,
+                specific,
+            };
+        }
+    }
+    async findEndpoints(genericClass, specificClass) {
+        __assertType("genericClass", "number", __assertType__number.bind(void 0, genericClass));
+        __assertType("specificClass", "number", __assertType__number.bind(void 0, specificClass));
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.EndPointFind);
+        const cc = new MultiChannelCCEndPointFind({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            genericClass,
+            specificClass,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.foundEndpoints;
+    }
+    async getAggregatedMembers(endpoint) {
+        __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.AggregatedMembersGet);
+        const cc = new MultiChannelCCAggregatedMembersGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            requestedEndpoint: endpoint,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.members;
+    }
+    // Encapsulation is used internally and too frequently that we
+    // want to pay the cost of validating each call
+    // eslint-disable-next-line @zwave-js/ccapi-validate-args
+    async sendEncapsulated(options) {
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.CommandEncapsulation);
+        const cc = new MultiChannelCCCommandEncapsulation({
+            nodeId: this.endpoint.nodeId,
+            ...options,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getEndpointCountV1(ccId) {
+        __assertType("ccId", "CommandClasses", __assertType__number.bind(void 0, ccId));
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.GetV1);
+        const cc = new MultiChannelCCV1Get({
+            nodeId: this.endpoint.nodeId,
+            requestedCC: ccId,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.endpointCount;
+    }
+    // Encapsulation is used internally and too frequently that we
+    // want to pay the cost of validating each call
+    // eslint-disable-next-line @zwave-js/ccapi-validate-args
+    async sendEncapsulatedV1(encapsulated) {
+        this.assertSupportsCommand(MultiChannelCommand, MultiChannelCommand.CommandEncapsulationV1);
+        const cc = new MultiChannelCCV1CommandEncapsulation({
+            nodeId: this.endpoint.nodeId,
+            encapsulated,
+        });
+        await this.host.sendCommand(cc, this.commandOptions);
+    }
+};
+MultiChannelCCAPI = __decorate([
+    API(CommandClasses["Multi Channel"])
+], MultiChannelCCAPI);
+export { MultiChannelCCAPI };
+let MultiChannelCC = class MultiChannelCC extends CommandClass {
+    /** Tests if a command targets a specific endpoint and thus requires encapsulation */
+    static requiresEncapsulation(cc) {
+        return (cc.endpointIndex !== 0
+            && !(cc instanceof MultiChannelCCCommandEncapsulation)
+            && !(cc instanceof MultiChannelCCV1CommandEncapsulation));
+    }
+    /** Encapsulates a command that targets a specific endpoint, with version 2+ of the Multi Channel CC */
+    static encapsulate(cc) {
+        const ret = new MultiChannelCCCommandEncapsulation({
+            nodeId: cc.nodeId,
+            encapsulated: cc,
+            destination: cc.endpointIndex,
+        });
+        // Copy the encapsulation flags from the encapsulated command
+        ret.encapsulationFlags = cc.encapsulationFlags;
+        return ret;
+    }
+    /** Encapsulates a command that targets a specific endpoint, with version 1 of the Multi Channel CC */
+    static encapsulateV1(cc) {
+        const ret = new MultiChannelCCV1CommandEncapsulation({
+            nodeId: cc.nodeId,
+            encapsulated: cc,
+        });
+        // Copy the encapsulation flags from the encapsulated command
+        ret.encapsulationFlags = cc.encapsulationFlags;
+        return ret;
+    }
+    skipEndpointInterview() {
+        // The endpoints are discovered by querying the root device
+        return true;
+    }
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const removeEndpoints = ctx.getDeviceConfig?.(node.id)?.compat
+            ?.removeEndpoints;
+        if (removeEndpoints === "*") {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `Skipping ${this.ccName} interview b/c all endpoints are ignored by the device config file...`,
+                direction: "none",
+            });
+            return;
+        }
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        // Special interview procedure for legacy nodes
+        const ccVersion = getEffectiveCCVersion(ctx, this);
+        if (ccVersion === 1)
+            return this.interviewV1(ctx);
+        const endpoint = node.getEndpoint(this.endpointIndex);
+        const api = CCAPI.create(CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        const valueDB = this.getValueDB(ctx);
+        // Step 1: Retrieve general information about end points
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "querying device endpoint information...",
+            direction: "outbound",
+        });
+        const multiResponse = await api.getEndpoints();
+        if (!multiResponse) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "Querying device endpoint information timed out, aborting interview...",
+                level: "warn",
+            });
+            return this.throwMissingCriticalInterviewResponse();
+        }
+        let logMessage = `received response for device endpoints:
+endpoint count (individual): ${multiResponse.individualEndpointCount}
+count is dynamic:            ${multiResponse.isDynamicEndpointCount}
+identical capabilities:      ${multiResponse.identicalCapabilities}`;
+        if (multiResponse.aggregatedEndpointCount != undefined) {
+            logMessage +=
+                `\nendpoint count (aggregated): ${multiResponse.aggregatedEndpointCount}`;
+        }
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: logMessage,
+            direction: "inbound",
+        });
+        let allEndpoints = [];
+        const addSequentialEndpoints = () => {
+            for (let i = 1; i
+                <= multiResponse.individualEndpointCount
+                    + (multiResponse.aggregatedEndpointCount ?? 0); i++) {
+                allEndpoints.push(i);
+            }
+        };
+        if (api.supportsCommand(MultiChannelCommand.EndPointFind)) {
+            // Step 2a: Find all endpoints
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "querying all endpoints...",
+                direction: "outbound",
+            });
+            const foundEndpoints = await api.findEndpoints(0xff, 0xff);
+            if (foundEndpoints)
+                allEndpoints.push(...foundEndpoints);
+            if (!allEndpoints.length) {
+                // Create a sequential list of endpoints
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `Endpoint query returned no results, assuming that endpoints are sequential`,
+                    direction: "inbound",
+                });
+                addSequentialEndpoints();
+            }
+            else {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `received endpoints: ${allEndpoints
+                        .map(String)
+                        .join(", ")}`,
+                    direction: "inbound",
+                });
+            }
+        }
+        else {
+            // Step 2b: Assume that the endpoints are in sequential order
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `does not support EndPointFind, assuming that endpoints are sequential`,
+                direction: "none",
+            });
+            addSequentialEndpoints();
+        }
+        // Step 2.5: remove ignored endpoints
+        if (removeEndpoints?.length) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `The following endpoints are ignored through the config file: ${removeEndpoints.join(", ")}`,
+                direction: "none",
+            });
+            allEndpoints = allEndpoints.filter((e) => !removeEndpoints.includes(e));
+        }
+        // Step 3: Query endpoints
+        let hasQueriedCapabilities = false;
+        for (const endpoint of allEndpoints) {
+            if (endpoint > multiResponse.individualEndpointCount
+                && ccVersion >= 4) {
+                // Find members of aggregated end point
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `querying members of aggregated endpoint #${endpoint}...`,
+                    direction: "outbound",
+                });
+                const members = await api.getAggregatedMembers(endpoint);
+                if (members) {
+                    ctx.logNode(node.id, {
+                        endpoint: this.endpointIndex,
+                        message: `aggregated endpoint #${endpoint} has members ${members
+                            .map(String)
+                            .join(", ")}`,
+                        direction: "inbound",
+                    });
+                }
+            }
+            // When the device reports identical capabilities for all endpoints,
+            // we don't need to query them all
+            if (multiResponse.identicalCapabilities && hasQueriedCapabilities) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `all endpoints identical, skipping capability query for endpoint #${endpoint}...`,
+                    direction: "none",
+                });
+                // copy the capabilities from the first endpoint
+                const devClass = valueDB.getValue(MultiChannelCCValues.endpointDeviceClass.endpoint(allEndpoints[0]));
+                valueDB.setValue(MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint), devClass);
+                const ep1Caps = valueDB.getValue(MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]));
+                valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint), [...ep1Caps]);
+                continue;
+            }
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `querying capabilities for endpoint #${endpoint}...`,
+                direction: "outbound",
+            });
+            const caps = await api.getEndpointCapabilities(endpoint);
+            if (caps) {
+                hasQueriedCapabilities = true;
+                logMessage =
+                    `received response for endpoint capabilities (#${endpoint}):
+generic device class:  ${caps.generic.label}
+specific device class: ${caps.specific.label}
+is dynamic end point:  ${caps.isDynamic}
+supported CCs:`;
+                for (const cc of caps.supportedCCs) {
+                    logMessage += `\n  · ${getCCName(cc)}`;
+                }
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: logMessage,
+                    direction: "inbound",
+                });
+            }
+            else {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `Querying endpoint #${endpoint} capabilities timed out, aborting interview...`,
+                    level: "warn",
+                });
+                return this.throwMissingCriticalInterviewResponse();
+            }
+        }
+        // Now that all endpoints have been interviewed, remember which ones are there
+        // But first figure out if they seem unnecessary and if they do, which ones should be preserved
+        if (!multiResponse.identicalCapabilities
+            && areEndpointsUnnecessary(ctx, node.id, allEndpoints)) {
+            const preserve = ctx.getDeviceConfig?.(node.id)?.compat
+                ?.preserveEndpoints;
+            if (!preserve) {
+                allEndpoints = [];
+                ctx.logNode(node.id, {
+                    message: `Endpoints seem unnecessary b/c they have different device classes, ignoring all...`,
+                });
+            }
+            else if (preserve === "*") {
+                // preserve all endpoints, do nothing
+                ctx.logNode(node.id, {
+                    message: `Endpoints seem unnecessary, but are configured to be preserved.`,
+                });
+            }
+            else {
+                allEndpoints = allEndpoints.filter((ep) => preserve.includes(ep));
+                ctx.logNode(node.id, {
+                    message: `Endpoints seem unnecessary, but endpoints ${allEndpoints.join(", ")} are configured to be preserved.`,
+                });
+            }
+        }
+        this.setValue(ctx, MultiChannelCCValues.endpointIndizes, allEndpoints);
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    async interviewV1(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Multi Channel"], ctx, endpoint);
+        const valueDB = this.getValueDB(ctx);
+        // V1 works the opposite way - we scan all CCs and remember how many
+        // endpoints they have
+        const supportedCCs = [...node.getCCs()]
+            // Don't query CCs the node only controls
+            .filter(([, info]) => info.isSupported)
+            .map(([cc]) => cc)
+            // Don't query CCs that want to skip the endpoint interview
+            .filter((cc) => !CommandClass.createInstanceUnchecked(node, cc)?.skipEndpointInterview());
+        const endpointCounts = new Map();
+        for (const ccId of supportedCCs) {
+            ctx.logNode(node.id, {
+                message: `Querying endpoint count for CommandClass ${getCCName(ccId)}...`,
+                direction: "outbound",
+            });
+            const endpointCount = await api.getEndpointCountV1(ccId);
+            if (endpointCount != undefined) {
+                endpointCounts.set(ccId, endpointCount);
+                ctx.logNode(node.id, {
+                    message: `CommandClass ${getCCName(ccId)} has ${endpointCount} endpoints`,
+                    direction: "inbound",
+                });
+            }
+        }
+        // Store the collected information
+        // We have only individual and no dynamic and no aggregated endpoints
+        const numEndpoints = Math.max(...endpointCounts.values());
+        this.setValue(ctx, MultiChannelCCValues.endpointCountIsDynamic, false);
+        this.setValue(ctx, MultiChannelCCValues.aggregatedEndpointCount, 0);
+        this.setValue(ctx, MultiChannelCCValues.individualEndpointCount, numEndpoints);
+        // Since we queried all CCs separately, we can assume that all
+        // endpoints have different capabilities
+        this.setValue(ctx, MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
+        for (let endpoint = 1; endpoint <= numEndpoints; endpoint++) {
+            // Check which CCs exist on this endpoint
+            const endpointCCs = [...endpointCounts.entries()]
+                .filter(([, ccEndpoints]) => ccEndpoints >= endpoint)
+                .map(([ccId]) => ccId);
+            // And store it per endpoint
+            valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint), endpointCCs);
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+};
+MultiChannelCC = __decorate([
+    commandClass(CommandClasses["Multi Channel"]),
+    implementedVersion(4),
+    ccValues(MultiChannelCCValues)
+], MultiChannelCC);
+export { MultiChannelCC };
+let MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = class MultiChannelCCEndPointReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.countIsDynamic = options.countIsDynamic;
+        this.identicalCapabilities = options.identicalCapabilities;
+        this.individualCount = options.individualCount;
+        this.aggregatedCount = options.aggregatedCount;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const countIsDynamic = !!(raw.payload[0] & 0b10000000);
+        const identicalCapabilities = !!(raw.payload[0] & 0b01000000);
+        const individualCount = raw.payload[1] & 0b01111111;
+        let aggregatedCount;
+        if (raw.payload.length >= 3) {
+            aggregatedCount = raw.payload[2] & 0b01111111;
+        }
+        return new MultiChannelCCEndPointReport_1({
+            nodeId: ctx.sourceNodeId,
+            countIsDynamic,
+            identicalCapabilities,
+            individualCount,
+            aggregatedCount,
+        });
+    }
+    countIsDynamic;
+    identicalCapabilities;
+    individualCount;
+    aggregatedCount;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            (this.countIsDynamic ? 0b10000000 : 0)
+                | (this.identicalCapabilities ? 0b01000000 : 0),
+            this.individualCount & 0b01111111,
+            this.aggregatedCount ?? 0,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "endpoint count (individual)": this.individualCount,
+            "count is dynamic": this.countIsDynamic,
+            "identical capabilities": this.identicalCapabilities,
+        };
+        if (this.aggregatedCount != undefined) {
+            message["endpoint count (aggregated)"] = this.aggregatedCount;
+        }
+        const ret = {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+        return ret;
+    }
+};
+__decorate([
+    ccValue(MultiChannelCCValues.endpointCountIsDynamic)
+], MultiChannelCCEndPointReport.prototype, "countIsDynamic", void 0);
+__decorate([
+    ccValue(MultiChannelCCValues.endpointsHaveIdenticalCapabilities)
+], MultiChannelCCEndPointReport.prototype, "identicalCapabilities", void 0);
+__decorate([
+    ccValue(MultiChannelCCValues.individualEndpointCount)
+], MultiChannelCCEndPointReport.prototype, "individualCount", void 0);
+__decorate([
+    ccValue(MultiChannelCCValues.aggregatedEndpointCount)
+], MultiChannelCCEndPointReport.prototype, "aggregatedCount", void 0);
+MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = __decorate([
+    CCCommand(MultiChannelCommand.EndPointReport)
+], MultiChannelCCEndPointReport);
+export { MultiChannelCCEndPointReport };
+let MultiChannelCCEndPointGet = class MultiChannelCCEndPointGet extends MultiChannelCC {
+};
+MultiChannelCCEndPointGet = __decorate([
+    CCCommand(MultiChannelCommand.EndPointGet),
+    expectedCCResponse(MultiChannelCCEndPointReport)
+], MultiChannelCCEndPointGet);
+export { MultiChannelCCEndPointGet };
+let MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = class MultiChannelCCCapabilityReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.endpointIndex = options.endpointIndex;
+        this.genericDeviceClass = options.genericDeviceClass;
+        this.specificDeviceClass = options.specificDeviceClass;
+        this.supportedCCs = options.supportedCCs;
+        this.isDynamic = options.isDynamic;
+        this.wasRemoved = options.wasRemoved;
+    }
+    static from(raw, ctx) {
+        // Only validate the bytes we expect to see here
+        // parseApplicationNodeInformation does its own validation
+        validatePayload(raw.payload.length >= 1);
+        const endpointIndex = raw.payload[0] & 0b01111111;
+        const isDynamic = !!(raw.payload[0] & 0b10000000);
+        const NIF = parseApplicationNodeInformation(raw.payload.subarray(1));
+        const genericDeviceClass = NIF.genericDeviceClass;
+        const specificDeviceClass = NIF.specificDeviceClass;
+        const supportedCCs = NIF.supportedCCs;
+        // Removal reports have very specific information
+        const wasRemoved = isDynamic
+            && genericDeviceClass === 0xff // "Non-Interoperable"
+            && specificDeviceClass === 0x00;
+        return new MultiChannelCCCapabilityReport_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            isDynamic,
+            genericDeviceClass,
+            specificDeviceClass,
+            supportedCCs,
+            wasRemoved,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        const deviceClassValue = MultiChannelCCValues.endpointDeviceClass;
+        const ccsValue = MultiChannelCCValues.endpointCCs;
+        if (this.wasRemoved) {
+            this.removeValue(ctx, deviceClassValue);
+            this.removeValue(ctx, ccsValue);
+        }
+        else {
+            this.setValue(ctx, deviceClassValue, {
+                generic: this.genericDeviceClass,
+                specific: this.specificDeviceClass,
+            });
+            this.setValue(ctx, ccsValue, this.supportedCCs);
+        }
+        return true;
+    }
+    // The endpoint index must be overridden to be able to attribute the information to the correct endpoint
+    genericDeviceClass;
+    specificDeviceClass;
+    supportedCCs;
+    isDynamic;
+    wasRemoved;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([
+                (this.endpointIndex & 0b01111111)
+                    | (this.isDynamic ? 0b10000000 : 0),
+            ]),
+            encodeApplicationNodeInformation(this),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "endpoint index": this.endpointIndex,
+                "generic device class": getGenericDeviceClass(this.genericDeviceClass).label,
+                "specific device class": getSpecificDeviceClass(this.genericDeviceClass, this.specificDeviceClass).label,
+                "is dynamic end point": this.isDynamic,
+                "supported CCs": this.supportedCCs
+                    .map((cc) => `\n· ${getCCName(cc)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = __decorate([
+    CCCommand(MultiChannelCommand.CapabilityReport)
+], MultiChannelCCCapabilityReport);
+export { MultiChannelCCCapabilityReport };
+function testResponseForMultiChannelCapabilityGet(sent, received) {
+    return received.endpointIndex === sent.requestedEndpoint;
+}
+let MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = class MultiChannelCCCapabilityGet extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const requestedEndpoint = raw.payload[0] & 0b01111111;
+        return new MultiChannelCCCapabilityGet_1({
+            nodeId: ctx.sourceNodeId,
+            requestedEndpoint,
+        });
+    }
+    requestedEndpoint;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.requestedEndpoint & 0b01111111]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { endpoint: this.requestedEndpoint },
+        };
+    }
+};
+MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = __decorate([
+    CCCommand(MultiChannelCommand.CapabilityGet),
+    expectedCCResponse(MultiChannelCCCapabilityReport, testResponseForMultiChannelCapabilityGet)
+], MultiChannelCCCapabilityGet);
+export { MultiChannelCCCapabilityGet };
+let MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = class MultiChannelCCEndPointFindReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.genericClass = options.genericClass;
+        this.specificClass = options.specificClass;
+        this.foundEndpoints = options.foundEndpoints;
+        this.reportsToFollow = options.reportsToFollow;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const reportsToFollow = raw.payload[0];
+        const genericClass = raw.payload[1];
+        const specificClass = raw.payload[2];
+        // Some devices omit the endpoint list although that is not allowed in the specs
+        // therefore don't validatePayload here.
+        const foundEndpoints = [...raw.payload.subarray(3)]
+            .map((e) => e & 0b01111111)
+            .filter((e) => e !== 0);
+        return new MultiChannelCCEndPointFindReport_1({
+            nodeId: ctx.sourceNodeId,
+            reportsToFollow,
+            genericClass,
+            specificClass,
+            foundEndpoints,
+        });
+    }
+    genericClass;
+    specificClass;
+    foundEndpoints;
+    reportsToFollow;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([
+                this.reportsToFollow,
+                this.genericClass,
+                this.specificClass,
+            ]),
+            Bytes.from(this.foundEndpoints.map((e) => e & 0b01111111)),
+        ]);
+        return super.serialize(ctx);
+    }
+    getPartialCCSessionId() {
+        // Distinguish sessions by the requested device classes
+        return {
+            genericClass: this.genericClass,
+            specificClass: this.specificClass,
+        };
+    }
+    expectMoreMessages() {
+        return this.reportsToFollow > 0;
+    }
+    mergePartialCCs(partials, _ctx) {
+        // Concat the list of end points
+        this.foundEndpoints = [...partials, this]
+            .map((report) => report.foundEndpoints)
+            .reduce((prev, cur) => prev.concat(...cur), []);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "generic device class": getGenericDeviceClass(this.genericClass).label,
+                "specific device class": getSpecificDeviceClass(this.genericClass, this.specificClass).label,
+                "found endpoints": this.foundEndpoints.join(", "),
+                "# of reports to follow": this.reportsToFollow,
+            },
+        };
+    }
+};
+MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = __decorate([
+    CCCommand(MultiChannelCommand.EndPointFindReport)
+], MultiChannelCCEndPointFindReport);
+export { MultiChannelCCEndPointFindReport };
+let MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = class MultiChannelCCEndPointFind extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.genericClass = options.genericClass;
+        this.specificClass = options.specificClass;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const genericClass = raw.payload[0];
+        const specificClass = raw.payload[1];
+        return new MultiChannelCCEndPointFind_1({
+            nodeId: ctx.sourceNodeId,
+            genericClass,
+            specificClass,
+        });
+    }
+    genericClass;
+    specificClass;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.genericClass, this.specificClass]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "generic device class": getGenericDeviceClass(this.genericClass).label,
+                "specific device class": getSpecificDeviceClass(this.genericClass, this.specificClass).label,
+            },
+        };
+    }
+};
+MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = __decorate([
+    CCCommand(MultiChannelCommand.EndPointFind),
+    expectedCCResponse(MultiChannelCCEndPointFindReport)
+], MultiChannelCCEndPointFind);
+export { MultiChannelCCEndPointFind };
+let MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = class MultiChannelCCAggregatedMembersReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.aggregatedEndpointIndex = options.aggregatedEndpointIndex;
+        this.members = options.members;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const aggregatedEndpointIndex = raw.payload[0] & 0b0111_1111;
+        const bitMaskLength = raw.payload[1];
+        validatePayload(raw.payload.length >= 2 + bitMaskLength);
+        const bitMask = raw.payload.subarray(2, 2 + bitMaskLength);
+        const members = parseBitMask(bitMask);
+        return new MultiChannelCCAggregatedMembersReport_1({
+            nodeId: ctx.sourceNodeId,
+            aggregatedEndpointIndex,
+            members,
+        });
+    }
+    aggregatedEndpointIndex;
+    members;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "aggregated endpoint": this.aggregatedEndpointIndex,
+                members: this.members.join(", "),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])
+], MultiChannelCCAggregatedMembersReport.prototype, "members", void 0);
+MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = __decorate([
+    CCCommand(MultiChannelCommand.AggregatedMembersReport)
+], MultiChannelCCAggregatedMembersReport);
+export { MultiChannelCCAggregatedMembersReport };
+let MultiChannelCCAggregatedMembersGet = class MultiChannelCCAggregatedMembersGet extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new MultiChannelCCAggregatedMembersGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    requestedEndpoint;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.requestedEndpoint & 0b0111_1111]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { endpoint: this.requestedEndpoint },
+        };
+    }
+};
+MultiChannelCCAggregatedMembersGet = __decorate([
+    CCCommand(MultiChannelCommand.AggregatedMembersGet),
+    expectedCCResponse(MultiChannelCCAggregatedMembersReport)
+], MultiChannelCCAggregatedMembersGet);
+export { MultiChannelCCAggregatedMembersGet };
+// SDS13783: A receiving node MAY respond to a Multi Channel encapsulated command if the Destination
+// End Point field specifies a single End Point. In that case, the response MUST be Multi Channel
+// encapsulated.
+// A receiving node MUST NOT respond to a Multi Channel encapsulated command if the
+// Destination End Point field specifies multiple End Points via bit mask addressing.
+function getCCResponseForCommandEncapsulation(sent) {
+    if (typeof sent.destination === "number"
+        && sent.encapsulated.expectsCCResponse()) {
+        // Allow both versions of the encapsulation command
+        // Our implementation check is a bit too strict, so change the return type
+        return [
+            MultiChannelCCCommandEncapsulation,
+            MultiChannelCCV1CommandEncapsulation,
+        ];
+    }
+}
+function testResponseForCommandEncapsulation(sent, received) {
+    if (typeof sent.destination === "number"
+        && sent.destination === received.endpointIndex) {
+        return "checkEncapsulated";
+    }
+    return false;
+}
+let MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = class MultiChannelCCCommandEncapsulation extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.encapsulated = options.encapsulated;
+        this.encapsulated.encapsulatingCC = this;
+        // Propagate the endpoint index all the way down
+        let cur = this;
+        while (cur) {
+            if (isMultiEncapsulatingCommandClass(cur)) {
+                for (const cc of cur.encapsulated) {
+                    cc.endpointIndex = this.endpointIndex;
+                }
+                break;
+            }
+            else if (isEncapsulatingCommandClass(cur)) {
+                cur.encapsulated.endpointIndex = this.endpointIndex;
+                cur = cur.encapsulated;
+            }
+            else {
+                break;
+            }
+        }
+        this.destination = options.destination;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        let endpointIndex;
+        let destination;
+        if (ctx.getDeviceConfig?.(ctx.sourceNodeId)
+            ?.compat?.treatDestinationEndpointAsSource) {
+            // This device incorrectly uses the destination field to indicate the source endpoint
+            endpointIndex = raw.payload[1] & 0b0111_1111;
+            destination = 0;
+        }
+        else {
+            // Parse normally
+            endpointIndex = raw.payload[0] & 0b0111_1111;
+            const isBitMask = !!(raw.payload[1] & 0b1000_0000);
+            destination = raw.payload[1] & 0b0111_1111;
+            if (isBitMask) {
+                destination = parseBitMask(Bytes.from([destination]));
+            }
+        }
+        // No need to validate further, each CC does it for itself
+        const encapsulated = CommandClass.parse(raw.payload.subarray(2), ctx);
+        return new MultiChannelCCCommandEncapsulation_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            destination,
+            encapsulated,
+        });
+    }
+    encapsulated;
+    /** The destination end point (0-127) or an array of destination end points (1-7) */
+    destination;
+    serialize(ctx) {
+        if (ctx.getDeviceConfig?.(this.nodeId)?.compat
+            ?.treatDestinationEndpointAsSource) {
+            // This device incorrectly responds from the endpoint we've passed as our source endpoint
+            if (typeof this.destination === "number") {
+                this.endpointIndex = this.destination;
+            }
+        }
+        const destination = typeof this.destination === "number"
+            // The destination is a single number
+            ? this.destination & 0b0111_1111
+            // The destination is a bit mask
+            : encodeBitMask(this.destination, 7)[0] | 0b1000_0000;
+        this.payload = Bytes.concat([
+            Bytes.from([this.endpointIndex & 0b0111_1111, destination]),
+            this.encapsulated.serialize(ctx),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                source: this.endpointIndex,
+                destination: typeof this.destination === "number"
+                    ? this.destination
+                    : this.destination.join(", "),
+            },
+        };
+    }
+    computeEncapsulationOverhead() {
+        // Multi Channel CC adds two bytes for the source and destination endpoint
+        return super.computeEncapsulationOverhead() + 2;
+    }
+};
+MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = __decorate([
+    CCCommand(MultiChannelCommand.CommandEncapsulation),
+    expectedCCResponse(getCCResponseForCommandEncapsulation, testResponseForCommandEncapsulation)
+], MultiChannelCCCommandEncapsulation);
+export { MultiChannelCCCommandEncapsulation };
+let MultiChannelCCV1Report = MultiChannelCCV1Report_1 = class MultiChannelCCV1Report extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.requestedCC = options.requestedCC;
+        this.endpointCount = options.endpointCount;
+    }
+    static from(raw, ctx) {
+        // V1 won't be extended in the future, so do an exact check
+        validatePayload(raw.payload.length === 2);
+        const requestedCC = raw.payload[0];
+        const endpointCount = raw.payload[1];
+        return new MultiChannelCCV1Report_1({
+            nodeId: ctx.sourceNodeId,
+            requestedCC,
+            endpointCount,
+        });
+    }
+    requestedCC;
+    endpointCount;
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                CC: getCCName(this.requestedCC),
+                "# of endpoints": this.endpointCount,
+            },
+        };
+    }
+};
+MultiChannelCCV1Report = MultiChannelCCV1Report_1 = __decorate([
+    CCCommand(MultiChannelCommand.ReportV1)
+], MultiChannelCCV1Report);
+export { MultiChannelCCV1Report };
+function testResponseForMultiChannelV1Get(sent, received) {
+    return sent.requestedCC === received.requestedCC;
+}
+let MultiChannelCCV1Get = class MultiChannelCCV1Get extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.requestedCC = options.requestedCC;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new MultiChannelCCV1Get({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    requestedCC;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.requestedCC]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { CC: getCCName(this.requestedCC) },
+        };
+    }
+};
+MultiChannelCCV1Get = __decorate([
+    CCCommand(MultiChannelCommand.GetV1),
+    expectedCCResponse(MultiChannelCCV1Report, testResponseForMultiChannelV1Get)
+], MultiChannelCCV1Get);
+export { MultiChannelCCV1Get };
+function getResponseForV1CommandEncapsulation(sent) {
+    if (sent.encapsulated.expectsCCResponse()) {
+        return MultiChannelCCV1CommandEncapsulation;
+    }
+}
+function testResponseForV1CommandEncapsulation(sent, received) {
+    if (sent.endpointIndex === received.endpointIndex) {
+        return "checkEncapsulated";
+    }
+    return false;
+}
+let MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = class MultiChannelCCV1CommandEncapsulation extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.encapsulated = options.encapsulated;
+        // No need to distinguish between source and destination in V1
+        this.endpointIndex = this.encapsulated.endpointIndex;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const endpointIndex = raw.payload[0];
+        // Some devices send invalid reports, i.e. MultiChannelCCV1CommandEncapsulation, but with V2+ binary format
+        // This would be a NoOp CC, but it makes no sense to encapsulate that.
+        const isV2withV1Header = raw.payload.length >= 2
+            && raw.payload[1] === 0x00;
+        // No need to validate further, each CC does it for itself
+        const encapsulated = CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
+        return new MultiChannelCCV1CommandEncapsulation_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            encapsulated,
+        });
+    }
+    encapsulated;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.endpointIndex]),
+            this.encapsulated.serialize(ctx),
+        ]);
+        return super.serialize(ctx);
+    }
+    computeEncapsulationOverhead() {
+        // Multi Channel CC V1 adds one byte for the endpoint index
+        return super.computeEncapsulationOverhead() + 1;
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { source: this.endpointIndex },
+        };
+    }
+};
+MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = __decorate([
+    CCCommand(MultiChannelCommand.CommandEncapsulationV1),
+    expectedCCResponse(getResponseForV1CommandEncapsulation, testResponseForV1CommandEncapsulation)
+], MultiChannelCCV1CommandEncapsulation);
+export { MultiChannelCCV1CommandEncapsulation };
+//# sourceMappingURL=MultiChannelCC.js.map