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

package/lib/feature/fit/shared.js

@@ -0,0 +1,118 @@
+import { connectBLEDevice, getBLEOnlineState, getEncryptLocalKeyWithData, offBLETransparentDataReport, onBLETransparentDataReport, publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export const FIT_BIND_TIMEOUT_MS = 12_000;
+export const FIT_OPERATION_CODE = {
+    bind: "00",
+    unbind: "01",
+};
+export const normalizeHex = (value) => value.replace(/\s/g, "");
+export function buildTransparentData(operation, fit, loginKey) {
+    return `${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}${fit.devUnlockId}${fit.devUuid}${loginKey}`;
+}
+export function buildLockCheckCodeTemplate(operation, fit) {
+    return `ffff${fit.devUnlockId}${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}`;
+}
+export function waitTransparentResult(params) {
+    const { fittingId, expectedOperation, timeout = FIT_BIND_TIMEOUT_MS, } = params;
+    return new Promise((resolve, reject) => {
+        const onReport = ({ deviceId, data }) => {
+            if (deviceId !== fittingId) {
+                return;
+            }
+            if (!data) {
+                return;
+            }
+            const hex = normalizeHex(data).toLowerCase();
+            const operation = hex.slice(0, 2);
+            const result = hex.slice(26, 28);
+            if (operation !== expectedOperation) {
+                return;
+            }
+            clearTimeout(timer);
+            offBLETransparentDataReport(onReport);
+            if (result === "00" || result === "07") {
+                resolve();
+                return;
+            }
+            reject(getError(1004));
+        };
+        const timer = setTimeout(() => {
+            offBLETransparentDataReport(onReport);
+            reject(getError(1002));
+        }, timeout);
+        onBLETransparentDataReport(onReport);
+    });
+}
+export async function ensureFitBleOnline(fittingId) {
+    const isOnline = await getBLEOnlineState(fittingId);
+    if (isOnline) {
+        return true;
+    }
+    sdkLog("info", "fit", "ensureFitBleConnectStart", {
+        devId: fittingId,
+    });
+    try {
+        await connectBLEDevice(fittingId);
+        const nextOnline = await getBLEOnlineState(fittingId);
+        sdkLog(nextOnline ? "info" : "warn", "fit", "ensureFitBleConnectResult", {
+            devId: fittingId,
+            data: { online: nextOnline },
+        });
+        return nextOnline;
+    }
+    catch (error) {
+        sdkLog("warn", "fit", "ensureFitBleConnectFail", {
+            devId: fittingId,
+            error,
+        });
+        return false;
+    }
+}
+export async function publishFitTransparentFlow(fittingId, keyDeviceId, operation, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "transparentFlowStart", {
+        devId: fittingId,
+        data: { operation, lockDevId: keyDeviceId },
+    });
+    const fitBleOnline = await ensureFitBleOnline(fittingId);
+    if (!fitBleOnline) {
+        const error = getError(1001);
+        sdkLog("warn", "fit", "transparentFlowOffline", {
+            devId: fittingId,
+            duration: Date.now() - startedAt,
+            data: { operation, lockDevId: keyDeviceId },
+            error,
+        });
+        throw error;
+    }
+    subscribeBLETransparentDataReport(fittingId);
+    const loginKey = await getEncryptLocalKeyWithData({
+        deviceId: fittingId,
+        keyDeviceId,
+    });
+    if (!loginKey) {
+        const error = getError(1051);
+        sdkLog("warn", "fit", "transparentFlowMissingLoginKey", {
+            devId: fittingId,
+            duration: Date.now() - startedAt,
+            data: { operation, lockDevId: keyDeviceId },
+            error,
+        });
+        throw error;
+    }
+    const waitResult = waitTransparentResult({
+        fittingId,
+        expectedOperation: FIT_OPERATION_CODE[operation],
+    });
+    if (operation === "bind") {
+        await publishBLETransparentData(fittingId, buildTransparentData("unbind", fit, loginKey));
+    }
+    await publishBLETransparentData(fittingId, buildTransparentData(operation, fit, loginKey));
+    await waitResult;
+    sdkLog("info", "fit", "transparentFlowSuccess", {
+        devId: fittingId,
+        duration: Date.now() - startedAt,
+        data: { operation, lockDevId: keyDeviceId },
+    });
+}

