@ray-js/lock-sdk 1.1.3 → 1.2.0-beta.1

package/lib/feature/password/temporary/custom-dp-ble.js

@@ -0,0 +1,263 @@
+import { createTemporaryPassword, deleteTempPassword, fetchEffectiveList, updateTemporaryPassword, } from "../../../api/temp";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { parallelOnlyForRuntime } from "../../utils";
+import { addBleTempPwd as addBleTempPwdDpMap, reportAddBleTempPwd as reportAddBleTempPwdDpMap, updateBleTempPwd as updateBleTempPwdDpMap, reportUpdateTempPwd as reportUpdateTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "../../../config/dp-map/unlock-method";
+import dpCodes from "../../../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { sdkLog } from "../../../utils/sdk-log";
+import { isValidPassword } from "./internal/password-helpers";
+import { prepareCustomTempCreateContext, } from "./custom-dp-create-shared";
+function throwBleTempPwdAddDpReportStatus(status) {
+    switch (status) {
+        case 1:
+            throw getError(1042);
+        case 2:
+            throw getError(1041);
+        case 3:
+            throw getError(1037);
+        default:
+            throw getError(1042);
+    }
+}
+async function publishBleTempCustomUpdateNearDp(rt, sn, validConfig) {
+    const targetDpCode = dpCodes.tempPwdEdit;
+    const reportMap = reportUpdateTempPwdDpMap;
+    const dpPayload = dpUtils.format({
+        unlockId: sn,
+        type: 1,
+        validConfig,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+    }, updateBleTempPwdDpMap);
+    const result = await publishDpsForRuntime(rt, { [targetDpCode]: dpPayload }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(reportData, reportMap);
+                if (data["unlockId"] === sn) {
+                    return data;
+                }
+            }
+            return false;
+        },
+    });
+    if (result.status === 0) {
+        return;
+    }
+    throw getError(1082);
+}
+async function publishBleTempCustomCreateNearDp(rt, params, prepared) {
+    const cfg = rt.config;
+    const { effective, validConfig } = prepared;
+    const targetDpCode = cfg.supportBigData
+        ? dpCodes.tempPwdCreateW
+        : dpCodes.tempPwdCreate;
+    const dpPayload = dpUtils.format({
+        type: 1,
+        validConfig,
+        validNum: 0,
+        pwdLength: params.password.length,
+        pwd: params.password.split("").map(Number),
+    }, addBleTempPwdDpMap);
+    const result = await publishDpsForRuntime(rt, {
+        [targetDpCode]: dpPayload,
+    }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(dpDataRow[targetDpCode], reportAddBleTempPwdDpMap);
+                sdkLog("debug", "tempPassword", "addBleTempPwdReport", {
+                    devId: rt.devId,
+                    data: { status: data.status, unlockId: data.unlockId },
+                });
+                return data;
+            }
+            return false;
+        },
+    });
+    const status = Number(result.status);
+    if (status === 0) {
+        return result.unlockId;
+    }
+    throwBleTempPwdAddDpReportStatus(status);
+}
+export const createTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "createBleCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof params.name === "string",
+            repeat: params.effective?.repeat,
+        },
+    });
+    const prepared = await prepareCustomTempCreateContext(rt, params);
+    await isValidPassword(prepared.baseData);
+    const unlockId = await publishBleTempCustomCreateNearDp(rt, params, prepared);
+    const result = await createTemporaryPassword({
+        ...prepared.baseData,
+        sn: unlockId,
+        availTime: 0,
+    });
+    sdkLog("info", "tempPassword", "createBleCustomSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { unlockId },
+    });
+    return {
+        type: "custom",
+        name: result.name,
+        password: params.password,
+        unlockBindingId: result.unlockBindingId,
+        effectiveConfig: prepared.effective,
+    };
+});
+export const updateTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const { unlockBindingId, name, effective } = params;
+    sdkLog("info", "tempPassword", "updateBleCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "updateBleCustomInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    validateEffectiveConfig(effective);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime: effective?.effectiveTime ?? 0,
+            invalidTime: effective?.expiredTime ?? 0,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const validConfig = {
+        startTime: effective.effectiveDate,
+        endTime: effective.expiredDate,
+        loop: loopType,
+        loopConfig: 0,
+        weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
+        days: [],
+        startHour: Math.floor(effectiveTime / 60),
+        startMinute: effectiveTime % 60,
+        endHour: Math.floor(expiredTime / 60),
+        endMinute: expiredTime % 60,
+    };
+    const cloudPayload = {
+        devId: cfg.devInfo.devId,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        name,
+        schedule,
+        unlockBindingId,
+    };
+    const list = await fetchEffectiveList({
+        devId: cfg.devInfo.devId,
+        authTypes: ["LOCK_OFFLINE_TEMP_PWD", "LOCK_TEMP_PWD"],
+    });
+    const row = list.find((item) => item.unlockBindingId === unlockBindingId);
+    if (!row) {
+        const error = getError(1051);
+        sdkLog("warn", "tempPassword", "updateBleCustomNotFound", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    try {
+        await publishBleTempCustomUpdateNearDp(rt, row.sn, validConfig);
+        const result = await updateTemporaryPassword(cloudPayload);
+        sdkLog("info", "tempPassword", "updateBleCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "updateBleCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+});
+export const removeTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const startedAt = Date.now();
+    const cfg = rt.config;
+    const dpCode = dpCodes.tempPwdDel;
+    sdkLog("info", "tempPassword", "removeBleCustomStart", {
+        devId: rt.devId,
+        data: { sn: params.sn },
+    });
+    try {
+        const result = await publishDpsForRuntime(rt, {
+            [dpCode]: dpUtils.format({ unlockId: params.sn }, removeTempPwdDpMap),
+        }, {
+            checkReport: (dpsIn) => {
+                const dpDataRow = dpsIn;
+                const reportData = dpDataRow[dpCode];
+                if (reportData) {
+                    const data = dpUtils.parse(reportData, reportRemoveTempPwdDpMap);
+                    sdkLog("debug", "tempPassword", "removeTempPwdReport", {
+                        devId: rt.devId,
+                        data: { unlockId: data.unlockId },
+                    });
+                    if (data["unlockId"] === params.sn) {
+                        return data;
+                    }
+                }
+                return false;
+            },
+        });
+        if (result.status !== 0) {
+            const error = getError(1028);
+            sdkLog("warn", "tempPassword", "removeBleCustomDpFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { status: result.status },
+                error,
+            });
+            throw error;
+        }
+        await deleteTempPassword({
+            devId: cfg.devInfo.devId,
+            unlockBindingId: params.unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        sdkLog("info", "tempPassword", "removeBleCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return true;
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "removeBleCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+});

package/lib/feature/password/temporary/custom-dp-create-shared.d.ts

@@ -0,0 +1,34 @@
+import type { EffectiveConfig, TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { LoopTypes } from "../../../utils/constant";
+import type { CreateCustomParams } from "./types";
+export interface CustomTempCreatePrepared {
+    baseData: {
+        devId: string;
+        effectiveTime: number;
+        invalidTime: number;
+        name?: string;
+        password: string;
+        schedule: {
+            allDay: boolean;
+            effectiveTime: number;
+            invalidTime: number;
+            workingDay: number;
+        }[];
+    };
+    effective: EffectiveConfig;
+    validConfig: {
+        startTime: number;
+        endTime: number;
+        loop: LoopTypes;
+        loopConfig: number;
+        weeks: number[];
+        days: never[];
+        startHour: number;
+        startMinute: number;
+        endHour: number;
+        endMinute: number;
+    };
+}
+export declare function prepareCustomTempCreateContext(rt: LockDeviceRuntime, params: CreateCustomParams): Promise<CustomTempCreatePrepared>;
+export declare function buildTempCustomCreateResult(createdName: string | undefined, passwordPlain: string, unlockBindingId: string, effective: EffectiveConfig): TempPasswordResult;

package/lib/feature/password/temporary/custom-dp-create-shared.js

@@ -0,0 +1,64 @@
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { encrypt } from "../../../platform/device";
+import { getError } from "../../../utils/errors";
+import { PASSWORD_REGEX } from "./internal/password-helpers";
+export async function prepareCustomTempCreateContext(rt, params) {
+    const cfg = rt.config;
+    const { password, name, effective } = params;
+    if (!PASSWORD_REGEX.test(password)) {
+        throw getError(1030);
+    }
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(cfg.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    const baseData = {
+        devId: cfg.devInfo.devId,
+        effectiveTime: effective.effectiveDate,
+        invalidTime: effective.expiredDate,
+        name: name,
+        password: aesPwd,
+        schedule,
+    };
+    const validConfig = {
+        startTime: effective.effectiveDate,
+        endTime: effective.expiredDate,
+        loop: loopType,
+        loopConfig: 0,
+        weeks: effective.weeks ? effective.weeks : [0, 0, 0, 0, 0, 0, 0],
+        days: [],
+        startHour: Math.floor(effectiveTime / 60),
+        startMinute: effectiveTime % 60,
+        endHour: Math.floor(expiredTime / 60),
+        endMinute: expiredTime % 60,
+    };
+    return {
+        baseData,
+        effective,
+        validConfig,
+    };
+}
+export function buildTempCustomCreateResult(createdName, passwordPlain, unlockBindingId, effective) {
+    return {
+        type: "custom",
+        name: createdName ?? "",
+        password: passwordPlain,
+        unlockBindingId,
+        effectiveConfig: effective,
+    };
+}

package/lib/feature/password/temporary/custom-dp.d.ts

@@ -0,0 +1,6 @@
+import type { TempPasswordResult } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { CreateCustomParams, RemoveCustomProps, UpdateTempPasswordParams } from "./types";
+export declare const createTempCustomForRuntime: (this: unknown, rt: LockDeviceRuntime, params: CreateCustomParams) => Promise<TempPasswordResult>;
+export declare function removeTempCustomForRuntime(rt: LockDeviceRuntime, params: RemoveCustomProps): Promise<boolean>;
+export declare function updateTempCustomForRuntime(rt: LockDeviceRuntime, params: UpdateTempPasswordParams): Promise<boolean>;

package/lib/feature/password/temporary/custom-dp.js

@@ -0,0 +1,241 @@
+import { createTemporaryPassword, deleteTempPassword, updateTemporaryPassword, } from "../../../api/temp";
+import { isUseNearChannelForRuntime } from "../../misc/is-use-near-channel-for-runtime";
+import { parallelOnlyForRuntime } from "../../utils";
+import { formatWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { addTempPwd as addTempPwdDpMap, reportAddTempPwd as reportAddTempPwdDpMap, removeTempPwd as removeTempPwdDpMap, reportRemoveTempPwd as reportRemoveTempPwdDpMap, } from "../../../config/dp-map/unlock-method";
+import { addTempPwd as addTempPwdBigDpMap, reportAddTempPwd as reportAddTempPwdDBigpMap, removeTempPwd as removeTempPwdBigDpMap, reportRemoveTempPwd as reportRemoveTempPwdBigDpMap, } from "../../../config/dp-map/unlock-method-big";
+import dpCodes from "../../../config/dp-code";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { isValidPassword } from "./internal/password-helpers";
+import { prepareCustomTempCreateContext, buildTempCustomCreateResult, } from "./custom-dp-create-shared";
+import { sdkLog } from "../../../utils/sdk-log";
+export const createTempCustomForRuntime = parallelOnlyForRuntime(async function (rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    const prepared = await prepareCustomTempCreateContext(rt, params);
+    const { baseData, effective, validConfig } = prepared;
+    const useNear = isUseNearChannelForRuntime(rt);
+    sdkLog("info", "tempPassword", "createCustomStart", {
+        devId: rt.devId,
+        data: {
+            route: useNear ? "nearDp" : "cloud",
+            hasName: typeof params.name === "string",
+            repeat: params.effective?.repeat,
+        },
+    });
+    if (!useNear) {
+        try {
+            const res = await createTemporaryPassword({
+                ...baseData,
+                sn: 0,
+                availTime: 0,
+                symbolic: false,
+                dpTunnel: 2,
+            });
+            sdkLog("info", "tempPassword", "createCustomSuccess", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { route: "cloud" },
+            });
+            return buildTempCustomCreateResult(res.name, params.password, res.unlockBindingId, effective);
+        }
+        catch (error) {
+            sdkLog("error", "tempPassword", "createCustomCloudFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { route: "cloud" },
+                error,
+            });
+            throw handleCloudError(error);
+        }
+    }
+    await isValidPassword(baseData);
+    const { tyNum, name: createdName } = await createTemporaryPassword({
+        ...baseData,
+        sn: 0,
+        availTime: 0,
+        symbolic: false,
+        dpTunnel: 2,
+    });
+    if (!tyNum) {
+        const error = getError(1043);
+        sdkLog("warn", "tempPassword", "createCustomMissingCloudNo", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+    const targetDpCode = cfg.supportBigData
+        ? dpCodes.tempPwdCreateW
+        : dpCodes.tempPwdCreate;
+    const dpPayload = dpUtils.format({
+        cloudNo: tyNum,
+        valid: true,
+        validConfig,
+        validNum: 0,
+        pwdLength: params.password.length,
+        pwd: params.password.split("").map(Number),
+    }, (cfg.supportBigData ? addTempPwdBigDpMap : addTempPwdDpMap));
+    const result = await publishDpsForRuntime(rt, {
+        [targetDpCode]: dpPayload,
+    }, {
+        checkReport: (dpsIn) => {
+            const dpDataRow = dpsIn;
+            const reportData = dpDataRow[targetDpCode];
+            if (reportData) {
+                const data = dpUtils.parse(dpDataRow[targetDpCode], (cfg.supportBigData
+                    ? reportAddTempPwdDBigpMap
+                    : reportAddTempPwdDpMap));
+                if (data.cloudNo === tyNum) {
+                    return data;
+                }
+            }
+            return false;
+        },
+    });
+    if (result.status === 0) {
+        sdkLog("info", "tempPassword", "createCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { route: "nearDp" },
+        });
+        return buildTempCustomCreateResult(createdName, params.password, result.unlockBindingId, effective);
+    }
+    const error = getError(result.status === 2 ? 1041 : 1042);
+    sdkLog("warn", "tempPassword", "createCustomDpFail", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { status: result.status },
+        error,
+    });
+    throw error;
+});
+export async function removeTempCustomForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    const useNear = isUseNearChannelForRuntime(rt);
+    sdkLog("info", "tempPassword", "removeCustomStart", {
+        devId: rt.devId,
+        data: { route: useNear ? "cloudAndNearDp" : "cloud", sn: params.sn },
+    });
+    try {
+        await deleteTempPassword({
+            devId: cfg.devInfo.devId,
+            unlockBindingId: params.unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        if (useNear) {
+            const dpCode = cfg.supportBigData
+                ? dpCodes.tempPwdDelW
+                : dpCodes.tempPwdDel;
+            const dpData = {
+                unlockId: params.sn,
+            };
+            const result = await publishDpsForRuntime(rt, {
+                [dpCode]: dpUtils.format(dpData, (cfg.supportBigData
+                    ? removeTempPwdBigDpMap
+                    : removeTempPwdDpMap)),
+            }, {
+                checkReport: (dpsIn) => {
+                    const dpDataRow = dpsIn;
+                    const reportData = dpDataRow[dpCode];
+                    if (reportData) {
+                        const data = dpUtils.parse(reportData, (cfg.supportBigData
+                            ? reportRemoveTempPwdBigDpMap
+                            : reportRemoveTempPwdDpMap));
+                        return data;
+                    }
+                    return false;
+                },
+            });
+            if (result.status === 0) {
+                sdkLog("info", "tempPassword", "removeCustomSuccess", {
+                    devId: rt.devId,
+                    duration: Date.now() - startedAt,
+                    data: { route: "cloudAndNearDp" },
+                });
+                return true;
+            }
+            const error = getError(1065);
+            sdkLog("warn", "tempPassword", "removeCustomDpFail", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                data: { status: result.status },
+                error,
+            });
+            throw error;
+        }
+        sdkLog("info", "tempPassword", "removeCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { route: "cloud" },
+        });
+        return true;
+    }
+    catch (e) {
+        sdkLog("error", "tempPassword", "removeCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw handleCloudError(e);
+    }
+}
+export async function updateTempCustomForRuntime(rt, params) {
+    const { unlockBindingId, name, effective } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "updateCustomStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (name && name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(effective);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime: effective?.effectiveTime ?? 0,
+            invalidTime: effective?.expiredTime ?? 0,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const result = await updateTemporaryPassword({
+            devId: rt.config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            schedule,
+            unlockBindingId,
+            symbolic: false,
+            dpTunnel: 2,
+        });
+        sdkLog("info", "tempPassword", "updateCustomSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { hasName: typeof name === "string" },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "updateCustomFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/password/temporary/freeze-ble-key.d.ts

@@ -0,0 +1,4 @@
+import { LockDeviceRuntime } from "../../../runtime";
+import { FreezeParams } from "./types";
+export declare function freezeBLEKeyForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<unknown>;
+export declare function unfreezeBLEKeyForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<unknown>;

package/lib/feature/password/temporary/freeze-ble-key.js

@@ -0,0 +1,7 @@
+import { updateLockVirtualKeyStatus } from "../../../api/ble";
+export async function freezeBLEKeyForRuntime(rt, params) {
+    return updateLockVirtualKeyStatus(rt.config.devInfo.devId, params.unlockBindingId, 4);
+}
+export async function unfreezeBLEKeyForRuntime(rt, params) {
+    return updateLockVirtualKeyStatus(rt.config.devInfo.devId, params.unlockBindingId, 2);
+}

package/lib/feature/password/temporary/freeze-rename.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FreezeParams, RenameParams } from "./types";
+export declare function freezeTempForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<boolean>;
+export declare function unfreezeTempForRuntime(rt: LockDeviceRuntime, params: FreezeParams): Promise<boolean>;
+export declare function renameTempForRuntime(rt: LockDeviceRuntime, params: RenameParams): Promise<void>;