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

package/build/esm/cc/EntryControlCC.js

@@ -1,10 +1,37 @@
-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 __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-var EntryControlCCNotification_1, EntryControlCCKeySupportedReport_1, EntryControlCCEventSupportedReport_1, EntryControlCCConfigurationReport_1;
 function __assertType(argName, typeName, boundHasError) {
     const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
     if (boundHasError()) {
@@ -22,7 +49,7 @@ import { Bytes } from "@zwave-js/shared/safe";
 import { buffer2hex, pick } from "@zwave-js/shared/safe";
 import { CCAPI, POLL_VALUE, SET_VALUE, throwUnsupportedProperty, throwWrongValueType, } from "../lib/API.js";
 import { CommandClass, } from "../lib/CommandClass.js";
-import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { API, CCCommand, ccValueProperty, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
 import { V } from "../lib/Values.js";
 import { EntryControlCommand, EntryControlDataTypes, EntryControlEventTypes, } from "../lib/_Types.js";
 import * as ccUtils from "../lib/utils.js";
@@ -54,528 +81,637 @@ export const EntryControlCCValues = Object.freeze({
         }),
     }),
 });
-let EntryControlCCAPI = class EntryControlCCAPI extends CCAPI {
-    supportsCommand(cmd) {
-        switch (cmd) {
-            case EntryControlCommand.KeySupportedGet:
-            case EntryControlCommand.EventSupportedGet:
-            case EntryControlCommand.ConfigurationGet:
-                return this.isSinglecast();
-            case EntryControlCommand.ConfigurationSet:
-                return true;
-        }
-        return super.supportsCommand(cmd);
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    async getSupportedKeys() {
-        this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.KeySupportedGet);
-        const cc = new EntryControlCCKeySupportedGet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        return response?.supportedKeys;
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    async getEventCapabilities() {
-        this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.EventSupportedGet);
-        const cc = new EntryControlCCEventSupportedGet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        if (response) {
-            return pick(response, [
-                "supportedDataTypes",
-                "supportedEventTypes",
-                "minKeyCacheSize",
-                "maxKeyCacheSize",
-                "minKeyCacheTimeout",
-                "maxKeyCacheTimeout",
-            ]);
+let EntryControlCCAPI = (() => {
+    let _classDecorators = [API(CommandClasses["Entry Control"])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CCAPI;
+    var EntryControlCCAPI = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCAPI = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    async getConfiguration() {
-        this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.ConfigurationGet);
-        const cc = new EntryControlCCConfigurationGet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-        });
-        const response = await this.host.sendCommand(cc, this.commandOptions);
-        if (response) {
-            return pick(response, ["keyCacheSize", "keyCacheTimeout"]);
+        supportsCommand(cmd) {
+            switch (cmd) {
+                case EntryControlCommand.KeySupportedGet:
+                case EntryControlCommand.EventSupportedGet:
+                case EntryControlCommand.ConfigurationGet:
+                    return this.isSinglecast();
+                case EntryControlCommand.ConfigurationSet:
+                    return true;
+            }
+            return super.supportsCommand(cmd);
         }
-    }
-    async setConfiguration(keyCacheSize, keyCacheTimeout) {
-        __assertType("keyCacheSize", "number", __assertType__number.bind(void 0, keyCacheSize));
-        __assertType("keyCacheTimeout", "number", __assertType__number.bind(void 0, keyCacheTimeout));
-        this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.ConfigurationGet);
-        const cc = new EntryControlCCConfigurationSet({
-            nodeId: this.endpoint.nodeId,
-            endpointIndex: this.endpoint.index,
-            keyCacheSize,
-            keyCacheTimeout,
-        });
-        return this.host.sendCommand(cc, this.commandOptions);
-    }
-    get [SET_VALUE]() {
-        return async function ({ property }, value) {
-            if (property !== "keyCacheSize" && property !== "keyCacheTimeout") {
-                throwUnsupportedProperty(this.ccId, property);
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async getSupportedKeys() {
+            this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.KeySupportedGet);
+            const cc = new EntryControlCCKeySupportedGet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+            });
+            const response = await this.host.sendCommand(cc, this.commandOptions);
+            return response?.supportedKeys;
+        }
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async getEventCapabilities() {
+            this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.EventSupportedGet);
+            const cc = new EntryControlCCEventSupportedGet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+            });
+            const response = await this.host.sendCommand(cc, this.commandOptions);
+            if (response) {
+                return pick(response, [
+                    "supportedDataTypes",
+                    "supportedEventTypes",
+                    "minKeyCacheSize",
+                    "maxKeyCacheSize",
+                    "minKeyCacheTimeout",
+                    "maxKeyCacheTimeout",
+                ]);
             }
-            if (typeof value !== "number") {
-                throwWrongValueType(this.ccId, property, "number", typeof value);
+        }
+        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+        async getConfiguration() {
+            this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.ConfigurationGet);
+            const cc = new EntryControlCCConfigurationGet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+            });
+            const response = await this.host.sendCommand(cc, this.commandOptions);
+            if (response) {
+                return pick(response, ["keyCacheSize", "keyCacheTimeout"]);
             }