package/lib/feature/fit/sync.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function syncFitBindingsForRuntime(runtime: LockDeviceRuntime): Promise<void>;
+export declare function syncFitReportForRuntime(runtime: LockDeviceRuntime, ins: string): Promise<unknown>;
+export declare function syncOpenModeRiseForRuntime(runtime: LockDeviceRuntime, dpIds: string): Promise<unknown>;

package/lib/feature/fit/sync.js

@@ -0,0 +1,85 @@
+import { syncFitToLockRise, syncFitReport as syncFitReportApi, syncOpenModeRise as syncOpenModeRiseApi, } from "../../api/fit";
+import { publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
+import { sdkLog } from "../../utils/sdk-log";
+export async function syncFitBindingsForRuntime(runtime) {
+    const startedAt = Date.now();
+    const fittingId = runtime.devId;
+    sdkLog("info", "fit", "syncBindingsStart", {
+        devId: runtime.devId,
+    });
+    try {
+        const result = await syncFitToLockRise(fittingId);
+        const instructions = Array.isArray(result.ins) ? result.ins : [];
+        if (!result.distributed || instructions.length === 0) {
+            sdkLog("info", "fit", "syncBindingsSkip", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { distributed: result.distributed, count: instructions.length },
+            });
+            return;
+        }
+        subscribeBLETransparentDataReport(fittingId);
+        for (const ins of instructions) {
+            await publishBLETransparentData(fittingId, ins);
+        }
+        sdkLog("info", "fit", "syncBindingsSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { count: instructions.length },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncBindingsFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}
+export async function syncFitReportForRuntime(runtime, ins) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "syncReportStart", {
+        devId: runtime.devId,
+        data: { hasInstruction: !!ins },
+    });
+    try {
+        const result = await syncFitReportApi(runtime.devId, ins);
+        sdkLog("info", "fit", "syncReportSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncReportFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}
+export async function syncOpenModeRiseForRuntime(runtime, dpIds) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "syncOpenModeRiseStart", {
+        devId: runtime.devId,
+        data: { hasDpIds: !!dpIds },
+    });
+    try {
+        const result = await syncOpenModeRiseApi(runtime.devId, dpIds);
+        sdkLog("info", "fit", "syncOpenModeRiseSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncOpenModeRiseFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/fit/temp-password.d.ts

@@ -0,0 +1,27 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { EffectiveConfig } from "../../interface";
+export interface AddFitTempPwdParams {
+    lockDevId: string;
+    type: "once" | "limit";
+    password: string;
+    name?: string;
+    effective: EffectiveConfig;
+}
+export interface RemoveFitTempPwdParams {
+    id: number;
+}
+export interface UpdateFitTempPwdParams {
+    id: number;
+    name: string;
+    effective: EffectiveConfig;
+}
+export declare function fitAddTempPwdForRuntime(runtime: LockDeviceRuntime, params: AddFitTempPwdParams): Promise<{
+    pwdId: number;
+}>;
+export declare function fitRemoveTempPwdForRuntime(runtime: LockDeviceRuntime, params: RemoveFitTempPwdParams): Promise<void>;
+export declare function fitUpdateTempPwdForRuntime(runtime: LockDeviceRuntime, params: UpdateFitTempPwdParams): Promise<void>;
+export interface RenameFitTempPwdParams {
+    id: number;
+    name: string;
+}
+export declare const fitRenameTempPwdForRuntime: (runtime: LockDeviceRuntime, params: RenameFitTempPwdParams) => Promise<void>;

package/lib/feature/fit/temp-password.js

@@ -0,0 +1,428 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../config/dp-code";
+import { fitAddTempPwd, fitReportAddTempPwd, fitRemoveTempPwd, fitReportRemoveTempPwd, fitUpdateTempPwd, fitReportUpdateTempPwd, fitBlePswCreate, fitBlePswDelete, fitBlePswCreateReport, fitBlePswDeleteReport, fitBlePswUpdate, fitBlePswUpdateReport, } from "../../config/dp-map/temp-pwd-fit";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import { resolveSlaveId } from "./resolve-slave-id";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { addFitOnlineTempPwd, addFitOnlineTempPwdCloud, getFitPasswordList, removeFitOnlineTempPwd, renameFitOnlineTempPwd, updateFitOnlineTempPwd, } from "../../api/fit";
+import { decrypt, encrypt } from "../../platform";
+import { formatPasswordToList, formatWeek, getAppUser, parseWeek, sleep, transformEffectiveConfigToValidConfig, validateEffectiveConfig, } from "../../utils";
+import { hasDpForRuntime } from "../dp/has-dp";
+export async function fitAddTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "addStart", {
+        devId: runtime.devId,
+        data: {
+            type: params.type,
+            hasLockDevId: typeof params.lockDevId === "string",
+            credentialProvided: typeof params.password === "string" && params.password.length > 0,
+        },
+    });
+    if (params.name && params.name.length > 20) {
+        throw getError(1031);
+    }
+    validateEffectiveConfig(params.effective);
+    if (!hasDpForRuntime(runtime, dpCodes.tempPwdCreate) &&
+        !hasDpForRuntime(runtime, dpCodes.bleKeyCreate)) {
+        throw getError(1045);
+    }
+    const passwordEncrypted = await encrypt(runtime.config.devInfo.devId, params.password);
+    const slaveId = await resolveSlaveId(runtime, params.lockDevId);
+    const countryCode = getAppUser()?.phoneCode || "86";
+    const schedule = [
+        {
+            allDay: params.effective.repeat !== "week",
+            effectiveTime: params.effective?.effectiveTime ?? 0,
+            invalidTime: params.effective?.expiredTime ?? 0,
+            workingDay: formatWeek(params.effective?.weeks ?? [0, 0, 0, 0, 0, 0, 0]),
+        },
+    ];
+    const validConfig = transformEffectiveConfigToValidConfig(params.effective);
+    const pwdList = formatPasswordToList(params.password);
+    if (hasDpForRuntime(runtime, dpCodes.tempPwdCreate)) {
+        const payload = dpUtils.format({
+            slaveId,
+            type: params.type === "once" ? 1 : 0,
+            validConfig,
+            validNum: params.type === "once" ? 1 : 0,
+            pwdLength: params.password.length ?? 0,
+            pwd: pwdList,
+        }, fitAddTempPwd);
+        const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdCreate]: payload }, {
+            checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdCreate, fitReportAddTempPwd),
+        });
+        try {
+            if (res.status === 0x00) {
+                const result = await addFitOnlineTempPwd({
+                    fittingId: runtime.devId,
+                    devIdList: [params.lockDevId],
+                    password: passwordEncrypted,
+                    effectiveTime: params.effective.effectiveDate,
+                    invalidTime: params.effective.expiredDate,
+                    sn: res.unlockId,
+                    schedule,
+                    countryCode,
+                    availTime: params.type === "once" ? 0x01 : 0x00,
+                    name: params.name,
+                });
+                sdkLog("info", "fitTempPassword", "addSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { type: params.type },
+                });
+                return result;
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1041);
+                }
+                throw getError(1042);
+            }
+        }
+        catch (error) {
+            sdkLog("error", "fitTempPassword", "addFail", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { type: params.type },
+                error,
+            });
+            throw error;
+        }
+    }
+    else {
+        try {
+            const result = await addFitOnlineTempPwdCloud({
+                fittingId: runtime.devId,
+                devIdList: [params.lockDevId],
+                password: passwordEncrypted,
+                effectiveTime: params.effective.effectiveDate,
+                invalidTime: params.effective.expiredDate,
+                sn: -1,
+                schedule,
+                countryCode,
+                availTime: params.type === "once" ? 0x01 : 0x00,
+                name: params.name,
+            });
+            const payload = dpUtils.format({
+                slaveId,
+                msgId: result.msgId,
+                type: params.type === "once" ? 0x00 : 0x01,
+                validConfig,
+                validNum: params.type === "once" ? 0x01 : 0x00,
+                pwdLength: params.password.length ?? 0,
+                pwd: pwdList,
+            }, fitBlePswCreate);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswCreate]: payload }, {
+                checkReport: (dps) => {
+                    if (dps[dpCodes.blePswCreate]) {
+                        return {
+                            status: parseInt(dps[dpCodes.blePswCreate].slice(-2), 16),
+                        };
+                    }
+                    return false;
+                },
+            });
+            if (res.status === 0x00) {
+                sdkLog("info", "fitTempPassword", "addSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { type: params.type, strategy: "cloud_first" },
+                });
+                return {
+                    pwdId: result.msgId,
+                };
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1041);
+                }
+                throw getError(1042);
+            }
+        }
+        catch (error) {
+            sdkLog("error", "fitTempPassword", "addFail", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { type: params.type, strategy: "cloud_first" },
+                error,
+            });
+            throw error;
+        }
+    }
+}
+export async function fitRemoveTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "removeStart", {
+        devId: runtime.devId,
+        data: { id: params.id },
+    });
+    const supportDeleteDp = hasDpForRuntime(runtime, dpCodes.tempPwdDel);
+    const supportBleDeleteDp = hasDpForRuntime(runtime, dpCodes.blePswDelete);
+    try {
+        if (!supportDeleteDp && !supportBleDeleteDp) {
+            throw getError(1045);
+        }
+        const list = await getFitPasswordList(runtime.devId);
+        const exist = list.find((item) => item.unlockBindingId === params.id);
+        if (!exist) {
+            throw getError(1040);
+        }
+        if (supportDeleteDp) {
+            const payload = dpUtils.format({ slaveId: parseInt(exist.devUnlockId, 16), unlockId: exist.sn }, fitRemoveTempPwd);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdDel]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdDel, fitReportRemoveTempPwd),
+            });
+            sdkLog("info", "fitTempPassword", "removeReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "device_first" },
+            });
+            if (res.status === 0x00 || res.status === 0x02) {
+                await removeFitOnlineTempPwd(runtime.devId, exist.pwdId);
+            }
+            else {
+                throw getError(1028);
+            }
+        }
+        else {
+            let { sn } = exist;
+            if (sn < 1) {
+                const { effectiveTime = 0, workingDay = 0, allDay, invalidTime = 0, } = exist.scheduleDetails?.[0] ?? {};
+                const repeat = allDay ? "none" : "week";
+                const password = await decrypt(runtime.config.devInfo.devId, exist.passWord ?? "");
+                const payload = dpUtils.format({
+                    slaveId: parseInt(exist.devUnlockId, 16),
+                    msgId: exist.msgId,
+                    type: exist.opModeSubType === 0 ? 1 : 0,
+                    validConfig: transformEffectiveConfigToValidConfig({
+                        effectiveDate: exist.effectiveTime,
+                        expiredDate: exist.invalidTime,
+                        repeat: repeat,
+                        weeks: parseWeek(workingDay),
+                        effectiveTime,
+                        expiredTime: invalidTime,
+                    }),
+                    validNum: exist.opModeSubType === 0 ? 0 : 1,
+                    pwdLength: password.length,
+                    pwd: formatPasswordToList(password),
+                }, fitBlePswCreate);
+                const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswCreate]: payload }, {
+                    checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswCreate, fitBlePswCreateReport),
+                });
+                sdkLog("info", "fitTempPassword", "removeSyncReport", {
+                    devId: runtime.devId,
+                    data: { id: params.id, status: res.status },
+                });
+                if (res.status === 0) {
+                    sn = res.unlockId;
+                }
+                else {
+                    await sleep(100);
+                    sdkLog("info", "fitTempPassword", "removeSuccess", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id: params.id, strategy: "cloud_first_sync_skipped" },
+                    });
+                    return;
+                }
+            }
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                msgId: exist.msgId,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                unlockId: sn,
+            }, fitBlePswDelete);
+            const res = await publishDpsForRuntime(runtime, {
+                [dpCodes.blePswDelete]: payload,
+            }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswDelete, fitBlePswDeleteReport),
+            });
+            sdkLog("info", "fitTempPassword", "removeReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "cloud_first" },
+            });
+            if (res.status === 0x00 || res.status === 0x03) {
+                await sleep(100);
+                sdkLog("info", "fitTempPassword", "removeSuccess", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { id: params.id, strategy: "cloud_first" },
+                });
+                return;
+            }
+            else {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1091);
+                }
+                throw getError(1028);
+            }
+        }
+        sdkLog("info", "fitTempPassword", "removeSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id, strategy: "device_first" },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "removeFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+}
+export async function fitUpdateTempPwdForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "updateStart", {
+        devId: runtime.devId,
+        data: { id: params.id, hasName: typeof params.name === "string" },
+    });
+    const supportUpdateDp = hasDpForRuntime(runtime, dpCodes.tempPwdEdit);
+    const supportBleUpdateDp = hasDpForRuntime(runtime, dpCodes.blePswUpdate);
+    try {
+        if (!supportUpdateDp && !supportBleUpdateDp) {
+            throw getError(1045);
+        }
+        const list = await getFitPasswordList(runtime.devId);
+        const exist = list.find((item) => item.unlockBindingId === params.id);
+        if (!exist) {
+            throw getError(1040);
+        }
+        if (!params.name || !params.name.trim()) {
+            throw getError(1054);
+        }
+        if (params.name.trim().length > 20) {
+            throw getError(1031);
+        }
+        validateEffectiveConfig(params.effective);
+        const schedule = [
+            {
+                allDay: params.effective.repeat !== "week",
+                effectiveTime: params.effective?.effectiveTime ?? 0,
+                invalidTime: params.effective?.expiredTime ?? 0,
+                workingDay: formatWeek(params.effective?.weeks ?? [0, 0, 0, 0, 0, 0, 0]),
+            },
+        ];
+        if (supportUpdateDp) {
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                unlockId: exist.sn,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                validConfig: transformEffectiveConfigToValidConfig(params.effective),
+                validNum: exist.opModeSubType === 0 ? 0 : 1,
+                pwdLength: 0,
+                pwd: [],
+            }, fitUpdateTempPwd);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.tempPwdEdit]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.tempPwdEdit, fitReportUpdateTempPwd),
+            });
+            sdkLog("info", "fitTempPassword", "updateReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "device_first" },
+            });
+            if (res.status === 0x00) {
+                await updateFitOnlineTempPwd(runtime.devId, {
+                    pwdId: exist.unlockBindingId,
+                    name: params.name,
+                    effectiveTime: params.effective.effectiveDate,
+                    invalidTime: params.effective.expiredDate,
+                    sn: exist.sn,
+                    schedule,
+                });
+            }
+            else {
+                throw getError(1028);
+            }
+        }
+        else {
+            await updateFitOnlineTempPwd(runtime.devId, {
+                pwdId: exist.unlockBindingId,
+                name: params.name,
+                effectiveTime: params.effective.effectiveDate,
+                invalidTime: params.effective.expiredDate,
+                availTime: exist.opModeSubType === 0 ? 0 : 1,
+                sn: exist.sn,
+                schedule,
+            });
+            const payload = dpUtils.format({
+                slaveId: parseInt(exist.devUnlockId, 16),
+                msgId: exist.msgId,
+                type: exist.opModeSubType === 0 ? 1 : 0,
+                unlockId: exist.sn,
+                validConfig: transformEffectiveConfigToValidConfig(params.effective),
+                validNum: exist.opModeSubType === 0 ? 0 : 1,
+                pwdLength: 0,
+                pwd: [],
+            }, fitBlePswUpdate);
+            const res = await publishDpsForRuntime(runtime, { [dpCodes.blePswUpdate]: payload }, {
+                checkReport: (dps) => checkFitTempPwdReport(dps, dpCodes.blePswUpdate, fitBlePswUpdateReport),
+            });
+            sdkLog("info", "fitTempPassword", "updateReport", {
+                devId: runtime.devId,
+                data: { id: params.id, status: res.status, strategy: "cloud_first" },
+            });
+            if (res.status !== 0x00) {
+                switch (res.status) {
+                    case 0x02:
+                        throw getError(1091);
+                    case 0x03:
+                        throw getError(1092);
+                }
+                throw getError(1082);
+            }
+        }
+        sdkLog("info", "fitTempPassword", "updateSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: {
+                id: params.id,
+                strategy: supportUpdateDp ? "device_first" : "cloud_first",
+            },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "updateFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+}
+function checkFitTempPwdReport(dps, dpCode, reportMap) {
+    const raw = dps[dpCode];
+    if (typeof raw !== "string") {
+        return false;
+    }
+    return dpUtils.parse(raw, reportMap);
+}
+export const fitRenameTempPwdForRuntime = async (runtime, params) => {
+    const startedAt = Date.now();
+    sdkLog("info", "fitTempPassword", "renameStart", {
+        devId: runtime.devId,
+        data: { id: params.id, hasName: typeof params.name === "string" },
+    });
+    try {
+        await renameFitOnlineTempPwd(runtime.devId, params.id, params.name);
+        sdkLog("info", "fitTempPassword", "renameSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitTempPassword", "renameFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw error;
+    }
+};

package/lib/feature/fit/users.d.ts

@@ -0,0 +1,12 @@
+import type { UserType } from "../../constant";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface FitUserItem {
+    userId: string;
+    lockUserId: number;
+    avatarUrl: string;
+    nickName: string;
+    userType: UserType;
+    userContact: string;
+    phase: number;
+}
+export declare function getFitUsersForRuntime(runtime: LockDeviceRuntime): Promise<FitUserItem[]>;