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

package/build/esm/cc/ScheduleEntryLockCC.js

@@ -0,0 +1,1826 @@
+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 ScheduleEntryLockCCEnableSet_1, ScheduleEntryLockCCEnableAllSet_1, ScheduleEntryLockCCSupportedReport_1, ScheduleEntryLockCCWeekDayScheduleSet_1, ScheduleEntryLockCCWeekDayScheduleReport_1, ScheduleEntryLockCCWeekDayScheduleGet_1, ScheduleEntryLockCCYearDayScheduleSet_1, ScheduleEntryLockCCYearDayScheduleReport_1, ScheduleEntryLockCCYearDayScheduleGet_1, ScheduleEntryLockCCTimeOffsetSet_1, ScheduleEntryLockCCTimeOffsetReport_1, ScheduleEntryLockCCDailyRepeatingScheduleSet_1, ScheduleEntryLockCCDailyRepeatingScheduleReport_1, ScheduleEntryLockCCDailyRepeatingScheduleGet_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__boolean = $o => {
+    function _boolean($o) {
+        return typeof $o !== "boolean" ? {} : null;
+    }
+    return _boolean($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__ScheduleEntryLockSlotId = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($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 ("slotId" in $o && $o["slotId"] !== undefined) {
+            const error = _number($o["slotId"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    return _0($o);
+};
+const __assertType__optional_ScheduleEntryLockWeekDaySchedule = $o => {
+    function su__2__3__4__5__6__7__8_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6].includes($o) ? {} : null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("weekday" in $o && $o["weekday"] !== undefined) {
+            const error = su__2__3__4__5__6__7__8_eu($o["weekday"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startHour" in $o && $o["startHour"] !== undefined) {
+            const error = _number($o["startHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startMinute" in $o && $o["startMinute"] !== undefined) {
+            const error = _number($o["startMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopHour" in $o && $o["stopHour"] !== undefined) {
+            const error = _number($o["stopHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopMinute" in $o && $o["stopMinute"] !== undefined) {
+            const error = _number($o["stopMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function optional__0($o) {
+        if ($o !== undefined) {
+            const error = _0($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__0($o);
+};
+const __assertType__optional_ScheduleEntryLockYearDaySchedule = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("startYear" in $o && $o["startYear"] !== undefined) {
+            const error = _number($o["startYear"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startMonth" in $o && $o["startMonth"] !== undefined) {
+            const error = _number($o["startMonth"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startDay" in $o && $o["startDay"] !== undefined) {
+            const error = _number($o["startDay"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startHour" in $o && $o["startHour"] !== undefined) {
+            const error = _number($o["startHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startMinute" in $o && $o["startMinute"] !== undefined) {
+            const error = _number($o["startMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopYear" in $o && $o["stopYear"] !== undefined) {
+            const error = _number($o["stopYear"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopMonth" in $o && $o["stopMonth"] !== undefined) {
+            const error = _number($o["stopMonth"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopDay" in $o && $o["stopDay"] !== undefined) {
+            const error = _number($o["stopDay"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopHour" in $o && $o["stopHour"] !== undefined) {
+            const error = _number($o["stopHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("stopMinute" in $o && $o["stopMinute"] !== undefined) {
+            const error = _number($o["stopMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function optional__0($o) {
+        if ($o !== undefined) {
+            const error = _0($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__0($o);
+};
+const __assertType__optional_ScheduleEntryLockDailyRepeatingSchedule = $o => {
+    function su__4__5__6__7__8__9__10_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6].includes($o) ? {} : null;
+    }
+    function sa_su__4__5__6__7__8__9__10_eu_ea_3($o) {
+        if (!Array.isArray($o))
+            return {};
+        for (let i = 0; i < $o.length; i++) {
+            const error = su__4__5__6__7__8__9__10_eu($o[i]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("weekdays" in $o && $o["weekdays"] !== undefined) {
+            const error = sa_su__4__5__6__7__8__9__10_eu_ea_3($o["weekdays"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startHour" in $o && $o["startHour"] !== undefined) {
+            const error = _number($o["startHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startMinute" in $o && $o["startMinute"] !== undefined) {
+            const error = _number($o["startMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("durationHour" in $o && $o["durationHour"] !== undefined) {
+            const error = _number($o["durationHour"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("durationMinute" in $o && $o["durationMinute"] !== undefined) {
+            const error = _number($o["durationMinute"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function optional__0($o) {
+        if ($o !== undefined) {
+            const error = _0($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    return optional__0($o);
+};
+const __assertType__Timezone = $o => {
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _0($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("standardOffset" in $o && $o["standardOffset"] !== undefined) {
+            const error = _number($o["standardOffset"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("dstOffset" in $o && $o["dstOffset"] !== undefined) {
+            const error = _number($o["dstOffset"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    return _0($o);
+};
+import { CommandClasses, MessagePriority, ZWaveError, ZWaveErrorCodes, encodeBitMask, getDSTInfo, isUnsupervisedOrSucceeded, parseBitMask, validatePayload, } from "@zwave-js/core";
+import { Bytes, formatDate, formatTime, getEnumMemberName, pick, } from "@zwave-js/shared";
+import { CCAPI } from "../lib/API.js";
+import { CommandClass, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { ScheduleEntryLockCommand, ScheduleEntryLockScheduleKind, ScheduleEntryLockSetAction, ScheduleEntryLockWeekday, } from "../lib/_Types.js";
+import { encodeTimezone, parseTimezone } from "../lib/serializers.js";
+import { UserCodeCC } from "./UserCodeCC.js";
+export const ScheduleEntryLockCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Schedule Entry Lock"], {
+        ...V.staticProperty("numWeekDaySlots", undefined, { internal: true }),
+        ...V.staticProperty("numYearDaySlots", undefined, { internal: true }),
+        ...V.staticProperty("numDailyRepeatingSlots", undefined, {
+            internal: true,
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["Schedule Entry Lock"], {
+        ...V.dynamicPropertyAndKeyWithName("userEnabled", "userEnabled", (userId) => userId, ({ property, propertyKey }) => property === "userEnabled" && typeof propertyKey === "number", undefined, { internal: true }),
+        ...V.dynamicPropertyAndKeyWithName("scheduleKind", "scheduleKind", (userId) => userId, ({ property, propertyKey }) => property === "scheduleKind" && typeof propertyKey === "number", undefined, { internal: true }),
+        ...V.dynamicPropertyAndKeyWithName("schedule", "schedule", (scheduleKind, userId, slotId) => toPropertyKey(scheduleKind, userId, slotId), ({ property, propertyKey }) => property === "schedule" && typeof propertyKey === "number", undefined, { internal: true }),
+    }),
+});
+function toPropertyKey(scheduleKind, userId, slotId) {
+    return (scheduleKind << 16) | (userId << 8) | slotId;
+}
+/** Caches information about a schedule */
+function persistSchedule(ctx, scheduleKind, userId, slotId, schedule) {
+    const scheduleValue = ScheduleEntryLockCCValues.schedule(scheduleKind, userId, slotId);
+    if (schedule != undefined) {
+        this.setValue(ctx, scheduleValue, schedule);
+    }
+    else {
+        this.removeValue(ctx, scheduleValue);
+    }
+}
+/** Updates the schedule kind assumed to be active for user in the cache */
+function setUserCodeScheduleKindCached(ctx, endpoint, userId, scheduleKind) {
+    ctx
+        .getValueDB(endpoint.nodeId)
+        .setValue(ScheduleEntryLockCCValues.scheduleKind(userId).endpoint(endpoint.index), scheduleKind);
+}
+/** Updates whether scheduling is active for one or all user(s) in the cache */
+function setUserCodeScheduleEnabledCached(ctx, endpoint, userId, enabled) {
+    const setEnabled = (userId) => {
+        ctx
+            .getValueDB(endpoint.nodeId)
+            .setValue(ScheduleEntryLockCCValues.userEnabled(userId).endpoint(endpoint.index), enabled);
+    };
+    if (userId == undefined) {
+        // Enable/disable all users
+        const numUsers = UserCodeCC.getSupportedUsersCached(ctx, endpoint)
+            ?? 0;
+        for (let userId = 1; userId <= numUsers; userId++) {
+            setEnabled(userId);
+        }
+    }
+    else {
+        setEnabled(userId);
+    }
+}
+let ScheduleEntryLockCCAPI = class ScheduleEntryLockCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case ScheduleEntryLockCommand.EnableSet:
+            case ScheduleEntryLockCommand.EnableAllSet:
+            case ScheduleEntryLockCommand.WeekDayScheduleSet:
+            case ScheduleEntryLockCommand.WeekDayScheduleGet:
+            case ScheduleEntryLockCommand.YearDayScheduleSet:
+            case ScheduleEntryLockCommand.YearDayScheduleGet:
+            case ScheduleEntryLockCommand.SupportedGet:
+                return true; // V1
+            case ScheduleEntryLockCommand.TimeOffsetSet:
+            case ScheduleEntryLockCommand.TimeOffsetGet:
+                return this.version >= 2;
+            case ScheduleEntryLockCommand.DailyRepeatingScheduleSet:
+            case ScheduleEntryLockCommand.DailyRepeatingScheduleGet:
+                return this.version >= 3;
+        }
+        return super.supportsCommand(cmd);
+    }
+    /**
+     * Enables or disables schedules. If a user ID is given, that user's
+     * schedules will be enabled or disabled. If no user ID is given, all schedules
+     * will be affected.
+     */
+    async setEnabled(enabled, userId) {
+        __assertType("enabled", "boolean", __assertType__boolean.bind(void 0, enabled));
+        __assertType("userId", "(optional) number", __assertType__optional_number.bind(void 0, userId));
+        let result;
+        if (userId != undefined) {
+            this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.EnableSet);
+            const cc = new ScheduleEntryLockCCEnableSet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                userId,
+                enabled,
+            });
+            result = await this.host.sendCommand(cc, this.commandOptions);
+        }
+        else {
+            this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.EnableAllSet);
+            const cc = new ScheduleEntryLockCCEnableAllSet({
+                nodeId: this.endpoint.nodeId,
+                endpointIndex: this.endpoint.index,
+                enabled,
+            });
+            result = await this.host.sendCommand(cc, this.commandOptions);
+        }
+        if (this.isSinglecast() && isUnsupervisedOrSucceeded(result)) {
+            // Remember the new state in the cache
+            setUserCodeScheduleEnabledCached(this.host, this.endpoint, userId, enabled);
+        }
+        return result;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async getNumSlots() {
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.SupportedGet);
+        const cc = new ScheduleEntryLockCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (result) {
+            return pick(result, [
+                "numWeekDaySlots",
+                "numYearDaySlots",
+                "numDailyRepeatingSlots",
+            ]);
+        }
+    }
+    async setWeekDaySchedule(slot, schedule) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        __assertType("schedule", "(optional) ScheduleEntryLockWeekDaySchedule", __assertType__optional_ScheduleEntryLockWeekDaySchedule.bind(void 0, schedule));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.WeekDayScheduleSet);
+        if (this.isSinglecast()) {
+            const numSlots = ScheduleEntryLockCC.getNumWeekDaySlotsCached(this.host, this.endpoint);
+            if (slot.slotId < 1 || slot.slotId > numSlots) {
+                throw new ZWaveError(`The schedule slot # must be between 1 and the number of supported day-of-week slots ${numSlots}.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        if (schedule) {
+            if (schedule.stopHour < schedule.startHour
+                || schedule.stopHour === schedule.startHour
+                    && schedule.stopMinute <= schedule.startMinute) {
+                throw new ZWaveError(`The stop time must be after the start time.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        const cc = new ScheduleEntryLockCCWeekDayScheduleSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+            ...(schedule
+                ? {
+                    action: ScheduleEntryLockSetAction.Set,
+                    ...schedule,
+                }
+                : {
+                    action: ScheduleEntryLockSetAction.Erase,
+                }),
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (this.isSinglecast() && isUnsupervisedOrSucceeded(result)) {
+            // Editing (but not erasing) a schedule will enable scheduling for that user
+            // and switch it to the current scheduling kind
+            if (!!schedule) {
+                setUserCodeScheduleEnabledCached(this.host, this.endpoint, slot.userId, true);
+                setUserCodeScheduleKindCached(this.host, this.endpoint, slot.userId, ScheduleEntryLockScheduleKind.WeekDay);
+            }
+            // And cache the schedule
+            persistSchedule.call(cc, this.host, ScheduleEntryLockScheduleKind.WeekDay, slot.userId, slot.slotId, schedule ?? false);
+        }
+        return result;
+    }
+    async getWeekDaySchedule(slot) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.WeekDayScheduleSet);
+        const cc = new ScheduleEntryLockCCWeekDayScheduleGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (result?.weekday != undefined) {
+            return {
+                weekday: result.weekday,
+                startHour: result.startHour,
+                startMinute: result.startMinute,
+                stopHour: result.stopHour,
+                stopMinute: result.stopMinute,
+            };
+        }
+    }
+    async setYearDaySchedule(slot, schedule) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        __assertType("schedule", "(optional) ScheduleEntryLockYearDaySchedule", __assertType__optional_ScheduleEntryLockYearDaySchedule.bind(void 0, schedule));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.YearDayScheduleSet);
+        if (this.isSinglecast()) {
+            const numSlots = ScheduleEntryLockCC.getNumYearDaySlotsCached(this.host, this.endpoint);
+            if (slot.slotId < 1 || slot.slotId > numSlots) {
+                throw new ZWaveError(`The schedule slot # must be between 1 and the number of supported day-of-year slots ${numSlots}.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        if (schedule) {
+            const startDate = new Date(schedule.startYear, schedule.startMonth - 1, schedule.startDay, schedule.startHour, schedule.startMinute);
+            const stopDate = new Date(schedule.stopYear, schedule.stopMonth - 1, schedule.stopDay, schedule.stopHour, schedule.stopMinute);
+            if (stopDate <= startDate) {
+                throw new ZWaveError(`The stop date must be after the start date.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        const cc = new ScheduleEntryLockCCYearDayScheduleSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+            ...(schedule
+                ? {
+                    action: ScheduleEntryLockSetAction.Set,
+                    ...schedule,
+                }
+                : {
+                    action: ScheduleEntryLockSetAction.Erase,
+                }),
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (this.isSinglecast() && isUnsupervisedOrSucceeded(result)) {
+            // Editing (but not erasing) a schedule will enable scheduling for that user
+            // and switch it to the current scheduling kind
+            if (!!schedule) {
+                setUserCodeScheduleEnabledCached(this.host, this.endpoint, slot.userId, true);
+                setUserCodeScheduleKindCached(this.host, this.endpoint, slot.userId, ScheduleEntryLockScheduleKind.YearDay);
+            }
+            // And cache the schedule
+            persistSchedule.call(cc, this.host, ScheduleEntryLockScheduleKind.YearDay, slot.userId, slot.slotId, schedule ?? false);
+        }
+        return result;
+    }
+    async getYearDaySchedule(slot) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.YearDayScheduleSet);
+        const cc = new ScheduleEntryLockCCYearDayScheduleGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (result?.startYear != undefined) {
+            return {
+                startYear: result.startYear,
+                startMonth: result.startMonth,
+                startDay: result.startDay,
+                startHour: result.startHour,
+                startMinute: result.startMinute,
+                stopYear: result.stopYear,
+                stopMonth: result.stopMonth,
+                stopDay: result.stopDay,
+                stopHour: result.stopHour,
+                stopMinute: result.stopMinute,
+            };
+        }
+    }
+    async setDailyRepeatingSchedule(slot, schedule) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        __assertType("schedule", "(optional) ScheduleEntryLockDailyRepeatingSchedule", __assertType__optional_ScheduleEntryLockDailyRepeatingSchedule.bind(void 0, schedule));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.DailyRepeatingScheduleSet);
+        if (this.isSinglecast()) {
+            const numSlots = ScheduleEntryLockCC
+                .getNumDailyRepeatingSlotsCached(this.host, this.endpoint);
+            if (slot.slotId < 1 || slot.slotId > numSlots) {
+                throw new ZWaveError(`The schedule slot # must be between 1 and the number of supported daily repeating slots ${numSlots}.`, ZWaveErrorCodes.Argument_Invalid);
+            }
+        }
+        const cc = new ScheduleEntryLockCCDailyRepeatingScheduleSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+            ...(schedule
+                ? {
+                    action: ScheduleEntryLockSetAction.Set,
+                    ...schedule,
+                }
+                : {
+                    action: ScheduleEntryLockSetAction.Erase,
+                }),
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (this.isSinglecast() && isUnsupervisedOrSucceeded(result)) {
+            // Editing (but not erasing) a schedule will enable scheduling for that user
+            // and switch it to the current scheduling kind
+            if (!!schedule) {
+                setUserCodeScheduleEnabledCached(this.host, this.endpoint, slot.userId, true);
+                setUserCodeScheduleKindCached(this.host, this.endpoint, slot.userId, ScheduleEntryLockScheduleKind.DailyRepeating);
+            }
+            // And cache the schedule
+            persistSchedule.call(cc, this.host, ScheduleEntryLockScheduleKind.DailyRepeating, slot.userId, slot.slotId, schedule ?? false);
+        }
+        return result;
+    }
+    async getDailyRepeatingSchedule(slot) {
+        __assertType("slot", "ScheduleEntryLockSlotId", __assertType__ScheduleEntryLockSlotId.bind(void 0, slot));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.DailyRepeatingScheduleSet);
+        const cc = new ScheduleEntryLockCCDailyRepeatingScheduleGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...slot,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (result?.weekdays != undefined) {
+            return {
+                weekdays: result.weekdays,
+                startHour: result.startHour,
+                startMinute: result.startMinute,
+                durationHour: result.durationHour,
+                durationMinute: result.durationMinute,
+            };
+        }
+    }
+    async getTimezone() {
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.TimeOffsetGet);
+        const cc = new ScheduleEntryLockCCTimeOffsetGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (result) {
+            return pick(result, ["standardOffset", "dstOffset"]);
+        }
+    }
+    async setTimezone(timezone) {
+        __assertType("timezone", "Timezone", __assertType__Timezone.bind(void 0, timezone));
+        this.assertSupportsCommand(ScheduleEntryLockCommand, ScheduleEntryLockCommand.TimeOffsetSet);
+        const cc = new ScheduleEntryLockCCTimeOffsetSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...timezone,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+};
+ScheduleEntryLockCCAPI = __decorate([
+    API(CommandClasses["Schedule Entry Lock"])
+], ScheduleEntryLockCCAPI);
+export { ScheduleEntryLockCCAPI };
+let ScheduleEntryLockCC = class ScheduleEntryLockCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Schedule Entry Lock"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "Querying supported number of schedule slots...",
+            direction: "outbound",
+        });
+        const slotsResp = await api.getNumSlots();
+        if (slotsResp) {
+            let logMessage = `received supported number of schedule slots:
+day of week:     ${slotsResp.numWeekDaySlots}
+day of year:     ${slotsResp.numYearDaySlots}`;
+            if (slotsResp.numDailyRepeatingSlots != undefined) {
+                logMessage += `
+daily repeating: ${slotsResp.numDailyRepeatingSlots}`;
+            }
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: logMessage,
+                direction: "inbound",
+            });
+        }
+        // If the timezone is not configured with the Time CC, do it here
+        if (api.supportsCommand(ScheduleEntryLockCommand.TimeOffsetSet)
+            && (!endpoint.supportsCC(CommandClasses.Time)
+                || endpoint.getCCVersion(CommandClasses.Time) < 2)) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "setting timezone information...",
+                direction: "outbound",
+            });
+            // Set the correct timezone on this node
+            const timezone = getDSTInfo();
+            await api.setTimezone(timezone);
+        }
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    /**
+     * Returns the number of supported day-of-week slots.
+     * This only works AFTER the interview process
+     */
+    static getNumWeekDaySlotsCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.numWeekDaySlots.endpoint(endpoint.index)) || 0;
+    }
+    /**
+     * Returns the number of supported day-of-year slots.
+     * This only works AFTER the interview process
+     */
+    static getNumYearDaySlotsCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.numYearDaySlots.endpoint(endpoint.index)) || 0;
+    }
+    /**
+     * Returns the number of supported daily-repeating slots.
+     * This only works AFTER the interview process
+     */
+    static getNumDailyRepeatingSlotsCached(ctx, endpoint) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.numDailyRepeatingSlots.endpoint(endpoint.index)) || 0;
+    }
+    /**
+     * Returns whether scheduling for a given user ID (most likely) enabled. Since the Schedule Entry Lock CC
+     * provides no way to query the enabled state, Z-Wave JS tracks this in its own cache.
+     *
+     * This only works AFTER the interview process and is likely to be wrong if a device
+     * with existing schedules is queried. To be sure, disable scheduling for all users and enable
+     * only the desired ones.
+     */
+    static getUserCodeScheduleEnabledCached(ctx, endpoint, userId) {
+        return !!ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.userEnabled(userId).endpoint(endpoint.index));
+    }
+    /**
+     * Returns which scheduling kind is (most likely) enabled for a given user ID . Since the Schedule Entry Lock CC
+     * provides no way to query the current state, Z-Wave JS tracks this in its own cache.
+     *
+     * This only works AFTER the interview process and is likely to be wrong if a device
+     * with existing schedules is queried. To be sure, edit a schedule of the desired kind
+     * which will automatically switch the user to that scheduling kind.
+     */
+    static getUserCodeScheduleKindCached(ctx, endpoint, userId) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.scheduleKind(userId).endpoint(endpoint.index));
+    }
+    /**
+     * Returns the assumed state of a schedule. Since the Schedule Entry Lock CC
+     * provides no way to query the current state, Z-Wave JS tracks this in its own cache.
+     *
+     * A return value of `false` means the slot is empty, a return value of `undefined` means the information is not cached yet.
+     *
+     * This only works AFTER the interview process.
+     */
+    static getScheduleCached(ctx, endpoint, scheduleKind, userId, slotId) {
+        return ctx
+            .getValueDB(endpoint.nodeId)
+            .getValue(ScheduleEntryLockCCValues.schedule(scheduleKind, userId, slotId).endpoint(endpoint.index));
+    }
+};
+ScheduleEntryLockCC = __decorate([
+    commandClass(CommandClasses["Schedule Entry Lock"]),
+    implementedVersion(3),
+    ccValues(ScheduleEntryLockCCValues)
+], ScheduleEntryLockCC);
+export { ScheduleEntryLockCC };
+let ScheduleEntryLockCCEnableSet = ScheduleEntryLockCCEnableSet_1 = class ScheduleEntryLockCCEnableSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.enabled = options.enabled;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const enabled = raw.payload[1] === 0x01;
+        return new ScheduleEntryLockCCEnableSet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            enabled,
+        });
+    }
+    userId;
+    enabled;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId, this.enabled ? 0x01 : 0x00]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user ID": this.userId,
+                action: this.enabled ? "enable" : "disable",
+            },
+        };
+    }
+};
+ScheduleEntryLockCCEnableSet = ScheduleEntryLockCCEnableSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.EnableSet),
+    useSupervision()
+], ScheduleEntryLockCCEnableSet);
+export { ScheduleEntryLockCCEnableSet };
+let ScheduleEntryLockCCEnableAllSet = ScheduleEntryLockCCEnableAllSet_1 = class ScheduleEntryLockCCEnableAllSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.enabled = options.enabled;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const enabled = raw.payload[0] === 0x01;
+        return new ScheduleEntryLockCCEnableAllSet_1({
+            nodeId: ctx.sourceNodeId,
+            enabled,
+        });
+    }
+    enabled;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.enabled ? 0x01 : 0x00]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                action: this.enabled ? "enable all" : "disable all",
+            },
+        };
+    }
+};
+ScheduleEntryLockCCEnableAllSet = ScheduleEntryLockCCEnableAllSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.EnableAllSet),
+    useSupervision()
+], ScheduleEntryLockCCEnableAllSet);
+export { ScheduleEntryLockCCEnableAllSet };
+let ScheduleEntryLockCCSupportedReport = ScheduleEntryLockCCSupportedReport_1 = class ScheduleEntryLockCCSupportedReport extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.numWeekDaySlots = options.numWeekDaySlots;
+        this.numYearDaySlots = options.numYearDaySlots;
+        this.numDailyRepeatingSlots = options.numDailyRepeatingSlots;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const numWeekDaySlots = raw.payload[0];
+        const numYearDaySlots = raw.payload[1];
+        let numDailyRepeatingSlots;
+        if (raw.payload.length >= 3) {
+            numDailyRepeatingSlots = raw.payload[2];
+        }
+        return new ScheduleEntryLockCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            numWeekDaySlots,
+            numYearDaySlots,
+            numDailyRepeatingSlots,
+        });
+    }
+    numWeekDaySlots;
+    numYearDaySlots;
+    numDailyRepeatingSlots;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.numWeekDaySlots,
+            this.numYearDaySlots,
+            this.numDailyRepeatingSlots ?? 0,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "no. of weekday schedule slots": this.numWeekDaySlots,
+            "no. of day-of-year schedule slots": this.numYearDaySlots,
+        };
+        if (this.numDailyRepeatingSlots != undefined) {
+            message["no. of daily repeating schedule slots"] =
+                this.numDailyRepeatingSlots;
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(ScheduleEntryLockCCValues.numWeekDaySlots)
+], ScheduleEntryLockCCSupportedReport.prototype, "numWeekDaySlots", void 0);
+__decorate([
+    ccValue(ScheduleEntryLockCCValues.numYearDaySlots)
+], ScheduleEntryLockCCSupportedReport.prototype, "numYearDaySlots", void 0);
+__decorate([
+    ccValue(ScheduleEntryLockCCValues.numDailyRepeatingSlots)
+], ScheduleEntryLockCCSupportedReport.prototype, "numDailyRepeatingSlots", void 0);
+ScheduleEntryLockCCSupportedReport = ScheduleEntryLockCCSupportedReport_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.SupportedReport)
+], ScheduleEntryLockCCSupportedReport);
+export { ScheduleEntryLockCCSupportedReport };
+let ScheduleEntryLockCCSupportedGet = class ScheduleEntryLockCCSupportedGet extends ScheduleEntryLockCC {
+};
+ScheduleEntryLockCCSupportedGet = __decorate([
+    CCCommand(ScheduleEntryLockCommand.SupportedGet),
+    expectedCCResponse(ScheduleEntryLockCCSupportedReport)
+], ScheduleEntryLockCCSupportedGet);
+export { ScheduleEntryLockCCSupportedGet };
+let ScheduleEntryLockCCWeekDayScheduleSet = ScheduleEntryLockCCWeekDayScheduleSet_1 = class ScheduleEntryLockCCWeekDayScheduleSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.action = options.action;
+        if (options.action === ScheduleEntryLockSetAction.Set) {
+            this.weekday = options.weekday;
+            this.startHour = options.startHour;
+            this.startMinute = options.startMinute;
+            this.stopHour = options.stopHour;
+            this.stopMinute = options.stopMinute;
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const action = raw.payload[0];
+        validatePayload(action === ScheduleEntryLockSetAction.Set
+            || action === ScheduleEntryLockSetAction.Erase);
+        const userId = raw.payload[1];
+        const slotId = raw.payload[2];
+        if (action !== ScheduleEntryLockSetAction.Set) {
+            return new ScheduleEntryLockCCWeekDayScheduleSet_1({
+                nodeId: ctx.sourceNodeId,
+                action,
+                userId,
+                slotId,
+            });
+        }
+        validatePayload(raw.payload.length >= 8);
+        const weekday = raw.payload[3];
+        const startHour = raw.payload[4];
+        const startMinute = raw.payload[5];
+        const stopHour = raw.payload[6];
+        const stopMinute = raw.payload[7];
+        return new ScheduleEntryLockCCWeekDayScheduleSet_1({
+            nodeId: ctx.sourceNodeId,
+            action,
+            userId,
+            slotId,
+            weekday,
+            startHour,
+            startMinute,
+            stopHour,
+            stopMinute,
+        });
+    }
+    userId;
+    slotId;
+    action;
+    weekday;
+    startHour;
+    startMinute;
+    stopHour;
+    stopMinute;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.action,
+            this.userId,
+            this.slotId,
+            // The report should have these fields set to 0xff
+            // if the slot is erased. The specs don't mention anything
+            // for the Set command, so we just assume the same is okay
+            this.weekday ?? 0xff,
+            this.startHour ?? 0xff,
+            this.startMinute ?? 0xff,
+            this.stopHour ?? 0xff,
+            this.stopMinute ?? 0xff,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (this.action === ScheduleEntryLockSetAction.Erase) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "erase",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "set",
+                weekday: getEnumMemberName(ScheduleEntryLockWeekday, this.weekday),
+                "start time": formatTime(this.startHour ?? 0, this.startMinute ?? 0),
+                "end time": formatTime(this.stopHour ?? 0, this.stopMinute ?? 0),
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCWeekDayScheduleSet = ScheduleEntryLockCCWeekDayScheduleSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.WeekDayScheduleSet),
+    useSupervision()
+], ScheduleEntryLockCCWeekDayScheduleSet);
+export { ScheduleEntryLockCCWeekDayScheduleSet };
+let ScheduleEntryLockCCWeekDayScheduleReport = ScheduleEntryLockCCWeekDayScheduleReport_1 = class ScheduleEntryLockCCWeekDayScheduleReport extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.weekday = options.weekday;
+        this.startHour = options.startHour;
+        this.startMinute = options.startMinute;
+        this.stopHour = options.stopHour;
+        this.stopMinute = options.stopMinute;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        let ccOptions = {
+            userId,
+            slotId,
+        };
+        let weekday;
+        let startHour;
+        let startMinute;
+        let stopHour;
+        let stopMinute;
+        if (raw.payload.length >= 7) {
+            if (raw.payload[2] !== 0xff) {
+                weekday = raw.payload[2];
+            }
+            if (raw.payload[3] !== 0xff) {
+                startHour = raw.payload[3];
+            }
+            if (raw.payload[4] !== 0xff) {
+                startMinute = raw.payload[4];
+            }
+            if (raw.payload[5] !== 0xff) {
+                stopHour = raw.payload[5];
+            }
+            if (raw.payload[6] !== 0xff) {
+                stopMinute = raw.payload[6];
+            }
+        }
+        if (weekday != undefined
+            && startHour != undefined
+            && startMinute != undefined
+            && stopHour != undefined
+            && stopMinute != undefined) {
+            ccOptions = {
+                ...ccOptions,
+                weekday,
+                startHour,
+                startMinute,
+                stopHour,
+                stopMinute,
+            };
+        }
+        return new ScheduleEntryLockCCWeekDayScheduleReport_1({
+            nodeId: ctx.sourceNodeId,
+            ...ccOptions,
+        });
+    }
+    userId;
+    slotId;
+    weekday;
+    startHour;
+    startMinute;
+    stopHour;
+    stopMinute;
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        persistSchedule.call(this, ctx, ScheduleEntryLockScheduleKind.WeekDay, this.userId, this.slotId, this.weekday != undefined
+            ? {
+                weekday: this.weekday,
+                startHour: this.startHour,
+                startMinute: this.startMinute,
+                stopHour: this.stopHour,
+                stopMinute: this.stopMinute,
+            }
+            : false);
+        return true;
+    }
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.userId,
+            this.slotId,
+            this.weekday ?? 0xff,
+            this.startHour ?? 0xff,
+            this.startMinute ?? 0xff,
+            this.stopHour ?? 0xff,
+            this.stopMinute ?? 0xff,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (this.weekday == undefined) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                schedule: "(empty)",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                weekday: getEnumMemberName(ScheduleEntryLockWeekday, this.weekday),
+                "start time": formatTime(this.startHour ?? 0, this.startMinute ?? 0),
+                "end time": formatTime(this.stopHour ?? 0, this.stopMinute ?? 0),
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCWeekDayScheduleReport = ScheduleEntryLockCCWeekDayScheduleReport_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.WeekDayScheduleReport)
+], ScheduleEntryLockCCWeekDayScheduleReport);
+export { ScheduleEntryLockCCWeekDayScheduleReport };
+let ScheduleEntryLockCCWeekDayScheduleGet = ScheduleEntryLockCCWeekDayScheduleGet_1 = class ScheduleEntryLockCCWeekDayScheduleGet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        return new ScheduleEntryLockCCWeekDayScheduleGet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            slotId,
+        });
+    }
+    userId;
+    slotId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId, this.slotId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+            },
+        };
+    }
+};
+ScheduleEntryLockCCWeekDayScheduleGet = ScheduleEntryLockCCWeekDayScheduleGet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.WeekDayScheduleGet),
+    expectedCCResponse(ScheduleEntryLockCCWeekDayScheduleReport)
+], ScheduleEntryLockCCWeekDayScheduleGet);
+export { ScheduleEntryLockCCWeekDayScheduleGet };
+let ScheduleEntryLockCCYearDayScheduleSet = ScheduleEntryLockCCYearDayScheduleSet_1 = class ScheduleEntryLockCCYearDayScheduleSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.action = options.action;
+        if (options.action === ScheduleEntryLockSetAction.Set) {
+            this.startYear = options.startYear;
+            this.startMonth = options.startMonth;
+            this.startDay = options.startDay;
+            this.startHour = options.startHour;
+            this.startMinute = options.startMinute;
+            this.stopYear = options.stopYear;
+            this.stopMonth = options.stopMonth;
+            this.stopDay = options.stopDay;
+            this.stopHour = options.stopHour;
+            this.stopMinute = options.stopMinute;
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const action = raw.payload[0];
+        validatePayload(action === ScheduleEntryLockSetAction.Set
+            || action === ScheduleEntryLockSetAction.Erase);
+        const userId = raw.payload[1];
+        const slotId = raw.payload[2];
+        if (action !== ScheduleEntryLockSetAction.Set) {
+            return new ScheduleEntryLockCCYearDayScheduleSet_1({
+                nodeId: ctx.sourceNodeId,
+                action,
+                userId,
+                slotId,
+            });
+        }
+        validatePayload(raw.payload.length >= 13);
+        const startYear = raw.payload[3];
+        const startMonth = raw.payload[4];
+        const startDay = raw.payload[5];
+        const startHour = raw.payload[6];
+        const startMinute = raw.payload[7];
+        const stopYear = raw.payload[8];
+        const stopMonth = raw.payload[9];
+        const stopDay = raw.payload[10];
+        const stopHour = raw.payload[11];
+        const stopMinute = raw.payload[12];
+        return new ScheduleEntryLockCCYearDayScheduleSet_1({
+            nodeId: ctx.sourceNodeId,
+            action,
+            userId,
+            slotId,
+            startYear,
+            startMonth,
+            startDay,
+            startHour,
+            startMinute,
+            stopYear,
+            stopMonth,
+            stopDay,
+            stopHour,
+            stopMinute,
+        });
+    }
+    userId;
+    slotId;
+    action;
+    startYear;
+    startMonth;
+    startDay;
+    startHour;
+    startMinute;
+    stopYear;
+    stopMonth;
+    stopDay;
+    stopHour;
+    stopMinute;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.action,
+            this.userId,
+            this.slotId,
+            // The report should have these fields set to 0xff
+            // if the slot is erased. The specs don't mention anything
+            // for the Set command, so we just assume the same is okay
+            this.startYear ?? 0xff,
+            this.startMonth ?? 0xff,
+            this.startDay ?? 0xff,
+            this.startHour ?? 0xff,
+            this.startMinute ?? 0xff,
+            this.stopYear ?? 0xff,
+            this.stopMonth ?? 0xff,
+            this.stopDay ?? 0xff,
+            this.stopHour ?? 0xff,
+            this.stopMinute ?? 0xff,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (this.action === ScheduleEntryLockSetAction.Erase) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "erase",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "set",
+                "start date": `${formatDate(this.startYear ?? 0, this.startMonth ?? 0, this.startDay ?? 0)} ${formatTime(this.startHour ?? 0, this.startMinute ?? 0)}`,
+                "end date": `${formatDate(this.stopYear ?? 0, this.stopMonth ?? 0, this.stopDay ?? 0)} ${formatTime(this.stopHour ?? 0, this.stopMinute ?? 0)}`,
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCYearDayScheduleSet = ScheduleEntryLockCCYearDayScheduleSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.YearDayScheduleSet),
+    useSupervision()
+], ScheduleEntryLockCCYearDayScheduleSet);
+export { ScheduleEntryLockCCYearDayScheduleSet };
+let ScheduleEntryLockCCYearDayScheduleReport = ScheduleEntryLockCCYearDayScheduleReport_1 = class ScheduleEntryLockCCYearDayScheduleReport extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.startYear = options.startYear;
+        this.startMonth = options.startMonth;
+        this.startDay = options.startDay;
+        this.startHour = options.startHour;
+        this.startMinute = options.startMinute;
+        this.stopYear = options.stopYear;
+        this.stopMonth = options.stopMonth;
+        this.stopDay = options.stopDay;
+        this.stopHour = options.stopHour;
+        this.stopMinute = options.stopMinute;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        let ccOptions = {
+            userId,
+            slotId,
+        };
+        let startYear;
+        let startMonth;
+        let startDay;
+        let startHour;
+        let startMinute;
+        let stopYear;
+        let stopMonth;
+        let stopDay;
+        let stopHour;
+        let stopMinute;
+        if (raw.payload.length >= 12) {
+            if (raw.payload[2] !== 0xff) {
+                startYear = raw.payload[2];
+            }
+            if (raw.payload[3] !== 0xff) {
+                startMonth = raw.payload[3];
+            }
+            if (raw.payload[4] !== 0xff) {
+                startDay = raw.payload[4];
+            }
+            if (raw.payload[5] !== 0xff) {
+                startHour = raw.payload[5];
+            }
+            if (raw.payload[6] !== 0xff) {
+                startMinute = raw.payload[6];
+            }
+            if (raw.payload[7] !== 0xff) {
+                stopYear = raw.payload[7];
+            }
+            if (raw.payload[8] !== 0xff) {
+                stopMonth = raw.payload[8];
+            }
+            if (raw.payload[9] !== 0xff) {
+                stopDay = raw.payload[9];
+            }
+            if (raw.payload[10] !== 0xff) {
+                stopHour = raw.payload[10];
+            }
+            if (raw.payload[11] !== 0xff) {
+                stopMinute = raw.payload[11];
+            }
+        }
+        if (startYear != undefined
+            && startMonth != undefined
+            && startDay != undefined
+            && startHour != undefined
+            && startMinute != undefined
+            && stopYear != undefined
+            && stopMonth != undefined
+            && stopDay != undefined
+            && stopHour != undefined
+            && stopMinute != undefined) {
+            ccOptions = {
+                ...ccOptions,
+                startYear,
+                startMonth,
+                startDay,
+                startHour,
+                startMinute,
+                stopYear,
+                stopMonth,
+                stopDay,
+                stopHour,
+                stopMinute,
+            };
+        }
+        return new ScheduleEntryLockCCYearDayScheduleReport_1({
+            nodeId: ctx.sourceNodeId,
+            ...ccOptions,
+        });
+    }
+    userId;
+    slotId;
+    startYear;
+    startMonth;
+    startDay;
+    startHour;
+    startMinute;
+    stopYear;
+    stopMonth;
+    stopDay;
+    stopHour;
+    stopMinute;
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        persistSchedule.call(this, ctx, ScheduleEntryLockScheduleKind.YearDay, this.userId, this.slotId, this.startYear != undefined
+            ? {
+                startYear: this.startYear,
+                startMonth: this.startMonth,
+                startDay: this.startDay,
+                startHour: this.startHour,
+                startMinute: this.startMinute,
+                stopYear: this.stopYear,
+                stopMonth: this.stopMonth,
+                stopDay: this.stopDay,
+                stopHour: this.stopHour,
+                stopMinute: this.stopMinute,
+            }
+            : false);
+        return true;
+    }
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.userId,
+            this.slotId,
+            this.startYear ?? 0xff,
+            this.startMonth ?? 0xff,
+            this.startDay ?? 0xff,
+            this.startHour ?? 0xff,
+            this.startMinute ?? 0xff,
+            this.stopYear ?? 0xff,
+            this.stopMonth ?? 0xff,
+            this.stopDay ?? 0xff,
+            this.stopHour ?? 0xff,
+            this.stopMinute ?? 0xff,
+        ]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (this.startYear !== undefined) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                schedule: "(empty)",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "set",
+                "start date": `${formatDate(this.startYear ?? 0, this.startMonth ?? 0, this.startDay ?? 0)} ${formatTime(this.startHour ?? 0, this.startMinute ?? 0)}`,
+                "end date": `${formatDate(this.stopYear ?? 0, this.stopMonth ?? 0, this.stopDay ?? 0)} ${formatTime(this.stopHour ?? 0, this.stopMinute ?? 0)}`,
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCYearDayScheduleReport = ScheduleEntryLockCCYearDayScheduleReport_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.YearDayScheduleReport)
+], ScheduleEntryLockCCYearDayScheduleReport);
+export { ScheduleEntryLockCCYearDayScheduleReport };
+let ScheduleEntryLockCCYearDayScheduleGet = ScheduleEntryLockCCYearDayScheduleGet_1 = class ScheduleEntryLockCCYearDayScheduleGet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        return new ScheduleEntryLockCCYearDayScheduleGet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            slotId,
+        });
+    }
+    userId;
+    slotId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId, this.slotId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+            },
+        };
+    }
+};
+ScheduleEntryLockCCYearDayScheduleGet = ScheduleEntryLockCCYearDayScheduleGet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.YearDayScheduleGet),
+    expectedCCResponse(ScheduleEntryLockCCYearDayScheduleReport)
+], ScheduleEntryLockCCYearDayScheduleGet);
+export { ScheduleEntryLockCCYearDayScheduleGet };
+let ScheduleEntryLockCCTimeOffsetSet = ScheduleEntryLockCCTimeOffsetSet_1 = class ScheduleEntryLockCCTimeOffsetSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.standardOffset = options.standardOffset;
+        this.dstOffset = options.dstOffset;
+    }
+    static from(raw, ctx) {
+        const { standardOffset, dstOffset } = parseTimezone(raw.payload);
+        return new ScheduleEntryLockCCTimeOffsetSet_1({
+            nodeId: ctx.sourceNodeId,
+            standardOffset,
+            dstOffset,
+        });
+    }
+    standardOffset;
+    dstOffset;
+    serialize(ctx) {
+        this.payload = encodeTimezone({
+            standardOffset: this.standardOffset,
+            dstOffset: this.dstOffset,
+        });
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "standard time offset": `${this.standardOffset} minutes`,
+                "DST offset": `${this.dstOffset} minutes`,
+            },
+        };
+    }
+};
+ScheduleEntryLockCCTimeOffsetSet = ScheduleEntryLockCCTimeOffsetSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.TimeOffsetSet),
+    useSupervision()
+], ScheduleEntryLockCCTimeOffsetSet);
+export { ScheduleEntryLockCCTimeOffsetSet };
+let ScheduleEntryLockCCTimeOffsetReport = ScheduleEntryLockCCTimeOffsetReport_1 = class ScheduleEntryLockCCTimeOffsetReport extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.standardOffset = options.standardOffset;
+        this.dstOffset = options.dstOffset;
+    }
+    static from(raw, ctx) {
+        const { standardOffset, dstOffset } = parseTimezone(raw.payload);
+        return new ScheduleEntryLockCCTimeOffsetReport_1({
+            nodeId: ctx.sourceNodeId,
+            standardOffset,
+            dstOffset,
+        });
+    }
+    standardOffset;
+    dstOffset;
+    serialize(ctx) {
+        this.payload = encodeTimezone({
+            standardOffset: this.standardOffset,
+            dstOffset: this.dstOffset,
+        });
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "standard time offset": `${this.standardOffset} minutes`,
+                "DST offset": `${this.dstOffset} minutes`,
+            },
+        };
+    }
+};
+ScheduleEntryLockCCTimeOffsetReport = ScheduleEntryLockCCTimeOffsetReport_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.TimeOffsetReport)
+], ScheduleEntryLockCCTimeOffsetReport);
+export { ScheduleEntryLockCCTimeOffsetReport };
+let ScheduleEntryLockCCTimeOffsetGet = class ScheduleEntryLockCCTimeOffsetGet extends ScheduleEntryLockCC {
+};
+ScheduleEntryLockCCTimeOffsetGet = __decorate([
+    CCCommand(ScheduleEntryLockCommand.TimeOffsetGet),
+    expectedCCResponse(ScheduleEntryLockCCTimeOffsetReport)
+], ScheduleEntryLockCCTimeOffsetGet);
+export { ScheduleEntryLockCCTimeOffsetGet };
+let ScheduleEntryLockCCDailyRepeatingScheduleSet = ScheduleEntryLockCCDailyRepeatingScheduleSet_1 = class ScheduleEntryLockCCDailyRepeatingScheduleSet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.action = options.action;
+        if (options.action === ScheduleEntryLockSetAction.Set) {
+            this.weekdays = options.weekdays;
+            this.startHour = options.startHour;
+            this.startMinute = options.startMinute;
+            this.durationHour = options.durationHour;
+            this.durationMinute = options.durationMinute;
+        }
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const action = raw.payload[0];
+        validatePayload(action === ScheduleEntryLockSetAction.Set
+            || action === ScheduleEntryLockSetAction.Erase);
+        const userId = raw.payload[1];
+        const slotId = raw.payload[2];
+        if (action !== ScheduleEntryLockSetAction.Set) {
+            return new ScheduleEntryLockCCDailyRepeatingScheduleSet_1({
+                nodeId: ctx.sourceNodeId,
+                action,
+                userId,
+                slotId,
+            });
+        }
+        validatePayload(raw.payload.length >= 8);
+        const weekdays = parseBitMask(raw.payload.subarray(3, 4), ScheduleEntryLockWeekday.Sunday);
+        const startHour = raw.payload[4];
+        const startMinute = raw.payload[5];
+        const durationHour = raw.payload[6];
+        const durationMinute = raw.payload[7];
+        return new ScheduleEntryLockCCDailyRepeatingScheduleSet_1({
+            nodeId: ctx.sourceNodeId,
+            action,
+            userId,
+            slotId,
+            weekdays,
+            startHour,
+            startMinute,
+            durationHour,
+            durationMinute,
+        });
+    }
+    userId;
+    slotId;
+    action;
+    weekdays;
+    startHour;
+    startMinute;
+    durationHour;
+    durationMinute;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.action, this.userId, this.slotId]);
+        if (this.action === ScheduleEntryLockSetAction.Set) {
+            this.payload = Bytes.concat([
+                this.payload,
+                encodeBitMask(this.weekdays, ScheduleEntryLockWeekday.Saturday, ScheduleEntryLockWeekday.Sunday),
+                Bytes.from([
+                    this.startHour,
+                    this.startMinute,
+                    this.durationHour,
+                    this.durationMinute,
+                ]),
+            ]);
+        }
+        else {
+            // Not sure if this is correct
+            this.payload = Bytes.concat([this.payload, Bytes.alloc(5, 0xff)]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (this.action === ScheduleEntryLockSetAction.Erase) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "erase",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "set",
+                weekdays: this.weekdays.map((w) => getEnumMemberName(ScheduleEntryLockWeekday, w)).join(", "),
+                "start time": formatTime(this.startHour ?? 0, this.startMinute ?? 0),
+                duration: formatTime(this.durationHour ?? 0, this.durationMinute ?? 0),
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCDailyRepeatingScheduleSet = ScheduleEntryLockCCDailyRepeatingScheduleSet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.DailyRepeatingScheduleSet),
+    useSupervision()
+], ScheduleEntryLockCCDailyRepeatingScheduleSet);
+export { ScheduleEntryLockCCDailyRepeatingScheduleSet };
+let ScheduleEntryLockCCDailyRepeatingScheduleReport = ScheduleEntryLockCCDailyRepeatingScheduleReport_1 = class ScheduleEntryLockCCDailyRepeatingScheduleReport extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+        this.weekdays = options.weekdays;
+        this.startHour = options.startHour;
+        this.startMinute = options.startMinute;
+        this.durationHour = options.durationHour;
+        this.durationMinute = options.durationMinute;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        if (raw.payload.length >= 7 && raw.payload[2] !== 0) {
+            // Only parse the schedule if it is present and some weekday is selected
+            const weekdays = parseBitMask(raw.payload.subarray(2, 3), ScheduleEntryLockWeekday.Sunday);
+            const startHour = raw.payload[3];
+            const startMinute = raw.payload[4];
+            const durationHour = raw.payload[5];
+            const durationMinute = raw.payload[6];
+            return new ScheduleEntryLockCCDailyRepeatingScheduleReport_1({
+                nodeId: ctx.sourceNodeId,
+                userId,
+                slotId,
+                weekdays,
+                startHour,
+                startMinute,
+                durationHour,
+                durationMinute,
+            });
+        }
+        else {
+            return new ScheduleEntryLockCCDailyRepeatingScheduleReport_1({
+                nodeId: ctx.sourceNodeId,
+                userId,
+                slotId,
+            });
+        }
+    }
+    userId;
+    slotId;
+    weekdays;
+    startHour;
+    startMinute;
+    durationHour;
+    durationMinute;
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
+            return false;
+        persistSchedule.call(this, ctx, ScheduleEntryLockScheduleKind.DailyRepeating, this.userId, this.slotId, this.weekdays?.length
+            ? {
+                weekdays: this.weekdays,
+                startHour: this.startHour,
+                startMinute: this.startMinute,
+                durationHour: this.durationHour,
+                durationMinute: this.durationMinute,
+            }
+            : false);
+        return true;
+    }
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId, this.slotId]);
+        if (this.weekdays) {
+            this.payload = Bytes.concat([
+                this.payload,
+                encodeBitMask(this.weekdays, ScheduleEntryLockWeekday.Saturday, ScheduleEntryLockWeekday.Sunday),
+                Bytes.from([
+                    this.startHour,
+                    this.startMinute,
+                    this.durationHour,
+                    this.durationMinute,
+                ]),
+            ]);
+        }
+        else {
+            // Not sure if this is correct, but at least we won't parse it incorrectly ourselves when setting everything to 0
+            this.payload = Bytes.concat([this.payload, Bytes.alloc(5, 0)]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        let message;
+        if (!this.weekdays) {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                schedule: "(empty)",
+            };
+        }
+        else {
+            message = {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+                action: "set",
+                weekdays: this.weekdays
+                    .map((w) => getEnumMemberName(ScheduleEntryLockWeekday, w))
+                    .join(", "),
+                "start time": formatTime(this.startHour ?? 0, this.startMinute ?? 0),
+                duration: formatTime(this.durationHour ?? 0, this.durationMinute ?? 0),
+            };
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ScheduleEntryLockCCDailyRepeatingScheduleReport = ScheduleEntryLockCCDailyRepeatingScheduleReport_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.DailyRepeatingScheduleReport)
+], ScheduleEntryLockCCDailyRepeatingScheduleReport);
+export { ScheduleEntryLockCCDailyRepeatingScheduleReport };
+let ScheduleEntryLockCCDailyRepeatingScheduleGet = ScheduleEntryLockCCDailyRepeatingScheduleGet_1 = class ScheduleEntryLockCCDailyRepeatingScheduleGet extends ScheduleEntryLockCC {
+    constructor(options) {
+        super(options);
+        this.userId = options.userId;
+        this.slotId = options.slotId;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const userId = raw.payload[0];
+        const slotId = raw.payload[1];
+        return new ScheduleEntryLockCCDailyRepeatingScheduleGet_1({
+            nodeId: ctx.sourceNodeId,
+            userId,
+            slotId,
+        });
+    }
+    userId;
+    slotId;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.userId, this.slotId]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "user ID": this.userId,
+                "slot #": this.slotId,
+            },
+        };
+    }
+};
+ScheduleEntryLockCCDailyRepeatingScheduleGet = ScheduleEntryLockCCDailyRepeatingScheduleGet_1 = __decorate([
+    CCCommand(ScheduleEntryLockCommand.DailyRepeatingScheduleGet),
+    expectedCCResponse(ScheduleEntryLockCCDailyRepeatingScheduleReport)
+], ScheduleEntryLockCCDailyRepeatingScheduleGet);
+export { ScheduleEntryLockCCDailyRepeatingScheduleGet };
+//# sourceMappingURL=ScheduleEntryLockCC.js.map