-            let keyCacheSize = value;
-            let keyCacheTimeout = 2;
-            if (property === "keyCacheTimeout") {
-                keyCacheTimeout = value;
-                const oldKeyCacheSize = this.tryGetValueDB()?.getValue(EntryControlCCValues.keyCacheSize.endpoint(this.endpoint.index));
-                if (oldKeyCacheSize == undefined) {
-                    throw new ZWaveError(`The "keyCacheTimeout" property cannot be changed before the key cache size is known!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        async setConfiguration(keyCacheSize, keyCacheTimeout) {
+            __assertType("keyCacheSize", "number", __assertType__number.bind(void 0, keyCacheSize));
+            __assertType("keyCacheTimeout", "number", __assertType__number.bind(void 0, keyCacheTimeout));
+            this.assertSupportsCommand(EntryControlCommand, EntryControlCommand.ConfigurationGet);
+            const cc = new EntryControlCCConfigurationSet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                keyCacheSize,
+                keyCacheTimeout,
+            });
+            return this.host.sendCommand(cc, this.commandOptions);
+        }
+        get [SET_VALUE]() {
+            return async function ({ property }, value) {
+                if (property !== "keyCacheSize" && property !== "keyCacheTimeout") {
+                    throwUnsupportedProperty(this.ccId, property);
                 }
-                keyCacheSize = oldKeyCacheSize;
-            }
-            const result = await this.setConfiguration(keyCacheSize, keyCacheTimeout);
-            // Verify the change after a short delay, unless the command was supervised and successful
-            if (this.isSinglecast() && !supervisedCommandSucceeded(result)) {
-                this.schedulePoll({ property }, value, { transition: "fast" });
-            }
-            return result;
-        };
-    }
-    get [POLL_VALUE]() {
-        return async function ({ property }) {
-            switch (property) {
-                case "keyCacheSize":
-                case "keyCacheTimeout":
-                    return (await this.getConfiguration())?.[property];
-            }
-            throwUnsupportedProperty(this.ccId, property);
-        };
-    }
-};
-EntryControlCCAPI = __decorate([
-    API(CommandClasses["Entry Control"])
-], EntryControlCCAPI);
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                let keyCacheSize = value;
+                let keyCacheTimeout = 2;
+                if (property === "keyCacheTimeout") {
+                    keyCacheTimeout = value;
+                    const oldKeyCacheSize = this.tryGetValueDB()?.getValue(EntryControlCCValues.keyCacheSize.endpoint(this.endpoint.index));
+                    if (oldKeyCacheSize == undefined) {
+                        throw new ZWaveError(`The "keyCacheTimeout" property cannot be changed before the key cache size is known!`, ZWaveErrorCodes.Argument_Invalid);
+                    }
+                    keyCacheSize = oldKeyCacheSize;
+                }
+                const result = await this.setConfiguration(keyCacheSize, keyCacheTimeout);
+                // Verify the change after a short delay, unless the command was supervised and successful
+                if (this.isSinglecast() && !supervisedCommandSucceeded(result)) {
+                    this.schedulePoll({ property }, value, { transition: "fast" });
+                }
+                return result;
+            };
+        }
+        get [POLL_VALUE]() {
+            return async function ({ property }) {
+                switch (property) {
+                    case "keyCacheSize":
+                    case "keyCacheTimeout":
+                        return (await this.getConfiguration())?.[property];
+                }
+                throwUnsupportedProperty(this.ccId, property);
+            };
+        }
+    };
+    return EntryControlCCAPI = _classThis;
+})();
 export { EntryControlCCAPI };
-let EntryControlCC = class EntryControlCC extends CommandClass {
-    determineRequiredCCInterviews() {
-        return [
-            ...super.determineRequiredCCInterviews(),
-            CommandClasses.Association,
-            CommandClasses["Multi Channel Association"],
-            CommandClasses["Association Group Information"],
-        ];
-    }
-    async interview(ctx) {
-        const node = this.getNode(ctx);
-        const endpoint = this.getEndpoint(ctx);
-        const api = CCAPI.create(CommandClasses["Entry Control"], ctx, endpoint).withOptions({
-            priority: MessagePriority.NodeQuery,
-        });
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: `Interviewing ${this.ccName}...`,
-            direction: "none",
-        });
-        // If one Association group issues Entry Control notifications,
-        // we must associate ourselves with that channel
-        try {
-            await ccUtils.assignLifelineIssueingCommand(ctx, endpoint, this.ccId, EntryControlCommand.Notification);
-        }
-        catch {
+let EntryControlCC = (() => {
+    let _classDecorators = [commandClass(CommandClasses["Entry Control"]), implementedVersion(1), ccValues(EntryControlCCValues)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = CommandClass;
+    var EntryControlCC = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCC = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        determineRequiredCCInterviews() {
+            return [
+                ...super.determineRequiredCCInterviews(),
+                CommandClasses.Association,
+                CommandClasses["Multi Channel Association"],
+                CommandClasses["Association Group Information"],
+            ];
+        }
+        async interview(ctx) {
+            const node = this.getNode(ctx);
+            const endpoint = this.getEndpoint(ctx);
+            const api = CCAPI.create(CommandClasses["Entry Control"], ctx, endpoint).withOptions({
+                priority: MessagePriority.NodeQuery,
+            });
             ctx.logNode(node.id, {
-                endpoint: endpoint.index,
-                message: `Configuring associations to receive ${getCCName(this.ccId)} commands failed!`,
-                level: "warn",
+                endpoint: this.endpointIndex,
+                message: `Interviewing ${this.ccName}...`,
+                direction: "none",
             });
-        }
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: "requesting entry control supported keys...",
-            direction: "outbound",
-        });
-        const supportedKeys = await api.getSupportedKeys();
-        if (supportedKeys) {
+            // If one Association group issues Entry Control notifications,
+            // we must associate ourselves with that channel
+            try {
+                await ccUtils.assignLifelineIssueingCommand(ctx, endpoint, this.ccId, EntryControlCommand.Notification);
+            }
+            catch {
+                ctx.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Configuring associations to receive ${getCCName(this.ccId)} commands failed!`,
+                    level: "warn",
+                });
+            }
             ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
