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

package/lib/feature/fit/ble-key.js

@@ -0,0 +1,99 @@
+import { getFitBleKeyListApi, addFitBleKeyApi, updateFitBleKeyApi, removeFitBleKeyApi, renameFitBleKeyApi, } from "../../api/fit";
+import { sdkLog } from "../../utils/sdk-log";
+import { formatWeek } from "../../utils";
+export async function getFitBleKeyListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getBleKeyListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getFitBleKeyListApi(runtime.devId);
+    sdkLog("info", "fit", "getBleKeyListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+export async function addFitBleKeyForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    const logParams = params ?? {};
+    sdkLog("info", "fit", "addBleKeyStart", {
+        devId: runtime.devId,
+        data: {
+            hasName: typeof logParams["name"] === "string",
+            hasLockDevId: typeof logParams["lockDevId"] === "string",
+        },
+    });
+    const result = await addFitBleKeyApi(runtime.devId, params);
+    sdkLog("info", "fit", "addBleKeySuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+    });
+    return result;
+}
+export async function updateFitBleKeyForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    const logParams = params ?? {};
+    sdkLog("info", "fit", "updateBleKeyStart", {
+        devId: runtime.devId,
+        data: {
+            hasName: typeof logParams["name"] === "string",
+            hasId: typeof logParams["id"] === "string",
+        },
+    });
+    const schedule = [
+        {
+            allDay: params.effective.repeat !== "week",
+            effectiveTime: params.effective.effectiveTime ?? 0,
+            invalidTime: params.effective.expiredTime ?? 0,
+            workingDay: formatWeek(params.effective.weeks ?? [0]),
+        },
+    ];
+    const result = await updateFitBleKeyApi(runtime.devId, {
+        unlockBindingId: params.id,
+        name: params.name,
+        effectiveTime: params.effective.effectiveDate,
+        invalidTime: params.effective.expiredDate,
+        schedule,
+        timeSetType: params.effective.repeat !== "week" ? 20 : 30,
+    });
+    sdkLog("info", "fit", "updateBleKeySuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+    });
+    return result;
+}
+export async function removeFitBleKeyForRuntime(runtime, unlockBindingId) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "removeBleKeyStart", {
+        devId: runtime.devId,
+        data: { unlockBindingId },
+    });
+    const result = await removeFitBleKeyApi(runtime.devId, unlockBindingId);
+    sdkLog("info", "fit", "removeBleKeySuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { unlockBindingId },
+    });
+    return result;
+}
+export async function renameFitBleKeyForRuntime(runtime, params) {
+    const startedAt = Date.now();
+    const logParams = params ?? {};
+    sdkLog("info", "fit", "renameBleKeyStart", {
+        devId: runtime.devId,
+        data: {
+            hasName: typeof logParams["name"] === "string",
+            hasUnlockBindingId: typeof logParams["id"] === "string",
+        },
+    });
+    const result = await renameFitBleKeyApi(runtime.devId, {
+        unlockBindingId: params.id,
+        name: params.name,
+    });
+    sdkLog("info", "fit", "renameBleKeySuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+    });
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").BoundFitLockItem[]>;
+export declare function getUnbindLockListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").UnbindLockItem[]>;

package/lib/feature/fit/list.js

@@ -0,0 +1,28 @@
+import { getBoundLockListApi, getUnbindLockListApi, } from "../../api/fit";
+import { sdkLog } from "../../utils/sdk-log";
+export async function getBoundLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getBoundLockListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getBoundLockListApi(runtime.devId);
+    sdkLog("info", "fit", "getBoundLockListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+export async function getUnbindLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getUnbindLockListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getUnbindLockListApi(runtime.devId);
+    sdkLog("info", "fit", "getUnbindLockListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}

package/lib/feature/fit/method/add-flow.d.ts

@@ -0,0 +1,7 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitCancelAddUnlockMethodParams, FitStartAddUnlockMethodParams } from "./types";
+export interface FitStartAddUnlockMethodResult {
+    total: number;
+}
+export declare function fitStartAddUnlockMethodForRuntime(rt: LockDeviceRuntime, params: FitStartAddUnlockMethodParams): Promise<FitStartAddUnlockMethodResult>;
+export declare const fitCancelAddUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, params: FitCancelAddUnlockMethodParams) => Promise<void>;

package/lib/feature/fit/method/add-flow.js

@@ -0,0 +1,380 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { addFitOpenMode } from "../../../api/fit";
+import { sleep } from "../../../utils";
+import { DPCHANGE } from "../../../utils/constant";
+import { getError } from "../../../utils/errors";
+import emitter from "../../../utils/event";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { parallelOnlyForRuntime } from "../../utils";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../utils";
+import { getUserInfoOnDevForRuntime } from "../../user/user";
+import { getAddUnlockError } from "../../unlock/method/internal/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+import { getFitUnlockMethodBase } from "./internal/base";
+import { getFitUnlockMethodEvent } from "./add-method-events";
+const addUnlockMethodData = {
+    runtime: null,
+    unlockMethodConfig: {},
+    total: 0,
+    dpCode: "",
+    dpMap: {},
+    slaveId: 0,
+    lockDevId: "",
+    lockUserId: 0,
+    userId: "",
+    unlockDpId: 0,
+    timeout: 15000,
+    timeoutId: 0,
+};
+let isCancelAddUnlockMethod = false;
+const handleAddTimeout = (timeout = 15000) => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    addUnlockMethodData.timeoutId = setTimeout(() => {
+        emitter.off(DPCHANGE, handleAddReport);
+        const rt = addUnlockMethodData.runtime;
+        if (!rt)
+            return;
+        sdkLog("warn", "fitUnlockMethod", "addMethodTimeout", {
+            devId: rt.devId,
+            data: {
+                type: addUnlockMethodData.unlockMethodConfig.type,
+                lockDevId: addUnlockMethodData.lockDevId,
+            },
+            error: getError(1002),
+        });
+        emitter.emit(getFitUnlockMethodEvent(rt), {
+            type: addUnlockMethodData.unlockMethodConfig.type,
+            stage: "fail",
+            lockDevId: addUnlockMethodData.lockDevId,
+            lockUserId: addUnlockMethodData.lockUserId,
+            error: getError(1002),
+        });
+    }, timeout);
+};
+const clearMonitoringAddReport = () => {
+    clearTimeout(addUnlockMethodData.timeoutId);
+    emitter.off(DPCHANGE, handleAddReport);
+    addUnlockMethodData.runtime = null;
+};
+const handleAddReport = async (dps) => {
+    const rt = addUnlockMethodData.runtime;
+    if (!rt) {
+        return;
+    }
+    const cfg = rt.config;
+    if (!dps[addUnlockMethodData.dpCode]) {
+        return;
+    }
+    const result = dpUtils.parse(dps[addUnlockMethodData.dpCode], addUnlockMethodData.dpMap);
+    if (result.type !== addUnlockMethodData.unlockMethodConfig.id) {
+        return;
+    }
+    if (result.slaveId !== addUnlockMethodData.slaveId) {
+        return;
+    }
+    if (cfg.strictMode) {
+        if (result.memberId !== addUnlockMethodData.lockUserId) {
+            return;
+        }
+    }
+    else if (result.memberId !== addUnlockMethodData.lockUserId) {
+        console.warn(`FitAddUnlockMethod: lockUserId mismatch, expected ${addUnlockMethodData.lockUserId}, got ${result.memberId}`);
+    }
+    const type = addUnlockMethodData.unlockMethodConfig.type;
+    let eventData = null;
+    switch (result.stage) {
+        case 0xfc: {
+            handleAddTimeout(addUnlockMethodData.timeout);
+            sdkLog("info", "fitUnlockMethod", "addMethodStep", {
+                devId: rt.devId,
+                data: {
+                    type,
+                    lockDevId: addUnlockMethodData.lockDevId,
+                    step: result.step,
+                    total: addUnlockMethodData.total,
+                },
+            });
+            eventData = {
+                type,
+                stage: "step",
+                lockDevId: addUnlockMethodData.lockDevId,
+                lockUserId: result.memberId,
+                step: result.step,
+                total: addUnlockMethodData.total,
+            };
+            break;
+        }
+        case 0xfd: {
+            clearMonitoringAddReport();
+            sdkLog("warn", "fitUnlockMethod", "addMethodDpFail", {
+                devId: rt.devId,
+                data: {
+                    type,
+                    lockDevId: addUnlockMethodData.lockDevId,
+                    status: result.status,
+                },
+                error: getAddUnlockError(result.status),
+            });
+            eventData = {
+                stage: "fail",
+                type,
+                lockDevId: addUnlockMethodData.lockDevId,
+                lockUserId: result.memberId,
+                error: getAddUnlockError(result.status),
+            };
+            break;
+        }
+        case 0xfe: {
+            clearMonitoringAddReport();
+            if (isCancelAddUnlockMethod) {
+                isCancelAddUnlockMethod = false;
+                sdkLog("info", "fitUnlockMethod", "addMethodCancelAck", {
+                    devId: rt.devId,
+                    data: { type, lockDevId: addUnlockMethodData.lockDevId },
+                });
+                return;
+            }
+            sdkLog("warn", "fitUnlockMethod", "addMethodCancelStageFail", {
+                devId: rt.devId,
+                data: {
+                    type,
+                    lockDevId: addUnlockMethodData.lockDevId,
+                    status: result.status,
+                },
+                error: getAddUnlockError(result.status),
+            });
+            eventData = {
+                stage: "fail",
+                type,
+                lockDevId: addUnlockMethodData.lockDevId,
+                lockUserId: result.memberId,
+                error: getAddUnlockError(result.status),
+            };
+            break;
+        }
+        case 0xff: {
+            clearMonitoringAddReport();
+            try {
+                await sleep(300);
+                let isAddEnabled = true;
+                if (!cfg.supportMultipleFace && type === "face") {
+                    const user = await getUserInfoOnDevForRuntime(rt, {
+                        devId: addUnlockMethodData.lockDevId,
+                        userId: addUnlockMethodData.userId,
+                    });
+                    const faceData = user.unlockDetails.find((item) => item.type === "face" && item.unlockList.length > 0);
+                    if (faceData) {
+                        const originUnlockId = faceData.unlockList[0].unlockId;
+                        if (originUnlockId !== result.unlockId) {
+                            eventData = {
+                                stage: "fail",
+                                type,
+                                lockDevId: addUnlockMethodData.lockDevId,
+                                lockUserId: result.memberId,
+                                error: getError(1061),
+                            };
+                            sdkLog("warn", "fitUnlockMethod", "addMethodDuplicateFace", {
+                                devId: rt.devId,
+                                data: { lockDevId: addUnlockMethodData.lockDevId },
+                                error: getError(1061),
+                            });
+                        }
+                        else {
+                            eventData = {
+                                stage: "success",
+                                type,
+                                lockDevId: addUnlockMethodData.lockDevId,
+                                id: faceData.unlockList[0].id,
+                                name: faceData.unlockList[0].unlockName,
+                            };
+                        }
+                        isAddEnabled = false;
+                    }
+                }
+                if (isAddEnabled) {
+                    await addFitOpenMode({
+                        devIdList: [addUnlockMethodData.lockDevId],
+                        fittingId: rt.devId,
+                        unlockId: `${addUnlockMethodData.unlockDpId}-${result.unlockId}`,
+                        unlockName: "",
+                        userId: addUnlockMethodData.userId,
+                        hijack: false,
+                    });
+                    eventData = {
+                        stage: "success",
+                        type,
+                        lockDevId: addUnlockMethodData.lockDevId,
+                        id: 0,
+                        name: "",
+                    };
+                    sdkLog("info", "fitUnlockMethod", "addMethodSuccess", {
+                        devId: rt.devId,
+                        data: { type, lockDevId: addUnlockMethodData.lockDevId },
+                    });
+                }
+            }
+            catch (err) {
+                console.warn("FitAddUnlockMethod failed", err);
+                sdkLog("error", "fitUnlockMethod", "addMethodCloudFail", {
+                    devId: rt.devId,
+                    data: { type, lockDevId: addUnlockMethodData.lockDevId },
+                    error: err,
+                });
+                eventData = {
+                    stage: "fail",
+                    type,
+                    lockDevId: addUnlockMethodData.lockDevId,
+                    lockUserId: result.memberId,
+                    error: getError(1053),
+                };
+            }
+            break;
+        }
+        default:
+    }
+    if (eventData) {
+        const eventKey = getFitUnlockMethodEvent(rt);
+        if (emitter.hasListener(eventKey)) {
+            emitter.emit(eventKey, eventData);
+        }
+        else {
+            emitter.cache(eventKey, eventData);
+        }
+    }
+};
+const monitoringAddReport = (option) => {
+    Object.assign(addUnlockMethodData, {
+        timeout: 15000,
+        ...option,
+    });
+    emitter.clearCache(getFitUnlockMethodEvent(option.runtime));
+    emitter.off(DPCHANGE, handleAddReport);
+    emitter.on(DPCHANGE, handleAddReport);
+    handleAddTimeout(option.timeout);
+};
+export async function fitStartAddUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "startAddMethodStart", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            userId: params.userId,
+            hasLockDevId: typeof params.lockDevId === "string",
+        },
+    });
+    const base = await getFitUnlockMethodBase(rt, params.type, params.userId, params.lockDevId);
+    const { unlockMethodConfig, lockUserId, lockDevId, slaveId, addDpCode, addDpMap, addDpReportMap, dpData, } = base;
+    const cfgItem = getUnlockMethodTypeByTypeForRuntime(rt, params.type);
+    const dpId = rt.config.idsByCode[cfgItem.code];
+    isCancelAddUnlockMethod = false;
+    const res = await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        timeout: params.timeout,
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] === "undefined") {
+                return false;
+            }
+            const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+            let hasReport = result.type === unlockMethodConfig.id && result.slaveId === slaveId;
+            if (cfg.strictMode) {
+                hasReport = hasReport && result.memberId === lockUserId;
+            }
+            if (hasReport) {
+                if (result.memberId !== lockUserId) {
+                    console.warn(`FitStartAddUnlockMethod: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
+                    sdkLog("warn", "fitUnlockMethod", "startAddMethodMemberMismatch", {
+                        devId: rt.devId,
+                        data: { type: params.type, lockDevId },
+                    });
+                }
+                return result;
+            }
+            return false;
+        },
+    });
+    if (res.stage === 0) {
+        monitoringAddReport({
+            runtime: rt,
+            timeout: params.timeout,
+            unlockMethodConfig,
+            total: res.total,
+            dpCode: addDpCode,
+            dpMap: addDpReportMap,
+            slaveId,
+            lockDevId,
+            lockUserId,
+            userId: params.userId,
+            unlockDpId: dpId,
+        });
+        sdkLog("info", "fitUnlockMethod", "startAddMethodSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, lockDevId, total: res.total },
+        });
+        return { total: res.total };
+    }
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "fitUnlockMethod", "startAddMethodDpRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, lockDevId, status: res.status },
+            error,
+        });
+        throw error;
+    }
+    const error = getError(1027);
+    sdkLog("warn", "fitUnlockMethod", "startAddMethodUnexpectedStage", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type, lockDevId, stage: res.stage },
+        error,
+    });
+    throw error;
+}
+export const fitCancelAddUnlockMethodForRuntime = parallelOnlyForRuntime(async function fitCancelAddUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "cancelAddMethodStart", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            userId: params.userId,
+            hasLockDevId: typeof params.lockDevId === "string",
+        },
+    });
+    const base = await getFitUnlockMethodBase(rt, params.type, params.userId, params.lockDevId);
+    const { unlockMethodConfig, lockUserId, slaveId, addDpCode, addDpMap, addDpReportMap, dpData, } = base;
+    dpData.stage = 0xfe;
+    isCancelAddUnlockMethod = true;
+    await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] === "undefined") {
+                return false;
+            }
+            const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+            let hasReport = result.type === unlockMethodConfig.id &&
+                result.slaveId === slaveId;
+            if (cfg.strictMode) {
+                hasReport =
+                    hasReport &&
+                        result.stage === 0xfe &&
+                        result.memberId === lockUserId;
+            }
+            if (hasReport) {
+                return result;
+            }
+            return false;
+        },
+    });
+    sdkLog("info", "fitUnlockMethod", "cancelAddMethodSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type },
+    });
+    return;
+});

package/lib/feature/fit/method/add-method-events.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitAddUnlockMethodListener } from "./types";
+export declare function getFitUnlockMethodEvent(runtime: LockDeviceRuntime): string;
+export declare const onFitAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: FitAddUnlockMethodListener) => void;
+export declare const offFitAddUnlockMethodForRuntime: (runtime: LockDeviceRuntime, listener: FitAddUnlockMethodListener) => void;

package/lib/feature/fit/method/add-method-events.js

@@ -0,0 +1,11 @@
+import emitter from "../../../utils/event";
+import { FIT_UNLOCK_METHOD_EVENT } from "../../../utils/constant";
+export function getFitUnlockMethodEvent(runtime) {
+    return `${FIT_UNLOCK_METHOD_EVENT}_${runtime.devId}`;
+}
+export const onFitAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.on(getFitUnlockMethodEvent(runtime), listener);
+};
+export const offFitAddUnlockMethodForRuntime = (runtime, listener) => {
+    emitter.off(getFitUnlockMethodEvent(runtime), listener);
+};

package/lib/feature/fit/method/add-password.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitAddPasswordParams } from "./types";
+export declare function fitAddPasswordForRuntime(rt: LockDeviceRuntime, params: FitAddPasswordParams): Promise<void>;

package/lib/feature/fit/method/add-password.js

@@ -0,0 +1,99 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { addFitOpenMode } from "../../../api/fit";
+import { sleep } from "../../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getFitUnlockMethodBase } from "./internal/base";
+import { getAddUnlockError } from "../../unlock/method/internal/errors";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../utils";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function fitAddPasswordForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "addPasswordStart", {
+        devId: rt.devId,
+        data: {
+            userId: params.userId,
+            hasName: typeof params.name === "string",
+            hasLockDevId: typeof params.lockDevId === "string",
+            hijack: !!params.hijack,
+        },
+    });
+    if (!params.password) {
+        const error = getError(1054);
+        sdkLog("warn", "fitUnlockMethod", "addPasswordEmpty", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const base = await getFitUnlockMethodBase(rt, "password", params.userId, params.lockDevId);
+    const { unlockMethodConfig, fittingId, lockDevId, slaveId, lockUserId, addDpCode, addDpMap, addDpReportMap, dpData, } = base;
+    dpData.pwdLength = params.password.length;
+    dpData.pwd = params.password.split("").map(Number);
+    const res = await publishDpsForRuntime(rt, {
+        [addDpCode]: dpUtils.format(dpData, addDpMap),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[addDpCode] === "undefined") {
+                return false;
+            }
+            const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+            let hasReport = result.type === unlockMethodConfig.id &&
+                result.slaveId === slaveId &&
+                [0xff, 0xfd].includes(result.stage);
+            if (cfg.strictMode) {
+                hasReport = hasReport && result.memberId === lockUserId;
+            }
+            if (hasReport) {
+                if (result.memberId !== lockUserId) {
+                    console.warn(`FitAddPassword: lockUserId mismatch, expected ${lockUserId}, got ${result.memberId}`);
+                    sdkLog("warn", "fitUnlockMethod", "addPasswordMemberMismatch", {
+                        devId: rt.devId,
+                        data: { lockDevId },
+                    });
+                }
+                return result;
+            }
+            return false;
+        },
+    });
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "fitUnlockMethod", "addPasswordDpRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { status: res.status, lockDevId },
+            error,
+        });
+        throw error;
+    }
+    await sleep(300);
+    const cfgItem = getUnlockMethodTypeByTypeForRuntime(rt, "password");
+    const dpId = rt.config.idsByCode[cfgItem.code];
+    try {
+        await addFitOpenMode({
+            devIdList: [lockDevId],
+            fittingId,
+            unlockId: `${dpId}-${res.unlockId}`,
+            unlockName: params.name,
+            userId: params.userId,
+            hijack: !!params.hijack,
+        });
+        sdkLog("info", "fitUnlockMethod", "addPasswordSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId },
+        });
+        return;
+    }
+    catch (error) {
+        sdkLog("error", "fitUnlockMethod", "addPasswordCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/fit/method/internal/base.d.ts

@@ -0,0 +1,19 @@
+import type { DpMap } from "@ray-js/tuya-dp-transform";
+import { fitAdd } from "../../../../config/dp-map/unlock-method-fit";
+import type { DpMapDataType, UnlockMethodConfig, UnlockMethodType, UserInfo } from "../../../../interface";
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare function buildValidConfigFromTimeSchedule(timeScheduleInfo: UserInfo["timeScheduleInfo"] | null | undefined): DpMapDataType<typeof fitAdd>["validConfig"];
+export interface FitUnlockMethodBase {
+    unlockMethodConfig: UnlockMethodConfig;
+    fittingId: string;
+    lockDevId: string;
+    slaveId: number;
+    lockUserId: number;
+    userType: number;
+    lockUserInfo: UserInfo;
+    addDpCode: string;
+    addDpMap: DpMap;
+    addDpReportMap: DpMap;
+    dpData: DpMapDataType<typeof fitAdd>;
+}
+export declare function getFitUnlockMethodBase(rt: LockDeviceRuntime, type: UnlockMethodType, userId: string, lockDevId?: string): Promise<FitUnlockMethodBase>;