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

package/build/esm/cc/UserCodeCC.js

@@ -0,0 +1,1695 @@
+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 UserCodeCC_1, UserCodeCCSet_1, UserCodeCCReport_1, UserCodeCCGet_1, UserCodeCCUsersNumberReport_1, UserCodeCCCapabilitiesReport_1, UserCodeCCKeypadModeSet_1, UserCodeCCKeypadModeReport_1, UserCodeCCAdminCodeSet_1, UserCodeCCAdminCodeReport_1, UserCodeCCUserCodeChecksumReport_1, UserCodeCCExtendedUserCodeReport_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);
+};
+const __assertType__optional_boolean = $o => {
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    function optional__boolean($o) {
+        if ($o !== undefined) {
+            const error = _boolean($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__boolean($o);
+};
+const __assertType__su__1__2__3__4_eu = $o => {
+    function _1($o) {
+        return $o !== 1 ? {} : null;
+    }
+    function _2($o) {
+        return $o !== 2 ? {} : null;
+    }
+    function _3($o) {
+        return $o !== 3 ? {} : null;
+    }
+    function _4($o) {
+        return $o !== 4 ? {} : null;
+    }
+    function su__1__2__3__4_eu($o) {
+        const conditions = [_1, _2, _3, _4];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__1__2__3__4_eu($o);
+};
+const __assertType__su__string__uint8array_eu = $o => {
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _uint8array($o) {
+        return !require("@zwave-js/shared/safe").isUint8Array($o) ? {} : null;
+    }
+    function su__string__uint8array_eu($o) {
+        const conditions = [_string, _uint8array];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su__string__uint8array_eu($o);
+};
+const __assertType__sa_su__3__4__5_eu_ea_2 = $o => {
+    function _6($o) {
+        return $o !== 0 ? {} : null;
+    }
+    function _7($o) {
+        return $o !== 0 ? {} : null;
+    }
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _3($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("userId" in $o && $o["userId"] !== undefined) {
+            const error = _6($o["userId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userIdStatus" in $o && $o["userIdStatus"] !== undefined) {
+            const error = _7($o["userIdStatus"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userCode" in $o && $o["userCode"] !== undefined) {
+            const error = _undefined($o["userCode"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _4($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("userId" in $o && $o["userId"] !== undefined) {
+            const error = _number($o["userId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userIdStatus" in $o && $o["userIdStatus"] !== undefined) {
+            const error = _7($o["userIdStatus"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userCode" in $o && $o["userCode"] !== undefined) {
+            const error = _undefined($o["userCode"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _9($o) {
+        return $o !== 1 ? {} : null;
+    }
+    function _10($o) {
+        return $o !== 2 ? {} : null;
+    }
+    function _11($o) {
+        return $o !== 3 ? {} : null;
+    }
+    function _12($o) {
+        return $o !== 4 ? {} : null;
+    }
+    function su__9__10__11__12_eu($o) {
+        const conditions = [_9, _10, _11, _12];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _uint8array($o) {
+        return !require("@zwave-js/shared/safe").isUint8Array($o) ? {} : null;
+    }
+    function su__string__uint8array_eu($o) {
+        const conditions = [_string, _uint8array];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _5($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("userId" in $o && $o["userId"] !== undefined) {
+            const error = _number($o["userId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userIdStatus" in $o && $o["userIdStatus"] !== undefined) {
+            const error = su__9__10__11__12_eu($o["userIdStatus"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("userCode" in $o && $o["userCode"] !== undefined) {
+            const error = su__string__uint8array_eu($o["userCode"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function su__3__4__5_eu($o) {
+        const conditions = [_3, _4, _5];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function sa_su__3__4__5_eu_ea_2($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = su__3__4__5_eu($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return sa_su__3__4__5_eu_ea_2($o);
+};
+const __assertType__optional_number = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function optional__number($o) {
+        if ($o !== undefined) {
+            const error = _number($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__number($o);
+};
+const __assertType__KeypadMode = $o => {
+    function su__1__2__3__4_eu($o) {
+        return ![0, 1, 2, 3].includes($o) ? {} : null;
+    }
+    return su__1__2__3__4_eu($o);
+};
+const __assertType__string = $o => {
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    return _string($o);
+};
+import { CommandClasses, MessagePriority, ValueMetadata, ZWaveError, ZWaveErrorCodes, encodeBitMask, enumValuesToMetadataStates, parseBitMask, supervisedCommandSucceeded, validatePayload, } from "@zwave-js/core/safe";
+import { Bytes, isUint8Array, uint8ArrayToString } from "@zwave-js/shared/safe";
+import { getEnumMemberName, isPrintableASCII, isPrintableASCIIWithWhitespace, num2hex, pick, } from "@zwave-js/shared/safe";
+import { CCAPI, POLL_VALUE, PhysicalCCAPI, SET_VALUE, throwMissingPropertyKey, throwUnsupportedProperty, throwUnsupportedPropertyKey, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { KeypadMode, UserCodeCommand, UserIDStatus } from "../lib/_Types.js";
+export const UserCodeCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["User Code"], {
+        ...V.staticProperty("supportedUsers", undefined, { internal: true }),
+        ...V.staticProperty("supportsAdminCode", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsAdminCodeDeactivation", undefined, {
+            internal: true,
+        }),
+        // The following two properties are only kept for compatibility with devices
+        // that were interviewed before the rename to admin code
+        ...V.staticPropertyWithName("_deprecated_supportsMasterCode", "supportsMasterCode", undefined, {
+            internal: true,
+        }),
+        ...V.staticPropertyWithName("_deprecated_supportsMasterCodeDeactivation", "supportsMasterCodeDeactivation", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsUserCodeChecksum", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsMultipleUserCodeReport", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsMultipleUserCodeSet", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportedUserIDStatuses", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportedKeypadModes", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportedASCIIChars", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("userCodeChecksum", undefined, { internal: true }),
+        ...V.staticProperty("keypadMode", {
+            ...ValueMetadata.ReadOnlyNumber,
+            label: "Keypad Mode",
+        }, { minVersion: 2 }),
+        ...V.staticProperty("adminCode", {
+            ...ValueMetadata.String,
+            label: "Admin Code",
+            minLength: 4,
+            maxLength: 10,
+        }, {
+            minVersion: 2,
+            secret: true,
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["User Code"], {
+        ...V.dynamicPropertyAndKeyWithName("userIdStatus", "userIdStatus", (userId) => userId, ({ property, propertyKey }) => property === "userIdStatus" && typeof propertyKey === "number", (userId) => ({
+            ...ValueMetadata.Number,
+            label: `User ID status (${userId})`,
+        })),
+        ...V.dynamicPropertyAndKeyWithName("userCode", "userCode", (userId) => userId, ({ property, propertyKey }) => property === "userCode" && typeof propertyKey === "number", 
+        // The user code metadata is dynamically created
+        undefined, { secret: true }),
+    }),
+});
+function parseExtendedUserCode(payload) {
+    validatePayload(payload.length >= 4);
+    const userId = payload.readUInt16BE(0);
+    const status = payload[2];
+    const codeLength = payload[3] & 0b1111;
+    validatePayload(payload.length >= 4 + codeLength);
+    const code = payload.subarray(4, 4 + codeLength).toString("ascii");
+    return {
+        code: {
+            userId,
+            userIdStatus: status,
+            userCode: code,
+        },
+        bytesRead: 4 + codeLength,
+    };
+}
+function validateCode(code, supportedChars) {
+    if (code.length < 4 || code.length > 10)
+        return false;
+    return [...code].every((char) => supportedChars.includes(char));
+}
+function setUserCodeMetadata(ctx, userId, userCode) {
+    const statusValue = UserCodeCCValues.userIdStatus(userId);
+    const codeValue = UserCodeCCValues.userCode(userId);
+    const ccVersion = getEffectiveCCVersion(ctx, this);
+    const supportedUserIDStatuses = this.getValue(ctx, UserCodeCCValues.supportedUserIDStatuses)
+        ?? (ccVersion === 1
+            ? [
+                UserIDStatus.Available,
+                UserIDStatus.Enabled,
+                UserIDStatus.Disabled,
+            ]
+            : [
+                UserIDStatus.Available,
+                UserIDStatus.Enabled,
+                UserIDStatus.Disabled,
+                UserIDStatus.Messaging,
+                UserIDStatus.PassageMode,
+            ]);
+    this.ensureMetadata(ctx, statusValue, {
+        ...statusValue.meta,
+        states: enumValuesToMetadataStates(UserIDStatus, supportedUserIDStatuses),
+    });
+    const codeMetadata = {
+        ...(isUint8Array(userCode)
+            ? ValueMetadata.Buffer
+            : ValueMetadata.String),
+        minLength: 4,
+        maxLength: 10,
+        label: `User Code (${userId})`,
+    };
+    if (this.getMetadata(ctx, codeValue)?.type !== codeMetadata.type) {
+        this.setMetadata(ctx, codeValue, codeMetadata);
+    }
+}
+function persistUserCode(ctx, userId, userIdStatus, userCode) {
+    const statusValue = UserCodeCCValues.userIdStatus(userId);
+    const codeValue = UserCodeCCValues.userCode(userId);
+    // Check if this code is supported
+    if (userIdStatus === UserIDStatus.StatusNotAvailable) {
+        // It is not, remove all values if any exist
+        this.removeValue(ctx, statusValue);
+        this.removeValue(ctx, codeValue);
+        this.removeMetadata(ctx, statusValue);
+        this.removeMetadata(ctx, codeValue);
+    }
+    else {
+        // Always create metadata in case it does not exist
+        setUserCodeMetadata.call(this, ctx, userId, userCode);
+        this.setValue(ctx, statusValue, userIdStatus);
+        this.setValue(ctx, codeValue, userCode);
+    }
+    return true;
+}
+/** Formats a user code in a way that's safe to print in public logs */
+export function userCodeToLogString(userCode) {
+    if (userCode.length === 0)
+        return "(empty)";
+    return "*".repeat(userCode.length);
+}
+let UserCodeCCAPI = class UserCodeCCAPI extends PhysicalCCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case UserCodeCommand.Get:
+            case UserCodeCommand.Set:
+            case UserCodeCommand.UsersNumberGet:
+                return true; // This is mandatory
+            case UserCodeCommand.CapabilitiesGet:
+            case UserCodeCommand.KeypadModeSet:
+            case UserCodeCommand.KeypadModeGet:
+            case UserCodeCommand.ExtendedUserCodeSet:
+            case UserCodeCommand.ExtendedUserCodeGet:
+                return this.version >= 2;
+            case UserCodeCommand.AdminCodeSet:
+            case UserCodeCommand.AdminCodeGet: {
+                if (this.version < 2)
+                    return false;
+                return this.tryGetValueDB()?.getValue(UserCodeCCValues.supportsAdminCode.endpoint(this.endpoint.index));
+            }
+            case UserCodeCommand.UserCodeChecksumGet: {
+                if (this.version < 2)
+                    return false;
+                return this.tryGetValueDB()?.getValue(UserCodeCCValues.supportsUserCodeChecksum.endpoint(this.endpoint.index));
+            }
+        }
+        return super.supportsCommand(cmd);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property, propertyKey }, value) {
+            let result;
+            if (property === "keypadMode") {
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                result = await this.setKeypadMode(value);
+            }
+            else if (property === "adminCode"
+                // Support devices that were interviewed before the rename to adminCode
+                || property === "masterCode") {
+                if (typeof value !== "string") {
+                    throwWrongValueType(this.ccId, property, "string", typeof value);
+                }
+                result = await this.setAdminCode(value);
+            }
+            else if (property === "userIdStatus") {
+                if (propertyKey == undefined) {
+                    throwMissingPropertyKey(this.ccId, property);
+                }
+                else if (typeof propertyKey !== "number") {
+                    throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                }
+                if (typeof value !== "number") {
+                    throwWrongValueType(this.ccId, property, "number", typeof value);
+                }
+                if (value === UserIDStatus.Available) {
+                    // Clear Code
+                    result = await this.clear(propertyKey);
+                }
+                else {
+                    // We need to set the user code along with the status
+                    const userCode = this.getValueDB().getValue(UserCodeCCValues.userCode(propertyKey).endpoint(this.endpoint.index));
+                    result = await this.set(propertyKey, value, userCode);
+                }
+            }
+            else if (property === "userCode") {
+                if (propertyKey == undefined) {
+                    throwMissingPropertyKey(this.ccId, property);
+                }
+                else if (typeof propertyKey !== "number") {
+                    throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                }
+                if (typeof value !== "string" && !isUint8Array(value)) {
+                    throwWrongValueType(this.ccId, property, "string or Buffer", typeof value);
+                }
+                // We need to set the user id status along with the code
+                let userIdStatus = this.getValueDB().getValue(UserCodeCCValues.userIdStatus(propertyKey).endpoint(this.endpoint.index));
+                if (userIdStatus === UserIDStatus.Available
+                    || userIdStatus == undefined) {
+                    userIdStatus = UserIDStatus.Enabled;
+                }
+                result = await this.set(propertyKey, userIdStatus, value);
+            }
+            else {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+            // Verify the change after a short delay, unless the command was supervised and successful
+            if (this.isSinglecast() && !supervisedCommandSucceeded(result)) {
+                this.schedulePoll({ property, propertyKey }, value, {
+                    transition: "fast",
+                });
+            }
+            return result;
+        };
+    }
+    get [POLL_VALUE]() {
+        return async function ({ property, propertyKey }) {
+            switch (property) {
+                case "keypadMode":
+                    return this.getKeypadMode();
+                case "adminCode":
+                    return this.getAdminCode();
+                case "userIdStatus":
+                case "userCode": {
+                    if (propertyKey == undefined) {
+                        throwMissingPropertyKey(this.ccId, property);
+                    }
+                    else if (typeof propertyKey !== "number") {
+                        throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                    }
+                    return (await this.get(propertyKey))?.[property];
+                }
+                default:
+                    throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    async getUsersCount() {
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.UsersNumberGet);
+        const cc = new UserCodeCCUsersNumberGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.supportedUsers;
+    }
+    async get(userId, multiple = false) {
+        __assertType("userId", "number", __assertType__number.bind(void 0, userId));
+        __assertType("multiple", "(optional) boolean", __assertType__optional_boolean.bind(void 0, multiple));
+        if (userId > 255 || multiple) {
+            this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.ExtendedUserCodeGet);
+            const cc = new UserCodeCCExtendedUserCodeGet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                userId,
+                reportMore: multiple,
+            });
+            const response = await this.host.sendCommand(cc, this.commandOptions);
+            if (!response) {
+                return;
+            }
+            else if (multiple) {
+                return pick(response, ["userCodes", "nextUserId"]);
+            }
+            else {
+                return pick(response.userCodes[0], [
+                    "userIdStatus",
+                    "userCode",
+                ]);
+            }
+        }
+        else {
+            this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.Get);
+            const cc = new UserCodeCCGet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                userId,
+            });
+            const response = await this.host.sendCommand(cc, this.commandOptions);
+            if (response)
+                return pick(response, ["userIdStatus", "userCode"]);
+        }
+    }
+    /** Configures a single user code */
+    async set(userId, userIdStatus, userCode) {
+        __assertType("userId", "number", __assertType__number.bind(void 0, userId));
+        __assertType("userIdStatus", undefined, __assertType__su__1__2__3__4_eu.bind(void 0, userIdStatus));
+        __assertType("userCode", undefined, __assertType__su__string__uint8array_eu.bind(void 0, userCode));
+        if (userId > 255) {
+            return this.setMany([{ userId, userIdStatus, userCode }]);
+        }
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.Set);
+        const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+        if (numUsers != undefined && userId > numUsers) {
+            throw new ZWaveError(`The user ID must be between 0 and the number of supported users ${numUsers}.`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        const cc = new UserCodeCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            userId,
+            userIdStatus,
+            userCode,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    /** Configures multiple user codes */
+    async setMany(codes) {
+        __assertType("codes", undefined, __assertType__sa_su__3__4__5_eu_ea_2.bind(void 0, codes));
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.ExtendedUserCodeSet);
+        const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+        const supportedStatuses = UserCodeCC.getSupportedUserIDStatusesCached(this.host, this.endpoint);
+        const supportedASCIIChars = UserCodeCC.getSupportedASCIICharsCached(this.host, this.endpoint);
+        const supportsMultipleUserCodeSet = UserCodeCC.supportsMultipleUserCodeSetCached(this.host, this.endpoint) ?? false;
+        // Validate options
+        if (numUsers != undefined) {
+            if (codes.some((code) => code.userId < 0 || code.userId > numUsers)) {
+                throw new ZWaveError(`All User IDs must be between 0 and the number of supported users ${numUsers}.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        else {
+            if (codes.some((code) => code.userId < 0)) {
+                throw new ZWaveError(`All User IDs must be greater than 0.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        if (codes.some((code) => code.userId === 0) && codes.length > 1) {
+            throw new ZWaveError(`If user ID 0 is used, only one code may be set`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (codes.some((code) => code.userId === 0
+            && code.userIdStatus !== UserIDStatus.Available)) {
+            throw new ZWaveError(`User ID 0 may only be used to clear all user codes`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (codes.length > 1 && !supportsMultipleUserCodeSet) {
+            throw new ZWaveError(`The node does not support setting multiple user codes at once`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        for (const code of codes) {
+            if (supportedStatuses != undefined
+                && !supportedStatuses.includes(code.userIdStatus)) {
+                throw new ZWaveError(`The user ID status ${getEnumMemberName(UserIDStatus, code.userIdStatus)} is not supported by the node`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            else if (code.userIdStatus === UserIDStatus.Available) {
+                code.userCode = undefined;
+            }
+            else if (supportedASCIIChars) {
+                const userCodeString = typeof code.userCode === "string"
+                    ? code.userCode
+                    : uint8ArrayToString(code.userCode);
+                if (!validateCode(userCodeString, supportedASCIIChars)) {
+                    throw new ZWaveError(`The user code must consist of 4 to 10 of the following characters: ${supportedASCIIChars}`, ZWaveErrorCodes.Argument_Invalid);
+                }
+            }
+        }
+        const cc = new UserCodeCCExtendedUserCodeSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            userCodes: codes,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    /**
+     * Clears one or all user code
+     * @param userId The user code to clear. If none or 0 is given, all codes are cleared
+     */
+    async clear(userId = 0) {
+        __assertType("userId", "(optional) number", __assertType__optional_number.bind(void 0, userId));
+        if (this.version > 1 || userId > 255) {
+            return this.setMany([
+                { userId, userIdStatus: UserIDStatus.Available },
+            ]);
+        }
+        else {
+            this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.Set);
+            const numUsers = UserCodeCC.getSupportedUsersCached(this.host, this.endpoint);
+            if (numUsers != undefined && userId > numUsers) {
+                throw new ZWaveError(`The user ID must be between 0 and the number of supported users ${numUsers}.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            const cc = new UserCodeCCSet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                userId,
+                userIdStatus: UserIDStatus.Available,
+            });
+            return this.host.sendCommand(cc, this.commandOptions);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getCapabilities() {
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.CapabilitiesGet);
+        const cc = new UserCodeCCCapabilitiesGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, [
+                "supportsAdminCode",
+                "supportsAdminCodeDeactivation",
+                "supportsUserCodeChecksum",
+                "supportsMultipleUserCodeReport",
+                "supportsMultipleUserCodeSet",
+                "supportedUserIDStatuses",
+                "supportedKeypadModes",
+                "supportedASCIIChars",
+            ]);
+        }
+    }
+    async getKeypadMode() {
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.KeypadModeGet);
+        const cc = new UserCodeCCKeypadModeGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.keypadMode;
+    }
+    async setKeypadMode(keypadMode) {
+        __assertType("keypadMode", "KeypadMode", __assertType__KeypadMode.bind(void 0, keypadMode));
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.KeypadModeSet);
+        const supportedModes = UserCodeCC.getSupportedKeypadModesCached(this.host, this.endpoint);
+        if (!supportedModes) {
+            throw new ZWaveError(`The keypad mode can only be set after the interview is complete!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (!supportedModes.includes(keypadMode)) {
+            throw new ZWaveError(`The keypad mode ${getEnumMemberName(KeypadMode, keypadMode)} is not supported by the node!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        const cc = new UserCodeCCKeypadModeSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            keypadMode,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getAdminCode() {
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.AdminCodeGet);
+        const cc = new UserCodeCCAdminCodeGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.adminCode;
+    }
+    async setAdminCode(adminCode) {
+        __assertType("adminCode", "string", __assertType__string.bind(void 0, adminCode));
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.AdminCodeSet);
+        const supportedASCIIChars = UserCodeCC.getSupportedASCIICharsCached(this.host, this.endpoint);
+        if (!supportedASCIIChars) {
+            throw new ZWaveError(`The admin code can only be set after the interview is complete!`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        // Validate the code
+        if (!adminCode) {
+            const supportsDeactivation = UserCodeCC
+                .supportsAdminCodeDeactivationCached(this.host, this.endpoint);
+            if (!supportsDeactivation) {
+                throw new ZWaveError(`The node does not support deactivating the admin code!`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        else if (!validateCode(adminCode, supportedASCIIChars)) {
+            throw new ZWaveError(`The admin code must consist of 4 to 10 of the following characters: ${supportedASCIIChars}`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        const cc = new UserCodeCCAdminCodeSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            adminCode,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async getUserCodeChecksum() {
+        this.assertSupportsCommand(UserCodeCommand, UserCodeCommand.UserCodeChecksumGet);
+        const cc = new UserCodeCCUserCodeChecksumGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.userCodeChecksum;
+    }
+};
+UserCodeCCAPI = __decorate([
+    API(CommandClasses["User Code"])
+], UserCodeCCAPI);
+export { UserCodeCCAPI };
+let UserCodeCC = UserCodeCC_1 = class UserCodeCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["User Code"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        // Query capabilities first to determine what needs to be done when refreshing
+        if (api.version >= 2) {
+            ctx.logNode(node.id, {
+                message: "querying capabilities...",
+                direction: "outbound",
+            });
+            const caps = await api.getCapabilities();
+            if (!caps) {
+                ctx.logNode(node.id, {
+                    endpoint: this.endpointIndex,
+                    message: "User Code capabilities query timed out, skipping interview...",
+                    level: "warn",
+                });
+                return;
+            }
+        }
+        ctx.logNode(node.id, {
+            message: "querying number of user codes...",
+            direction: "outbound",
+        });
+        const supportedUsers = await api.getUsersCount();
+        if (supportedUsers == undefined) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "Querying number of user codes timed out, skipping interview...",
+                level: "warn",
+            });
+            return;
+        }
+        for (let userId = 1; userId <= supportedUsers; userId++) {
+            setUserCodeMetadata.call(this, ctx, userId);
+        }
+        // Synchronize user codes and settings
+        if (ctx.getInterviewOptions()?.queryAllUserCodes) {
+            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["User Code"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        const supportsAdminCode = UserCodeCC_1.supportsAdminCodeCached(ctx, endpoint);
+        const supportsUserCodeChecksum = this.getValue(ctx, UserCodeCCValues.supportsUserCodeChecksum) ?? false;
+        const supportedKeypadModes = this.getValue(ctx, UserCodeCCValues.supportedKeypadModes)
+            ?? [];
+        const supportedUsers = this.getValue(ctx, UserCodeCCValues.supportedUsers) ?? 0;
+        const supportsMultipleUserCodeReport = !!this.getValue(ctx, UserCodeCCValues.supportsMultipleUserCodeReport);
+        // Check for changed values and codes
+        if (api.version >= 2) {
+            if (supportsAdminCode) {
+                ctx.logNode(node.id, {
+                    message: "querying admin code...",
+                    direction: "outbound",
+                });
+                await api.getAdminCode();
+            }
+            if (supportedKeypadModes.length > 1) {
+                ctx.logNode(node.id, {
+                    message: "querying active keypad mode...",
+                    direction: "outbound",
+                });
+                await api.getKeypadMode();
+            }
+            const storedUserCodeChecksum = this.getValue(ctx, UserCodeCCValues.userCodeChecksum) ?? 0;
+            let currentUserCodeChecksum = 0;
+            if (supportsUserCodeChecksum) {
+                ctx.logNode(node.id, {
+                    message: "retrieving current user code checksum...",
+                    direction: "outbound",
+                });
+                currentUserCodeChecksum = await api.getUserCodeChecksum();
+            }
+            if (!supportsUserCodeChecksum
+                || currentUserCodeChecksum !== storedUserCodeChecksum) {
+                ctx.logNode(node.id, {
+                    message: "checksum changed or is not supported, querying all user codes...",
+                    direction: "outbound",
+                });
+                if (supportsMultipleUserCodeReport) {
+                    // Query the user codes in bulk
+                    let nextUserId = 1;
+                    while (nextUserId > 0 && nextUserId <= supportedUsers) {
+                        const response = await api.get(nextUserId, true);
+                        if (response) {
+                            nextUserId = response.nextUserId;
+                        }
+                        else {
+                            ctx.logNode(node.id, {
+                                endpoint: this.endpointIndex,
+                                message: `Querying user code #${nextUserId} timed out, skipping the remaining interview...`,
+                                level: "warn",
+                            });
+                            break;
+                        }
+                    }
+                }
+                else {
+                    // Query one user code at a time
+                    for (let userId = 1; userId <= supportedUsers; userId++) {
+                        await api.get(userId);
+                    }
+                }
+            }
+        }
+        else {
+            // V1
+            ctx.logNode(node.id, {
+                message: "querying all user codes...",
+                direction: "outbound",
+            });
+            for (let userId = 1; userId <= supportedUsers; userId++) {
+                await api.get(userId);
+            }
+        }
+    }
+    /**
+     * Returns the number of supported users.
+     * This only works AFTER the interview process
+     */
+    static getSupportedUsersCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.supportedUsers.endpoint(endpoint.index));
+    }
+    /**
+     * Returns the supported keypad modes.
+     * This only works AFTER the interview process
+     */
+    static getSupportedKeypadModesCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.supportedKeypadModes.endpoint(endpoint.index));
+    }
+    /**
+     * Returns the supported user ID statuses.
+     * This only works AFTER the interview process
+     */
+    static getSupportedUserIDStatusesCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.supportedUserIDStatuses.endpoint(endpoint.index));
+    }
+    /**
+     * Returns the supported ASCII characters.
+     * This only works AFTER the interview process
+     */
+    static getSupportedASCIICharsCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.supportedASCIIChars.endpoint(endpoint.index));
+    }
+    /**
+     * Returns whether the admin code functionality is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsAdminCodeCached(ctx, endpoint) {
+        const valueDB = ctx
+            .getValueDB(endpoint.nodeId);
+        return valueDB.getValue(UserCodeCCValues.supportsAdminCode.endpoint(endpoint.index)) ?? valueDB.getValue(UserCodeCCValues._deprecated_supportsMasterCode.endpoint(endpoint.index)) ?? false;
+    }
+    /**
+     * Returns whether deactivating the admin code is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsAdminCodeDeactivationCached(ctx, endpoint) {
+        const valueDB = ctx
+            .getValueDB(endpoint.nodeId);
+        return valueDB.getValue(UserCodeCCValues.supportsAdminCodeDeactivation.endpoint(endpoint.index)) ?? valueDB.getValue(UserCodeCCValues._deprecated_supportsMasterCodeDeactivation
+            .endpoint(endpoint.index)) ?? false;
+    }
+    /**
+     * Returns whether setting multiple user codes at once is supported.
+     * This only works AFTER the interview process
+     */
+    static supportsMultipleUserCodeSetCached(ctx, endpoint) {
+        return !!ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.supportsMultipleUserCodeSet.endpoint(endpoint.index));
+    }
+    /**
+     * Returns the current status of a user ID.
+     * This only works AFTER the user IDs have been queried.
+     */
+    static getUserIdStatusCached(ctx, endpoint, userId) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.userIdStatus(userId).endpoint(endpoint.index));
+    }
+    /**
+     * Returns the current code belonging to a user ID.
+     * This only works AFTER the user IDs have been queried.
+     */
+    static getUserCodeCached(ctx, endpoint, userId) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(UserCodeCCValues.userCode(userId).endpoint(endpoint.index));
+    }
+};
+UserCodeCC = UserCodeCC_1 = __decorate([
+    commandClass(CommandClasses["User Code"]),
+    implementedVersion(2),
+    ccValues(UserCodeCCValues)
+], UserCodeCC);
+export { UserCodeCC };
+let UserCodeCCSet = UserCodeCCSet_1 = class UserCodeCCSet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.userIdStatus = options.userIdStatus;
+        // Validate options
+        if (this.userId < 0) {
+            throw new ZWaveError(`${this.constructor.name}: The user ID must be between greater than 0.`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (this.userId === 0
+            && this.userIdStatus !== UserIDStatus.Available) {
+            throw new ZWaveError(`${this.constructor.name}: User ID 0 may only be used to clear all user codes`, ZWaveErrorCodes.Argument_Invalid);
+        }
+        else if (this.userIdStatus === UserIDStatus.Available) {
+            this.userCode = "\0".repeat(4);
+        }
+        else {
+            this.userCode = options.userCode;
+            // Specs say ASCII 0-9, manufacturers don't care :)
+            if (this.userCode.length < 4 || this.userCode.length > 10) {
+                throw new ZWaveError(`${this.constructor.name}: The user code must have a length of 4 to 10 ${typeof this.userCode === "string"
+                    ? "characters"
+                    : "bytes"}`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const userIdStatus = raw.payload[1];
+        if (userIdStatus === UserIDStatus.StatusNotAvailable) {
+            validatePayload.fail("Invalid user ID status");
+        }
+        if (userIdStatus === UserIDStatus.Available) {
+            return new UserCodeCCSet_1({
+                nodeId: ctx.sourceNodeId,
+                userId,
+                userIdStatus,
+            });
+        }
+        const userCode = raw.payload.subarray(2);
+        return new UserCodeCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            userIdStatus,
+            userCode,
+        });
+    }
+    userId;
+    userIdStatus;
+    userCode;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.userId, this.userIdStatus]),
+            typeof this.userCode === "string"
+                ? Bytes.from(this.userCode, "ascii")
+                : this.userCode,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user id": this.userId,
+                "id status": getEnumMemberName(UserIDStatus, this.userIdStatus),
+                "user code": userCodeToLogString(this.userCode),
+            },
+        };
+    }
+};
+UserCodeCCSet = UserCodeCCSet_1 = __decorate([
+    CCCommand(UserCodeCommand.Set),
+    useSupervision()
+], UserCodeCCSet);
+export { UserCodeCCSet };
+let UserCodeCCReport = UserCodeCCReport_1 = class UserCodeCCReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.userIdStatus = options.userIdStatus;
+        this.userCode = options.userCode ?? "";
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const userIdStatus = raw.payload[1];
+        let userCode;
+        if (raw.payload.length === 2
+            && (userIdStatus === UserIDStatus.Available
+                || userIdStatus === UserIDStatus.StatusNotAvailable)) {
+            // The user code is not set or not available and this report contains no user code
+            userCode = "";
+        }
+        else {
+            // The specs require the user code to be at least 4 digits
+            validatePayload(raw.payload.length >= 6);
+            let userCodeBuffer = raw.payload.subarray(2);
+            // Specs say infer user code from payload length, manufacturers send zero-padded strings
+            while (userCodeBuffer.at(-1) === 0) {
+                userCodeBuffer = userCodeBuffer.subarray(0, -1);
+            }
+            // Specs say ASCII 0-9, manufacturers don't care :)
+            // Thus we check if the code is printable using ASCII, if not keep it as a Buffer
+            const userCodeString = userCodeBuffer.toString("utf8");
+            if (isPrintableASCII(userCodeString)) {
+                userCode = userCodeString;
+            }
+            else if (isPrintableASCIIWithWhitespace(userCodeString)) {
+                // Ignore leading and trailing whitespace in V1 reports if the rest is ASCII
+                userCode = userCodeString.trim();
+            }
+            else {
+                userCode = userCodeBuffer;
+            }
+        }
+        return new UserCodeCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            userIdStatus,
+            userCode,
+        });
+    }
+    userId;
+    userIdStatus;
+    userCode;
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        persistUserCode.call(this, ctx, this.userId, this.userIdStatus, this.userCode);
+        return true;
+    }
+    serialize(ctx) {
+        let userCodeBuffer;
+        if (typeof this.userCode === "string") {
+            userCodeBuffer = Bytes.from(this.userCode, "ascii");
+        }
+        else {
+            userCodeBuffer = this.userCode;
+        }
+        this.payload = Bytes.concat([
+            Bytes.from([this.userId, this.userIdStatus]),
+            userCodeBuffer,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user id": this.userId,
+                "id status": getEnumMemberName(UserIDStatus, this.userIdStatus),
+                "user code": userCodeToLogString(this.userCode),
+            },
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    toNotificationEventParameters() {
+        return { userId: this.userId };
+    }
+};
+UserCodeCCReport = UserCodeCCReport_1 = __decorate([
+    CCCommand(UserCodeCommand.Report)
+], UserCodeCCReport);
+export { UserCodeCCReport };
+let UserCodeCCGet = UserCodeCCGet_1 = class UserCodeCCGet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const userId = raw.payload[0];
+        return new UserCodeCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+        });
+    }
+    userId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { "user id": this.userId },
+        };
+    }
+};
+UserCodeCCGet = UserCodeCCGet_1 = __decorate([
+    CCCommand(UserCodeCommand.Get),
+    expectedCCResponse(UserCodeCCReport)
+], UserCodeCCGet);
+export { UserCodeCCGet };
+let UserCodeCCUsersNumberReport = UserCodeCCUsersNumberReport_1 = class UserCodeCCUsersNumberReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.supportedUsers = options.supportedUsers;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        let supportedUsers;
+        if (raw.payload.length >= 3) {
+            // V2+
+            supportedUsers = raw.payload.readUInt16BE(1);
+        }
+        else {
+            // V1
+            supportedUsers = raw.payload[0];
+        }
+        return new UserCodeCCUsersNumberReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedUsers,
+        });
+    }
+    supportedUsers;
+    serialize(ctx) {
+        this.payload = new Bytes(3);
+        // If the node implements more than 255 users, this field MUST be set to 255
+        this.payload[0] = Math.min(255, this.supportedUsers);
+        this.payload.writeUInt16BE(this.supportedUsers, 1);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { "supported users": this.supportedUsers },
+        };
+    }
+};
+__decorate([
+    ccValue(UserCodeCCValues.supportedUsers)
+], UserCodeCCUsersNumberReport.prototype, "supportedUsers", void 0);
+UserCodeCCUsersNumberReport = UserCodeCCUsersNumberReport_1 = __decorate([
+    CCCommand(UserCodeCommand.UsersNumberReport)
+], UserCodeCCUsersNumberReport);
+export { UserCodeCCUsersNumberReport };
+let UserCodeCCUsersNumberGet = class UserCodeCCUsersNumberGet extends UserCodeCC {
+};
+UserCodeCCUsersNumberGet = __decorate([
+    CCCommand(UserCodeCommand.UsersNumberGet),
+    expectedCCResponse(UserCodeCCUsersNumberReport)
+], UserCodeCCUsersNumberGet);
+export { UserCodeCCUsersNumberGet };
+let UserCodeCCCapabilitiesReport = UserCodeCCCapabilitiesReport_1 = class UserCodeCCCapabilitiesReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.supportsAdminCode = options.supportsAdminCode;
+        this.supportsAdminCodeDeactivation =
+            options.supportsAdminCodeDeactivation;
+        this.supportsUserCodeChecksum = options.supportsUserCodeChecksum;
+        this.supportsMultipleUserCodeReport =
+            options.supportsMultipleUserCodeReport;
+        this.supportsMultipleUserCodeSet = options.supportsMultipleUserCodeSet;
+        this.supportedUserIDStatuses = options.supportedUserIDStatuses;
+        this.supportedKeypadModes = options.supportedKeypadModes;
+        this.supportedASCIIChars = options.supportedASCIIChars;
+    }
+    static from(raw, ctx) {
+        let offset = 0;
+        validatePayload(raw.payload.length >= offset + 1);
+        const supportsAdminCode = !!(raw.payload[offset] & 0b100_00000);
+        const supportsAdminCodeDeactivation = !!(raw.payload[offset] & 0b010_00000);
+        const statusBitMaskLength = raw.payload[offset] & 0b000_11111;
+        offset += 1;
+        validatePayload(raw.payload.length >= offset + statusBitMaskLength + 1);
+        const supportedUserIDStatuses = parseBitMask(raw.payload.subarray(offset, offset + statusBitMaskLength), UserIDStatus.Available);
+        offset += statusBitMaskLength;
+        const supportsUserCodeChecksum = !!(raw.payload[offset] & 0b100_00000);
+        const supportsMultipleUserCodeReport = !!(raw.payload[offset] & 0b010_00000);
+        const supportsMultipleUserCodeSet = !!(raw.payload[offset] & 0b001_00000);
+        const keypadModesBitMaskLength = raw.payload[offset] & 0b000_11111;
+        offset += 1;
+        validatePayload(raw.payload.length >= offset + keypadModesBitMaskLength + 1);
+        const supportedKeypadModes = parseBitMask(raw.payload.subarray(offset, offset + keypadModesBitMaskLength), KeypadMode.Normal);
+        offset += keypadModesBitMaskLength;
+        const keysBitMaskLength = raw.payload[offset] & 0b000_11111;
+        offset += 1;
+        validatePayload(raw.payload.length >= offset + keysBitMaskLength);
+        const supportedASCIIChars = Bytes.from(parseBitMask(raw.payload.subarray(offset, offset + keysBitMaskLength), 0)).toString("ascii");
+        return new UserCodeCCCapabilitiesReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportsAdminCode,
+            supportsAdminCodeDeactivation,
+            supportedUserIDStatuses,
+            supportsUserCodeChecksum,
+            supportsMultipleUserCodeReport,
+            supportsMultipleUserCodeSet,
+            supportedKeypadModes,
+            supportedASCIIChars,
+        });
+    }
+    supportsAdminCode;
+    supportsAdminCodeDeactivation;
+    supportsUserCodeChecksum;
+    supportsMultipleUserCodeReport;
+    supportsMultipleUserCodeSet;
+    supportedUserIDStatuses;
+    supportedKeypadModes;
+    supportedASCIIChars;
+    serialize(ctx) {
+        const supportedStatusesBitmask = encodeBitMask(this.supportedUserIDStatuses, undefined, UserIDStatus.Available);
+        const controlByte1 = (this.supportsAdminCode ? 0b100_00000 : 0)
+            | (this.supportsAdminCodeDeactivation ? 0b010_00000 : 0)
+            | (supportedStatusesBitmask.length & 0b000_11111);
+        const supportedKeypadModesBitmask = encodeBitMask(this.supportedKeypadModes, undefined, KeypadMode.Normal);
+        const controlByte2 = (this.supportsUserCodeChecksum ? 0b100_00000 : 0)
+            | (this.supportsMultipleUserCodeReport ? 0b010_00000 : 0)
+            | (this.supportsMultipleUserCodeSet ? 0b001_00000 : 0)
+            | (supportedKeypadModesBitmask.length & 0b000_11111);
+        const keysAsNumbers = [...this.supportedASCIIChars].map((char) => char.charCodeAt(0));
+        const supportedKeysBitmask = encodeBitMask(keysAsNumbers, undefined, 0);
+        const controlByte3 = supportedKeysBitmask.length & 0b000_11111;
+        this.payload = Bytes.concat([
+            Bytes.from([controlByte1]),
+            supportedStatusesBitmask,
+            Bytes.from([controlByte2]),
+            supportedKeypadModesBitmask,
+            Bytes.from([controlByte3]),
+            supportedKeysBitmask,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supports admin code": this.supportsAdminCode,
+                "supports admin code deactivation": this.supportsAdminCodeDeactivation,
+                "supports user code checksum": this.supportsUserCodeChecksum,
+                "supports multiple codes in report": this.supportsMultipleUserCodeReport,
+                "supports multiple codes in set": this.supportsMultipleUserCodeSet,
+                "supported user id statuses": this.supportedUserIDStatuses
+                    .map((status) => `\n· ${getEnumMemberName(UserIDStatus, status)}`)
+                    .join(""),
+                "supported keypad modes": this.supportedKeypadModes
+                    .map((mode) => `\n· ${getEnumMemberName(KeypadMode, mode)}`)
+                    .join(""),
+                "supported ASCII chars": this.supportedASCIIChars,
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(UserCodeCCValues.supportsAdminCode)
+], UserCodeCCCapabilitiesReport.prototype, "supportsAdminCode", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportsAdminCodeDeactivation)
+], UserCodeCCCapabilitiesReport.prototype, "supportsAdminCodeDeactivation", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportsUserCodeChecksum)
+], UserCodeCCCapabilitiesReport.prototype, "supportsUserCodeChecksum", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportsMultipleUserCodeReport)
+], UserCodeCCCapabilitiesReport.prototype, "supportsMultipleUserCodeReport", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportsMultipleUserCodeSet)
+], UserCodeCCCapabilitiesReport.prototype, "supportsMultipleUserCodeSet", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportedUserIDStatuses)
+], UserCodeCCCapabilitiesReport.prototype, "supportedUserIDStatuses", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportedKeypadModes)
+], UserCodeCCCapabilitiesReport.prototype, "supportedKeypadModes", void 0);
+__decorate([
+    ccValue(UserCodeCCValues.supportedASCIIChars)
+], UserCodeCCCapabilitiesReport.prototype, "supportedASCIIChars", void 0);
+UserCodeCCCapabilitiesReport = UserCodeCCCapabilitiesReport_1 = __decorate([
+    CCCommand(UserCodeCommand.CapabilitiesReport)
+], UserCodeCCCapabilitiesReport);
+export { UserCodeCCCapabilitiesReport };
+let UserCodeCCCapabilitiesGet = class UserCodeCCCapabilitiesGet extends UserCodeCC {
+};
+UserCodeCCCapabilitiesGet = __decorate([
+    CCCommand(UserCodeCommand.CapabilitiesGet),
+    expectedCCResponse(UserCodeCCCapabilitiesReport)
+], UserCodeCCCapabilitiesGet);
+export { UserCodeCCCapabilitiesGet };
+let UserCodeCCKeypadModeSet = UserCodeCCKeypadModeSet_1 = class UserCodeCCKeypadModeSet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.keypadMode = options.keypadMode;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const keypadMode = raw.payload[0];
+        return new UserCodeCCKeypadModeSet_1({
+            nodeId: ctx.sourceNodeId,
+            keypadMode,
+        });
+    }
+    keypadMode;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.keypadMode]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { mode: getEnumMemberName(KeypadMode, this.keypadMode) },
+        };
+    }
+};
+UserCodeCCKeypadModeSet = UserCodeCCKeypadModeSet_1 = __decorate([
+    CCCommand(UserCodeCommand.KeypadModeSet),
+    useSupervision()
+], UserCodeCCKeypadModeSet);
+export { UserCodeCCKeypadModeSet };
+let UserCodeCCKeypadModeReport = UserCodeCCKeypadModeReport_1 = class UserCodeCCKeypadModeReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.keypadMode = options.keypadMode;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const keypadMode = raw.payload[0];
+        return new UserCodeCCKeypadModeReport_1({
+            nodeId: ctx.sourceNodeId,
+            keypadMode,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        // Update the keypad modes metadata
+        const supportedKeypadModes = this.getValue(ctx, UserCodeCCValues.supportedKeypadModes) ?? [this.keypadMode];
+        const keypadModeValue = UserCodeCCValues.keypadMode;
+        this.setMetadata(ctx, keypadModeValue, {
+            ...keypadModeValue.meta,
+            states: enumValuesToMetadataStates(KeypadMode, supportedKeypadModes),
+        });
+        return true;
+    }
+    keypadMode;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.keypadMode]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                keypadMode: getEnumMemberName(KeypadMode, this.keypadMode),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(UserCodeCCValues.keypadMode)
+], UserCodeCCKeypadModeReport.prototype, "keypadMode", void 0);
+UserCodeCCKeypadModeReport = UserCodeCCKeypadModeReport_1 = __decorate([
+    CCCommand(UserCodeCommand.KeypadModeReport)
+], UserCodeCCKeypadModeReport);
+export { UserCodeCCKeypadModeReport };
+let UserCodeCCKeypadModeGet = class UserCodeCCKeypadModeGet extends UserCodeCC {
+};
+UserCodeCCKeypadModeGet = __decorate([
+    CCCommand(UserCodeCommand.KeypadModeGet),
+    expectedCCResponse(UserCodeCCKeypadModeReport)
+], UserCodeCCKeypadModeGet);
+export { UserCodeCCKeypadModeGet };
+let UserCodeCCAdminCodeSet = UserCodeCCAdminCodeSet_1 = class UserCodeCCAdminCodeSet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.adminCode = options.adminCode;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const codeLength = raw.payload[0] & 0b1111;
+        validatePayload(raw.payload.length >= 1 + codeLength);
+        const adminCode = raw.payload
+            .subarray(1, 1 + codeLength)
+            .toString("ascii");
+        return new UserCodeCCAdminCodeSet_1({
+            nodeId: ctx.sourceNodeId,
+            adminCode,
+        });
+    }
+    adminCode;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.adminCode.length & 0b1111]),
+            Bytes.from(this.adminCode, "ascii"),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { "admin code": userCodeToLogString(this.adminCode) },
+        };
+    }
+};
+UserCodeCCAdminCodeSet = UserCodeCCAdminCodeSet_1 = __decorate([
+    CCCommand(UserCodeCommand.AdminCodeSet),
+    useSupervision()
+], UserCodeCCAdminCodeSet);
+export { UserCodeCCAdminCodeSet };
+let UserCodeCCAdminCodeReport = UserCodeCCAdminCodeReport_1 = class UserCodeCCAdminCodeReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.adminCode = options.adminCode;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const codeLength = raw.payload[0] & 0b1111;
+        validatePayload(raw.payload.length >= 1 + codeLength);
+        const adminCode = raw.payload
+            .subarray(1, 1 + codeLength)
+            .toString("ascii");
+        return new UserCodeCCAdminCodeReport_1({
+            nodeId: ctx.sourceNodeId,
+            adminCode,
+        });
+    }
+    adminCode;
+    serialize(ctx) {
+        this.payload = Bytes.concat([
+            Bytes.from([this.adminCode.length & 0b1111]),
+            Bytes.from(this.adminCode, "ascii"),
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { "admin code": userCodeToLogString(this.adminCode) },
+        };
+    }
+};
+__decorate([
+    ccValue(UserCodeCCValues.adminCode)
+], UserCodeCCAdminCodeReport.prototype, "adminCode", void 0);
+UserCodeCCAdminCodeReport = UserCodeCCAdminCodeReport_1 = __decorate([
+    CCCommand(UserCodeCommand.AdminCodeReport)
+], UserCodeCCAdminCodeReport);
+export { UserCodeCCAdminCodeReport };
+let UserCodeCCAdminCodeGet = class UserCodeCCAdminCodeGet extends UserCodeCC {
+};
+UserCodeCCAdminCodeGet = __decorate([
+    CCCommand(UserCodeCommand.AdminCodeGet),
+    expectedCCResponse(UserCodeCCAdminCodeReport)
+], UserCodeCCAdminCodeGet);
+export { UserCodeCCAdminCodeGet };
+let UserCodeCCUserCodeChecksumReport = UserCodeCCUserCodeChecksumReport_1 = class UserCodeCCUserCodeChecksumReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userCodeChecksum = options.userCodeChecksum;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userCodeChecksum = raw.payload.readUInt16BE(0);
+        return new UserCodeCCUserCodeChecksumReport_1({
+            nodeId: ctx.sourceNodeId,
+            userCodeChecksum,
+        });
+    }
+    userCodeChecksum;
+    serialize(ctx) {
+        this.payload = new Bytes(2);
+        this.payload.writeUInt16BE(this.userCodeChecksum, 0);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: { "user code checksum": num2hex(this.userCodeChecksum) },
+        };
+    }
+};
+__decorate([
+    ccValue(UserCodeCCValues.userCodeChecksum)
+], UserCodeCCUserCodeChecksumReport.prototype, "userCodeChecksum", void 0);
+UserCodeCCUserCodeChecksumReport = UserCodeCCUserCodeChecksumReport_1 = __decorate([
+    CCCommand(UserCodeCommand.UserCodeChecksumReport)
+], UserCodeCCUserCodeChecksumReport);
+export { UserCodeCCUserCodeChecksumReport };
+let UserCodeCCUserCodeChecksumGet = class UserCodeCCUserCodeChecksumGet extends UserCodeCC {
+};
+UserCodeCCUserCodeChecksumGet = __decorate([
+    CCCommand(UserCodeCommand.UserCodeChecksumGet),
+    expectedCCResponse(UserCodeCCUserCodeChecksumReport)
+], UserCodeCCUserCodeChecksumGet);
+export { UserCodeCCUserCodeChecksumGet };
+let UserCodeCCExtendedUserCodeSet = class UserCodeCCExtendedUserCodeSet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userCodes = options.userCodes;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new UserCodeCCExtendedUserCodeSet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    userCodes;
+    serialize(ctx) {
+        const userCodeBuffers = this.userCodes.map((code) => {
+            const ret = Bytes.concat([
+                Bytes.from([
+                    0,
+                    0,
+                    code.userIdStatus,
+                    code.userCode?.length ?? 0,
+                ]),
+                isUint8Array(code.userCode)
+                    ? code.userCode
+                    : Bytes.from(code.userCode ?? "", "ascii"),
+            ]);
+            ret.writeUInt16BE(code.userId, 0);
+            return ret;
+        });
+        this.payload = Bytes.concat([
+            Bytes.from([this.userCodes.length]),
+            ...userCodeBuffers,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        for (const { userId, userIdStatus, userCode } of this.userCodes) {
+            message[`code #${userId}`] = `${userCodeToLogString(userCode ?? "")} (status: ${getEnumMemberName(UserIDStatus, userIdStatus)})`;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+UserCodeCCExtendedUserCodeSet = __decorate([
+    CCCommand(UserCodeCommand.ExtendedUserCodeSet),
+    useSupervision()
+], UserCodeCCExtendedUserCodeSet);
+export { UserCodeCCExtendedUserCodeSet };
+let UserCodeCCExtendedUserCodeReport = UserCodeCCExtendedUserCodeReport_1 = class UserCodeCCExtendedUserCodeReport extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.userCodes = options.userCodes;
+        this.nextUserId = options.nextUserId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const numCodes = raw.payload[0];
+        let offset = 1;
+        const userCodes = [];
+        // parse each user code
+        for (let i = 0; i < numCodes; i++) {
+            const { code, bytesRead } = parseExtendedUserCode(raw.payload.subarray(offset));
+            userCodes.push(code);
+            offset += bytesRead;
+        }
+        validatePayload(raw.payload.length >= offset + 2);
+        const nextUserId = raw.payload.readUInt16BE(offset);
+        return new UserCodeCCExtendedUserCodeReport_1({
+            nodeId: ctx.sourceNodeId,
+            userCodes,
+            nextUserId,
+        });
+    }
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        for (const { userId, userIdStatus, userCode } of this.userCodes) {
+            persistUserCode.call(this, ctx, userId, userIdStatus, userCode);
+        }
+        return true;
+    }
+    userCodes;
+    nextUserId;
+    toLogEntry(ctx) {
+        const message = {};
+        for (const { userId, userIdStatus, userCode } of this.userCodes) {
+            message[`code #${userId}`] = `${userCodeToLogString(userCode)} (status: ${getEnumMemberName(UserIDStatus, userIdStatus)})`;
+        }
+        message["next user id"] = this.nextUserId;
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+UserCodeCCExtendedUserCodeReport = UserCodeCCExtendedUserCodeReport_1 = __decorate([
+    CCCommand(UserCodeCommand.ExtendedUserCodeReport)
+], UserCodeCCExtendedUserCodeReport);
+export { UserCodeCCExtendedUserCodeReport };
+let UserCodeCCExtendedUserCodeGet = class UserCodeCCExtendedUserCodeGet extends UserCodeCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.reportMore = !!options.reportMore;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new ZWaveError(`${this.name}: deserialization not implemented`, ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new UserCodeCCExtendedUserCodeGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
+    }
+    userId;
+    reportMore;
+    serialize(ctx) {
+        this.payload = Bytes.from([0, 0, this.reportMore ? 1 : 0]);
+        this.payload.writeUInt16BE(this.userId, 0);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user id": this.userId,
+                "report more": this.reportMore,
+            },
+        };
+    }
+};
+UserCodeCCExtendedUserCodeGet = __decorate([
+    CCCommand(UserCodeCommand.ExtendedUserCodeGet),
+    expectedCCResponse(UserCodeCCExtendedUserCodeReport)
+], UserCodeCCExtendedUserCodeGet);
+export { UserCodeCCExtendedUserCodeGet };
+//# sourceMappingURL=UserCodeCC.js.map