-                message: `received entry control supported keys: ${supportedKeys.toString()}`,
-                direction: "inbound",
+                message: "requesting entry control supported keys...",
+                direction: "outbound",
             });
-        }
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: "requesting entry control supported events...",
-            direction: "outbound",
-        });
-        const eventCapabilities = await api.getEventCapabilities();
-        if (eventCapabilities) {
+            const supportedKeys = await api.getSupportedKeys();
+            if (supportedKeys) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `received entry control supported keys: ${supportedKeys.toString()}`,
+                    direction: "inbound",
+                });
+            }
             ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
-                message: `received entry control supported keys:
+                message: "requesting entry control supported events...",
+                direction: "outbound",
+            });
+            const eventCapabilities = await api.getEventCapabilities();
+            if (eventCapabilities) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `received entry control supported keys:
 data types:            ${eventCapabilities.supportedDataTypes
-                    .map((e) => EntryControlDataTypes[e])
-                    .toString()}
+                        .map((e) => EntryControlDataTypes[e])
+                        .toString()}
 event types:           ${eventCapabilities.supportedEventTypes
-                    .map((e) => EntryControlEventTypes[e])
-                    .toString()}
+                        .map((e) => EntryControlEventTypes[e])
+                        .toString()}
 min key cache size:    ${eventCapabilities.minKeyCacheSize}
 max key cache size:    ${eventCapabilities.maxKeyCacheSize}
 min key cache timeout: ${eventCapabilities.minKeyCacheTimeout} seconds
 max key cache timeout: ${eventCapabilities.maxKeyCacheTimeout} seconds`,
-                direction: "inbound",
-            });
+                    direction: "inbound",
+                });
+            }
+            await this.refreshValues(ctx);
+            // Remember that the interview is complete
+            this.setInterviewComplete(ctx, true);
         }
-        await this.refreshValues(ctx);
-        // Remember that the interview is complete
-        this.setInterviewComplete(ctx, true);
-    }
-    async refreshValues(ctx) {
-        const node = this.getNode(ctx);
-        const endpoint = this.getEndpoint(ctx);
-        const api = CCAPI.create(CommandClasses["Entry Control"], ctx, endpoint).withOptions({
-            priority: MessagePriority.NodeQuery,
-        });
-        ctx.logNode(node.id, {
-            endpoint: this.endpointIndex,
-            message: "requesting entry control configuration...",
-            direction: "outbound",
-        });
-        const conf = await api.getConfiguration();
-        if (conf) {
+        async refreshValues(ctx) {
+            const node = this.getNode(ctx);
+            const endpoint = this.getEndpoint(ctx);
+            const api = CCAPI.create(CommandClasses["Entry Control"], ctx, endpoint).withOptions({
+                priority: MessagePriority.NodeQuery,
+            });
             ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
-                message: `received entry control configuration:
+                message: "requesting entry control configuration...",
+                direction: "outbound",
+            });
+            const conf = await api.getConfiguration();
+            if (conf) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: `received entry control configuration:
 key cache size:    ${conf.keyCacheSize}
 key cache timeout: ${conf.keyCacheTimeout} seconds`,
-                direction: "inbound",
-            });
+                    direction: "inbound",
+                });
+            }
         }
-    }
-};
-EntryControlCC = __decorate([
-    commandClass(CommandClasses["Entry Control"]),
-    implementedVersion(1),
-    ccValues(EntryControlCCValues)
-], EntryControlCC);
+    };
+    return EntryControlCC = _classThis;
+})();
 export { EntryControlCC };
-let EntryControlCCNotification = EntryControlCCNotification_1 = class EntryControlCCNotification extends EntryControlCC {
-    constructor(options) {
-        super(options);
-        // TODO: Check implementation:
-        this.sequenceNumber = options.sequenceNumber;
-        this.dataType = options.dataType;
-        this.eventType = options.eventType;
-        this.eventData = options.eventData;
-    }
-    static from(raw, ctx) {
-        validatePayload(raw.payload.length >= 4);
-        const sequenceNumber = raw.payload[0];
-        let dataType = raw.payload[1] & 0b11;
-        const eventType = raw.payload[2];
-        const eventDataLength = raw.payload[3];
-        validatePayload(eventDataLength >= 0 && eventDataLength <= 32);
-        const offset = 4;
-        validatePayload(raw.payload.length >= offset + eventDataLength);
-        let eventData;
-        if (eventDataLength > 0) {
-            // We shouldn't need to check this, since the specs are pretty clear which format to expect.
-            // But as always - manufacturers don't care and send ASCII data with 0 bytes...
-            // We also need to disable the strict validation for some devices to make them work
-            const noStrictValidation = !!ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.disableStrictEntryControlDataValidation;
-            eventData = Bytes.from(raw.payload.subarray(offset, offset + eventDataLength));
-            switch (dataType) {
-                case EntryControlDataTypes.Raw:
-                    // RAW 1 to 32 bytes of arbitrary binary data
-                    if (!noStrictValidation) {
-                        validatePayload(eventDataLength >= 1 && eventDataLength <= 32);
-                    }
-                    break;
-                case EntryControlDataTypes.ASCII:
-                    // ASCII 1 to 32 ASCII encoded characters. ASCII codes MUST be in the value range 0x00-0xF7.
-                    // The string MUST be padded with the value 0xFF to fit 16 byte blocks when sent in a notification.
-                    if (!noStrictValidation) {
-                        validatePayload(eventDataLength === 16 || eventDataLength === 32);
-                    }
-                    eventData = eventData.toString("ascii");
-                    if (!noStrictValidation) {
-                        validatePayload(/^[\u0000-\u007f]+[\u00ff]*$/.test(eventData));
-                    }
-                    // Trim 0xff padding bytes
-                    eventData = eventData.replace(/[\u00ff]*$/, "");
-                    break;
-                case EntryControlDataTypes.MD5:
-                    // MD5 16 byte binary data encoded as a MD5 hash value.
-                    if (!noStrictValidation) {
-                        validatePayload(eventDataLength === 16);
-                    }
-                    break;
-            }
+let EntryControlCCNotification = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.Notification)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCNotification = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCNotification = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-        else {
-            dataType = EntryControlDataTypes.None;
+        constructor(options) {
+            super(options);
+            // TODO: Check implementation:
+            this.sequenceNumber = options.sequenceNumber;
+            this.dataType = options.dataType;
+            this.eventType = options.eventType;
+            this.eventData = options.eventData;
         }
-        return new EntryControlCCNotification_1({
-            nodeId: ctx.sourceNodeId,
-            sequenceNumber,
-            dataType,
-            eventType,
-            eventData,
-        });
-    }
-    sequenceNumber;
-    dataType;
-    eventType;
-    eventData;
-    toLogEntry(ctx) {
-        const message = {
-            "sequence number": this.sequenceNumber,
-            "data type": this.dataType,
-            "event type": this.eventType,
-        };
-        if (this.eventData) {
-            switch (this.eventType) {
-                case EntryControlEventTypes.CachedKeys:
-                case EntryControlEventTypes.Enter:
-                    // The event data is likely the user's PIN code, hide it from logs
-                    message["event data"] = "*".repeat(this.eventData.length);
-                    break;
-                default:
-                    message["event data"] = typeof this.eventData === "string"
-                        ? this.eventData
-                        : buffer2hex(this.eventData);
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 4);
+            const sequenceNumber = raw.payload[0];
+            let dataType = raw.payload[1] & 0b11;
+            const eventType = raw.payload[2];
+            const eventDataLength = raw.payload[3];
+            validatePayload(eventDataLength >= 0 && eventDataLength <= 32);
+            const offset = 4;
+            validatePayload(raw.payload.length >= offset + eventDataLength);
+            let eventData;
+            if (eventDataLength > 0) {
+                // We shouldn't need to check this, since the specs are pretty clear which format to expect.
+                // But as always - manufacturers don't care and send ASCII data with 0 bytes...
+                // We also need to disable the strict validation for some devices to make them work
+                const noStrictValidation = !!ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.disableStrictEntryControlDataValidation;
+                eventData = Bytes.from(raw.payload.subarray(offset, offset + eventDataLength));
+                switch (dataType) {
+                    case EntryControlDataTypes.Raw:
+                        // RAW 1 to 32 bytes of arbitrary binary data
+                        if (!noStrictValidation) {
+                            validatePayload(eventDataLength >= 1 && eventDataLength <= 32);
+                        }
+                        break;
+                    case EntryControlDataTypes.ASCII:
+                        // ASCII 1 to 32 ASCII encoded characters. ASCII codes MUST be in the value range 0x00-0xF7.
+                        // The string MUST be padded with the value 0xFF to fit 16 byte blocks when sent in a notification.
+                        if (!noStrictValidation) {
+                            validatePayload(eventDataLength === 16 || eventDataLength === 32);
+                        }
+                        eventData = eventData.toString("ascii");
+                        if (!noStrictValidation) {
+                            validatePayload(/^[\u0000-\u007f]+[\u00ff]*$/.test(eventData));
+                        }
+                        // Trim 0xff padding bytes
+                        eventData = eventData.replace(/[\u00ff]*$/, "");
+                        break;
+                    case EntryControlDataTypes.MD5:
+                        // MD5 16 byte binary data encoded as a MD5 hash value.
+                        if (!noStrictValidation) {
+                            validatePayload(eventDataLength === 16);
+                        }
+                        break;
+                }
             }
+            else {
+                dataType = EntryControlDataTypes.None;
+            }
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                sequenceNumber,
+                dataType,
+                eventType,
+                eventData,
+            });
         }
-        return {
-            ...super.toLogEntry(ctx),
-            message,
-        };
-    }
-};
-EntryControlCCNotification = EntryControlCCNotification_1 = __decorate([
-    CCCommand(EntryControlCommand.Notification)
-], EntryControlCCNotification);
+        sequenceNumber;
+        dataType;
+        eventType;
+        eventData;
+        toLogEntry(ctx) {
+            const message = {
+                "sequence number": this.sequenceNumber,
+                "data type": this.dataType,
+                "event type": this.eventType,
+            };
+            if (this.eventData) {
+                switch (this.eventType) {
+                    case EntryControlEventTypes.CachedKeys:
+                    case EntryControlEventTypes.Enter:
+                        // The event data is likely the user's PIN code, hide it from logs
+                        message["event data"] = "*".repeat(this.eventData.length);
+                        break;
+                    default:
+                        message["event data"] = typeof this.eventData === "string"
+                            ? this.eventData
+                            : buffer2hex(this.eventData);
+                }
+            }
+            return {
+                ...super.toLogEntry(ctx),
+                message,
+            };
+        }
+    };
+    return EntryControlCCNotification = _classThis;
+})();
 export { EntryControlCCNotification };
-let EntryControlCCKeySupportedReport = EntryControlCCKeySupportedReport_1 = class EntryControlCCKeySupportedReport extends EntryControlCC {
-    constructor(options) {
-        super(options);
-        // TODO: Check implementation:
-        this.supportedKeys = options.supportedKeys;
-    }
-    static from(raw, ctx) {
-        validatePayload(raw.payload.length >= 1);
-        const length = raw.payload[0];
-        validatePayload(raw.payload.length >= 1 + length);
-        const supportedKeys = parseBitMask(raw.payload.subarray(1, 1 + length), 0);
-        return new EntryControlCCKeySupportedReport_1({
-            nodeId: ctx.sourceNodeId,
-            supportedKeys,
-        });
-    }
-    supportedKeys;
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: { "supported keys": this.supportedKeys.toString() },
-        };
-    }
-};
-__decorate([
-    ccValue(EntryControlCCValues.supportedKeys)
-], EntryControlCCKeySupportedReport.prototype, "supportedKeys", void 0);
-EntryControlCCKeySupportedReport = EntryControlCCKeySupportedReport_1 = __decorate([
-    CCCommand(EntryControlCommand.KeySupportedReport)
-], EntryControlCCKeySupportedReport);
+let EntryControlCCKeySupportedReport = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.KeySupportedReport), ccValueProperty("supportedKeys", EntryControlCCValues.supportedKeys)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCKeySupportedReport = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCKeySupportedReport = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            // TODO: Check implementation:
+            this.supportedKeys = options.supportedKeys;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const length = raw.payload[0];
+            validatePayload(raw.payload.length >= 1 + length);
+            const supportedKeys = parseBitMask(raw.payload.subarray(1, 1 + length), 0);
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                supportedKeys,
+            });
+        }
+        supportedKeys;
+        toLogEntry(ctx) {
+            return {
+                ...super.toLogEntry(ctx),
+                message: { "supported keys": this.supportedKeys.toString() },
+            };
+        }
+    };
+    return EntryControlCCKeySupportedReport = _classThis;
+})();
 export { EntryControlCCKeySupportedReport };
-let EntryControlCCKeySupportedGet = class EntryControlCCKeySupportedGet extends EntryControlCC {
-};
-EntryControlCCKeySupportedGet = __decorate([
-    CCCommand(EntryControlCommand.KeySupportedGet),
-    expectedCCResponse(EntryControlCCKeySupportedReport)
-], EntryControlCCKeySupportedGet);
+let EntryControlCCKeySupportedGet = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.KeySupportedGet), expectedCCResponse(EntryControlCCKeySupportedReport)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCKeySupportedGet = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCKeySupportedGet = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return EntryControlCCKeySupportedGet = _classThis;
+})();
 export { EntryControlCCKeySupportedGet };
-let EntryControlCCEventSupportedReport = EntryControlCCEventSupportedReport_1 = class EntryControlCCEventSupportedReport extends EntryControlCC {
-    constructor(options) {
-        super(options);
-        // TODO: Check implementation:
-        this.supportedDataTypes = options.supportedDataTypes;
-        this.supportedEventTypes = options.supportedEventTypes;
-        this.minKeyCacheSize = options.minKeyCacheSize;
-        this.maxKeyCacheSize = options.maxKeyCacheSize;
-        this.minKeyCacheTimeout = options.minKeyCacheTimeout;
-        this.maxKeyCacheTimeout = options.maxKeyCacheTimeout;
-    }
-    static from(raw, ctx) {
-        validatePayload(raw.payload.length >= 1);
-        const dataTypeLength = raw.payload[0] & 0b11;
-        let offset = 1;
-        validatePayload(raw.payload.length >= offset + dataTypeLength);
-        const supportedDataTypes = parseBitMask(raw.payload.subarray(offset, offset + dataTypeLength), EntryControlDataTypes.None);
-        offset += dataTypeLength;
-        validatePayload(raw.payload.length >= offset + 1);
-        const eventTypeLength = raw.payload[offset] & 0b11111;
-        offset += 1;
-        validatePayload(raw.payload.length >= offset + eventTypeLength);
-        const supportedEventTypes = parseBitMask(raw.payload.subarray(offset, offset + eventTypeLength), EntryControlEventTypes.Caching);
-        offset += eventTypeLength;
-        validatePayload(raw.payload.length >= offset + 4);
-        const minKeyCacheSize = raw.payload[offset];
-        validatePayload(minKeyCacheSize >= 1 && minKeyCacheSize <= 32);
-        const maxKeyCacheSize = raw.payload[offset + 1];
-        validatePayload(maxKeyCacheSize >= minKeyCacheSize
-            && maxKeyCacheSize <= 32);
-        const minKeyCacheTimeout = raw.payload[offset + 2];
-        const maxKeyCacheTimeout = raw.payload[offset + 3];
-        return new EntryControlCCEventSupportedReport_1({
-            nodeId: ctx.sourceNodeId,
-            supportedDataTypes,
-            supportedEventTypes,
-            minKeyCacheSize,
-            maxKeyCacheSize,
-            minKeyCacheTimeout,
-            maxKeyCacheTimeout,
-        });
-    }
-    persistValues(ctx) {
-        if (!super.persistValues(ctx))
-            return false;
-        // Store min/max cache size and timeout as metadata
-        const keyCacheSizeValue = EntryControlCCValues.keyCacheSize;
-        this.setMetadata(ctx, keyCacheSizeValue, {
-            ...keyCacheSizeValue.meta,
-            min: this.minKeyCacheSize,
-            max: this.maxKeyCacheSize,
-        });
-        const keyCacheTimeoutValue = EntryControlCCValues.keyCacheTimeout;
-        this.setMetadata(ctx, keyCacheTimeoutValue, {
-            ...keyCacheTimeoutValue.meta,
-            min: this.minKeyCacheTimeout,
-            max: this.maxKeyCacheTimeout,
-        });
-        return true;
-    }
-    supportedDataTypes;
-    supportedEventTypes;
-    minKeyCacheSize;
-    maxKeyCacheSize;
-    minKeyCacheTimeout;
-    maxKeyCacheTimeout;
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "supported data types": this.supportedDataTypes
-                    .map((dt) => EntryControlDataTypes[dt])
-                    .toString(),
-                "supported event types": this.supportedEventTypes
-                    .map((et) => EntryControlEventTypes[et])
-                    .toString(),
-                "min key cache size": this.minKeyCacheSize,
-                "max key cache size": this.maxKeyCacheSize,
-                "min key cache timeout": this.minKeyCacheTimeout,
-                "max key cache timeout": this.maxKeyCacheTimeout,
-            },
-        };
-    }
-};
-__decorate([
-    ccValue(EntryControlCCValues.supportedDataTypes)
-], EntryControlCCEventSupportedReport.prototype, "supportedDataTypes", void 0);
-__decorate([
-    ccValue(EntryControlCCValues.supportedEventTypes)
-], EntryControlCCEventSupportedReport.prototype, "supportedEventTypes", void 0);
-EntryControlCCEventSupportedReport = EntryControlCCEventSupportedReport_1 = __decorate([
-    CCCommand(EntryControlCommand.EventSupportedReport)
-], EntryControlCCEventSupportedReport);
+let EntryControlCCEventSupportedReport = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.EventSupportedReport), ccValueProperty("supportedDataTypes", EntryControlCCValues.supportedDataTypes), ccValueProperty("supportedEventTypes", EntryControlCCValues.supportedEventTypes)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCEventSupportedReport = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCEventSupportedReport = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            // TODO: Check implementation:
+            this.supportedDataTypes = options.supportedDataTypes;
+            this.supportedEventTypes = options.supportedEventTypes;
+            this.minKeyCacheSize = options.minKeyCacheSize;
+            this.maxKeyCacheSize = options.maxKeyCacheSize;
+            this.minKeyCacheTimeout = options.minKeyCacheTimeout;
+            this.maxKeyCacheTimeout = options.maxKeyCacheTimeout;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 1);
+            const dataTypeLength = raw.payload[0] & 0b11;
+            let offset = 1;
+            validatePayload(raw.payload.length >= offset + dataTypeLength);
+            const supportedDataTypes = parseBitMask(raw.payload.subarray(offset, offset + dataTypeLength), EntryControlDataTypes.None);
+            offset += dataTypeLength;
+            validatePayload(raw.payload.length >= offset + 1);
+            const eventTypeLength = raw.payload[offset] & 0b11111;
+            offset += 1;
+            validatePayload(raw.payload.length >= offset + eventTypeLength);
+            const supportedEventTypes = parseBitMask(raw.payload.subarray(offset, offset + eventTypeLength), EntryControlEventTypes.Caching);
+            offset += eventTypeLength;
+            validatePayload(raw.payload.length >= offset + 4);
+            const minKeyCacheSize = raw.payload[offset];
+            validatePayload(minKeyCacheSize >= 1 && minKeyCacheSize <= 32);
+            const maxKeyCacheSize = raw.payload[offset + 1];
+            validatePayload(maxKeyCacheSize >= minKeyCacheSize
+                && maxKeyCacheSize <= 32);
+            const minKeyCacheTimeout = raw.payload[offset + 2];
+            const maxKeyCacheTimeout = raw.payload[offset + 3];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                supportedDataTypes,
+                supportedEventTypes,
+                minKeyCacheSize,
+                maxKeyCacheSize,
+                minKeyCacheTimeout,
+                maxKeyCacheTimeout,
+            });
+        }
+        persistValues(ctx) {
+            if (!super.persistValues(ctx))
+                return false;
+            // Store min/max cache size and timeout as metadata
+            const keyCacheSizeValue = EntryControlCCValues.keyCacheSize;
+            this.setMetadata(ctx, keyCacheSizeValue, {
+                ...keyCacheSizeValue.meta,
+                min: this.minKeyCacheSize,
+                max: this.maxKeyCacheSize,
+            });
+            const keyCacheTimeoutValue = EntryControlCCValues.keyCacheTimeout;
+            this.setMetadata(ctx, keyCacheTimeoutValue, {
+                ...keyCacheTimeoutValue.meta,
+                min: this.minKeyCacheTimeout,
+                max: this.maxKeyCacheTimeout,
+            });
+            return true;
+        }
+        supportedDataTypes;
+        supportedEventTypes;
+        minKeyCacheSize;
+        maxKeyCacheSize;
+        minKeyCacheTimeout;
+        maxKeyCacheTimeout;
+        toLogEntry(ctx) {
+            return {
+                ...super.toLogEntry(ctx),
+                message: {
+                    "supported data types": this.supportedDataTypes
+                        .map((dt) => EntryControlDataTypes[dt])
+                        .toString(),
+                    "supported event types": this.supportedEventTypes
+                        .map((et) => EntryControlEventTypes[et])
+                        .toString(),
+                    "min key cache size": this.minKeyCacheSize,
+                    "max key cache size": this.maxKeyCacheSize,
+                    "min key cache timeout": this.minKeyCacheTimeout,
+                    "max key cache timeout": this.maxKeyCacheTimeout,
+                },
+            };
+        }
+    };
+    return EntryControlCCEventSupportedReport = _classThis;
+})();
 export { EntryControlCCEventSupportedReport };
-let EntryControlCCEventSupportedGet = class EntryControlCCEventSupportedGet extends EntryControlCC {
-};
-EntryControlCCEventSupportedGet = __decorate([
-    CCCommand(EntryControlCommand.EventSupportedGet),
-    expectedCCResponse(EntryControlCCEventSupportedReport)
-], EntryControlCCEventSupportedGet);
+let EntryControlCCEventSupportedGet = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.EventSupportedGet), expectedCCResponse(EntryControlCCEventSupportedReport)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCEventSupportedGet = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCEventSupportedGet = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return EntryControlCCEventSupportedGet = _classThis;
+})();
 export { EntryControlCCEventSupportedGet };
-let EntryControlCCConfigurationReport = EntryControlCCConfigurationReport_1 = class EntryControlCCConfigurationReport extends EntryControlCC {
-    constructor(options) {
-        super(options);
-        // TODO: Check implementation:
-        this.keyCacheSize = options.keyCacheSize;
-        this.keyCacheTimeout = options.keyCacheTimeout;
-    }
-    static from(raw, ctx) {
-        validatePayload(raw.payload.length >= 2);
-        const keyCacheSize = raw.payload[0];
-        validatePayload(keyCacheSize >= 1 && keyCacheSize <= 32);
-        const keyCacheTimeout = raw.payload[1];
-        return new EntryControlCCConfigurationReport_1({
-            nodeId: ctx.sourceNodeId,
-            keyCacheSize,
-            keyCacheTimeout,
-        });
-    }
-    keyCacheSize;
-    keyCacheTimeout;
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "key cache size": this.keyCacheSize,
-                "key cache timeout": this.keyCacheTimeout,
-            },
-        };
-    }
-};
-__decorate([
-    ccValue(EntryControlCCValues.keyCacheSize)
-], EntryControlCCConfigurationReport.prototype, "keyCacheSize", void 0);
-__decorate([
-    ccValue(EntryControlCCValues.keyCacheTimeout)
-], EntryControlCCConfigurationReport.prototype, "keyCacheTimeout", void 0);
-EntryControlCCConfigurationReport = EntryControlCCConfigurationReport_1 = __decorate([
-    CCCommand(EntryControlCommand.ConfigurationReport)
-], EntryControlCCConfigurationReport);
+let EntryControlCCConfigurationReport = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.ConfigurationReport), ccValueProperty("keyCacheSize", EntryControlCCValues.keyCacheSize), ccValueProperty("keyCacheTimeout", EntryControlCCValues.keyCacheTimeout)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCConfigurationReport = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCConfigurationReport = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            // TODO: Check implementation:
+            this.keyCacheSize = options.keyCacheSize;
+            this.keyCacheTimeout = options.keyCacheTimeout;
+        }
+        static from(raw, ctx) {
+            validatePayload(raw.payload.length >= 2);
+            const keyCacheSize = raw.payload[0];
+            validatePayload(keyCacheSize >= 1 && keyCacheSize <= 32);
+            const keyCacheTimeout = raw.payload[1];
+            return new this({
+                nodeId: ctx.sourceNodeId,
+                keyCacheSize,
+                keyCacheTimeout,
+            });
+        }
+        keyCacheSize;
+        keyCacheTimeout;
+        toLogEntry(ctx) {
+            return {
+                ...super.toLogEntry(ctx),
+                message: {
+                    "key cache size": this.keyCacheSize,
+                    "key cache timeout": this.keyCacheTimeout,
+                },
+            };
+        }
+    };
+    return EntryControlCCConfigurationReport = _classThis;
+})();
 export { EntryControlCCConfigurationReport };
-let EntryControlCCConfigurationGet = class EntryControlCCConfigurationGet extends EntryControlCC {
-};
-EntryControlCCConfigurationGet = __decorate([
-    CCCommand(EntryControlCommand.ConfigurationGet),
-    expectedCCResponse(EntryControlCCConfigurationReport)
-], EntryControlCCConfigurationGet);
+let EntryControlCCConfigurationGet = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.ConfigurationGet), expectedCCResponse(EntryControlCCConfigurationReport)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCConfigurationGet = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCConfigurationGet = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return EntryControlCCConfigurationGet = _classThis;
+})();
 export { EntryControlCCConfigurationGet };
-let EntryControlCCConfigurationSet = class EntryControlCCConfigurationSet extends EntryControlCC {
-    constructor(options) {
-        super(options);
-        this.keyCacheSize = options.keyCacheSize;
-        this.keyCacheTimeout = options.keyCacheTimeout;
-    }
-    static from(_raw, _ctx) {
-        // TODO: Deserialize payload
-        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
-        // return new EntryControlCCConfigurationSet({
-        // 	nodeId: ctx.sourceNodeId,
-        // });
-    }
-    keyCacheSize;
-    keyCacheTimeout;
-    serialize(ctx) {
-        this.payload = Bytes.from([this.keyCacheSize, this.keyCacheTimeout]);
-        return super.serialize(ctx);
-    }
-    toLogEntry(ctx) {
-        return {
-            ...super.toLogEntry(ctx),
-            message: {
-                "key cache size": this.keyCacheSize,
-                "key cache timeout": this.keyCacheTimeout,
-            },
-        };
-    }
-};
-EntryControlCCConfigurationSet = __decorate([
-    CCCommand(EntryControlCommand.ConfigurationSet),
-    useSupervision()
-], EntryControlCCConfigurationSet);
+let EntryControlCCConfigurationSet = (() => {
+    let _classDecorators = [CCCommand(EntryControlCommand.ConfigurationSet), useSupervision()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = EntryControlCC;
+    var EntryControlCCConfigurationSet = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            EntryControlCCConfigurationSet = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(options) {
+            super(options);
+            this.keyCacheSize = options.keyCacheSize;
+            this.keyCacheTimeout = options.keyCacheTimeout;
+        }
+        static from(_raw, _ctx) {
+            // TODO: Deserialize payload
+            throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+            // return new EntryControlCCConfigurationSet({
+            // 	nodeId: ctx.sourceNodeId,
+            // });
+        }
+        keyCacheSize;
+        keyCacheTimeout;
+        serialize(ctx) {
+            this.payload = Bytes.from([this.keyCacheSize, this.keyCacheTimeout]);
+            return super.serialize(ctx);
+        }
+        toLogEntry(ctx) {
+            return {
+                ...super.toLogEntry(ctx),
+                message: {
+                    "key cache size": this.keyCacheSize,
+                    "key cache timeout": this.keyCacheTimeout,
+                },
+            };
+        }
+    };
+    return EntryControlCCConfigurationSet = _classThis;
+})();
 export { EntryControlCCConfigurationSet };
 //# sourceMappingURL=EntryControlCC.js.map