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

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

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { AddPasswordParams } from "./types";
+export declare function addPasswordForRuntime(rt: LockDeviceRuntime, params: AddPasswordParams): Promise<import("../../../api/lock").CreateUnlockMethodResult>;

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

@@ -0,0 +1,99 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { createUnlockMethod } from "../../../api/lock";
+import { encrypt } from "../../../platform/device";
+import { sleep } from "../../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getUnlockMethodBase } from "./internal/base";
+import { checkSpecial } from "./internal/special-check";
+import { getAddUnlockError } from "./internal/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function addPasswordForRuntime(rt, params) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "unlockMethod", "addPasswordStart", {
+        devId: rt.devId,
+        data: {
+            userId: params.userId,
+            hasName: typeof params.name === "string",
+            isSpecial: !!params.isSpecial,
+        },
+    });
+    if (!params.password) {
+        const error = getError(1054);
+        sdkLog("warn", "unlockMethod", "addPasswordEmpty", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const specialInfo = checkSpecial(rt, !!params.isSpecial, params.specialInfo);
+    const { lockUserId, dpData, sn, addDpCode, addDpMap, addDpReportMap, devId, dpId, unlockMethodConfig, } = await getUnlockMethodBase(rt, "password", params.userId);
+    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") {
+                const result = dpUtils.parse(dpDataIn[addDpCode], addDpReportMap);
+                let hasReport = result.type === unlockMethodConfig.id &&
+                    [0xff, 0xfd].includes(result.stage);
+                if (cfg.strictMode) {
+                    hasReport =
+                        hasReport && result.memberId === lockUserId && result.sn === sn;
+                }
+                if (hasReport) {
+                    if (result.memberId !== lockUserId) {
+                        sdkLog("warn", "unlockMethod", "addPasswordMemberMismatch", {
+                            devId: rt.devId,
+                        });
+                    }
+                    return result;
+                }
+                return false;
+            }
+            sdkLog("warn", "unlockMethod", "addPasswordInvalidReport", {
+                devId: rt.devId,
+                data: { dpCode: addDpCode },
+            });
+            return false;
+        },
+    });
+    if (res.stage === 0xfd) {
+        const error = getAddUnlockError(res.status);
+        sdkLog("warn", "unlockMethod", "addPasswordDpRejected", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { status: res.status },
+            error,
+        });
+        throw error;
+    }
+    const aesPwd = await encrypt(devId, params.password);
+    await sleep(300);
+    try {
+        const result = await createUnlockMethod({
+            devId: devId,
+            userId: params.userId,
+            unlockId: `${dpId}-${res.unlockId}`,
+            unlockName: params.name,
+            unlockDetail: aesPwd,
+            ...specialInfo,
+        });
+        sdkLog("info", "unlockMethod", "addPasswordSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { opModeId: result.opModeId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "unlockMethod", "addPasswordCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/unlock/method/bind-unbind.d.ts

@@ -0,0 +1,8 @@
+import type { UnBindUnlockMethodGroup } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { BindUnlockMethodFromLogParams, BindUnlockMethodParams } from "./types";
+export declare function checkUnBindUnlockMethodsForRuntime(rt: LockDeviceRuntime): Promise<boolean>;
+export declare function getUnbindUnlockMethodsForRuntime(rt: LockDeviceRuntime): Promise<UnBindUnlockMethodGroup[]>;
+export declare function bindUnlockMethodForRuntime(rt: LockDeviceRuntime, params: BindUnlockMethodParams): Promise<boolean>;
+export declare function unbindUnlockMethodForRuntime(rt: LockDeviceRuntime, id: number): Promise<void>;
+export declare function bindUnlockMethodFromLogForRuntime(rt: LockDeviceRuntime, params: BindUnlockMethodFromLogParams): Promise<boolean>;

package/lib/feature/unlock/method/bind-unbind.js

@@ -0,0 +1,113 @@
+import { bindUnlockMethodToUser, bindUnlockMethodToUserByRecord, checkFreeUnlockMethods, fetchFreeUnlockMethods, unbindMemberUnlockMethod, } from "../../../api/lock";
+import { getUnlockMethodTypeByDpCodeForRuntime, getUnlockMethodTypeByTypeForRuntime, } from "../../utils";
+import { getError } from "../../../utils/errors";
+import { getUnlockMethodDetailForRuntime } from "./detail";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function checkUnBindUnlockMethodsForRuntime(rt) {
+    const data = await checkFreeUnlockMethods({
+        devId: rt.config.devInfo.devId,
+    });
+    sdkLog("debug", "unlockMethod", "checkUnbind", {
+        devId: rt.devId,
+        data: { hasUnbind: data === true || data === 1 },
+    });
+    return data === true || data === 1;
+}
+export async function getUnbindUnlockMethodsForRuntime(rt) {
+    const cloudData = await fetchFreeUnlockMethods({
+        devId: rt.config.devInfo.devId,
+    });
+    sdkLog("debug", "unlockMethod", "getUnbindList", {
+        devId: rt.devId,
+        data: { groupCount: cloudData.length },
+    });
+    const list = cloudData.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, item.standardDp);
+        return {
+            type: unlockMethodConfig.type,
+            list: item.unlockInfo.map((unlock) => {
+                return {
+                    unlockId: Number(unlock.unlockId.split("-")[1]),
+                    unlockName: unlock.unlockName,
+                    id: unlock.opmodeId,
+                    unlockSn: unlock.unlockSn,
+                    type: unlockMethodConfig.type,
+                    dpId: Number(item.opmode),
+                    dpCode: item.standardDp,
+                };
+            }),
+        };
+    });
+    return list;
+}
+export async function bindUnlockMethodForRuntime(rt, params) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "bindStart", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: params.unlockList.length },
+    });
+    const unlockIds = params.unlockList.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, item.type);
+        const dpId = cfg.idsByCode[unlockMethodConfig.code];
+        return `${dpId}-${item.unlockId}`;
+    });
+    const result = await bindUnlockMethodToUser({
+        devId: cfg.devInfo.devId,
+        userId: params.userId,
+        unlockIds: unlockIds,
+    });
+    sdkLog("info", "unlockMethod", "bindSuccess", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: unlockIds.length },
+    });
+    return result;
+}
+export async function unbindUnlockMethodForRuntime(rt, id) {
+    const cfg = rt.config;
+    sdkLog("info", "unlockMethod", "unbindStart", {
+        devId: rt.devId,
+        data: { id },
+    });
+    const detail = await getUnlockMethodDetailForRuntime(rt, id);
+    if (!detail.isBound) {
+        const error = getError(1050);
+        sdkLog("warn", "unlockMethod", "unbindNotBound", {
+            devId: rt.devId,
+            data: { id },
+            error,
+        });
+        throw error;
+    }
+    await unbindMemberUnlockMethod({
+        devId: cfg.devInfo.devId,
+        userId: detail.userId,
+        unlockIds: [`${detail.dpId}-${detail.unlockId}`],
+    });
+    sdkLog("info", "unlockMethod", "unbindSuccess", {
+        devId: rt.devId,
+        data: { id, userId: detail.userId },
+    });
+    return;
+}
+export async function bindUnlockMethodFromLogForRuntime(rt, params) {
+    const { idsByCode } = rt.config;
+    sdkLog("info", "unlockMethod", "bindFromLogStart", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: params.unlockList.length },
+    });
+    const unlockIds = params.unlockList.map((item) => {
+        const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, item.type);
+        const dpId = idsByCode[unlockMethodConfig.code];
+        return `${dpId}-${item.unlockId}`;
+    });
+    const result = await bindUnlockMethodToUserByRecord({
+        devId: rt.config.devInfo.devId,
+        userId: params.userId,
+        unlockIds: unlockIds,
+    });
+    sdkLog("info", "unlockMethod", "bindFromLogSuccess", {
+        devId: rt.devId,
+        data: { userId: params.userId, count: unlockIds.length },
+    });
+    return result;
+}

package/lib/feature/unlock/method/detail.d.ts

@@ -0,0 +1,3 @@
+import type { UnlockMethodDetail } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodDetailForRuntime(rt: LockDeviceRuntime, id: number): Promise<UnlockMethodDetail>;

package/lib/feature/unlock/method/detail.js

@@ -0,0 +1,35 @@
+import { getUnlockMethodInfo } from "../../../api/lock";
+import { getUnlockMethodTypeByDpCodeForRuntime } from "../../utils";
+import { handleCloudError } from "../../../utils/errors";
+export async function getUnlockMethodDetailForRuntime(rt, id) {
+    const cfg = rt.config;
+    try {
+        const cloudData = await getUnlockMethodInfo({
+            devId: cfg.devInfo.devId,
+            opModeId: id,
+        });
+        const detail = {
+            isBound: cloudData.allocateFlag === 1,
+            type: getUnlockMethodTypeByDpCodeForRuntime(rt, cfg.codesById[Number(cloudData.opmode)])?.type,
+            phase: cloudData.phase,
+            dpId: Number(cloudData.opmode),
+            isSpecial: cloudData.unlockAttr === 1,
+            unlockName: cloudData.unlockName,
+            userId: cloudData.userId,
+            unlockId: Number(cloudData.opmodeValue),
+            lockUserId: cloudData.lockUserId,
+            id: cloudData.opmodeId,
+            userType: cloudData.userType,
+            notifyInfo: {
+                appSend: !!cloudData.notifyInfo?.appSend,
+                msgSend: !!cloudData.notifyInfo?.msgPhone,
+                msgPhone: cloudData.notifyInfo?.msgPhone,
+                countryCode: cloudData.notifyInfo?.countryCode,
+            },
+        };
+        return detail;
+    }
+    catch (error) {
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/unlock/method/guide.d.ts

@@ -0,0 +1,3 @@
+import type { UnlockGuide, UnlockMethodType } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function getUnlockGuideForRuntime(rt: LockDeviceRuntime, type: UnlockMethodType): Promise<UnlockGuide | null>;

package/lib/feature/unlock/method/guide.js

@@ -0,0 +1,48 @@
+import { getFileRemoteUrl } from "../../../api";
+import { getDeviceAdvancedAbilitiesForRuntime } from "../../misc/capability";
+const guileTypeMap = {
+    card: ["addCard", "addCardPic"],
+    finger: ["addFingerprint", "addFingerprintPic"],
+    face: ["addFace", "addFacePic"],
+    fingerVein: ["addFingervein", "addFingerveinPic"],
+    hand: ["addPalmvein", "addPalmveinPic"],
+    eye: ["addIris", "addIrisPic"],
+};
+export async function getUnlockGuideForRuntime(rt, type) {
+    if (type === "password") {
+        return null;
+    }
+    const { unlockGuide } = await getDeviceAdvancedAbilitiesForRuntime(rt);
+    if (unlockGuide.support) {
+        const [videoKey, picKey] = guileTypeMap[type] || ["", ""];
+        const resources = [];
+        let videoUrlPath = "";
+        let picUrlPath = "";
+        if (unlockGuide.config[picKey]) {
+            picUrlPath = unlockGuide.config[picKey].url;
+            resources.push({
+                objectKey: picUrlPath,
+            });
+        }
+        if (unlockGuide.config[videoKey]) {
+            videoUrlPath = unlockGuide.config[videoKey].url;
+            resources.push({
+                objectKey: videoUrlPath,
+            });
+        }
+        if (resources.length === 0) {
+            return null;
+        }
+        const { signedUrls } = await getFileRemoteUrl({
+            biz: "hulk_video_tutorial_video",
+            resources,
+        });
+        const expireTime = Date.now() + 30 * 60 * 1000;
+        return {
+            videoUrl: signedUrls[videoUrlPath],
+            picUrl: signedUrls[picUrlPath],
+            expireTime,
+        };
+    }
+    return null;
+}

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

@@ -0,0 +1,109 @@
+import type { DpMap } from "@ray-js/tuya-dp-transform";
+import type { DpMapDataType, UnlockMethodType } from "../../../../interface";
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare function getUnlockMethodBase(rt: LockDeviceRuntime, type: UnlockMethodType, userId: string): Promise<{
+    unlockMethodConfig: import("../../../../interface").UnlockMethodConfig;
+    devId: string;
+    userType: import("../../../..").UserType;
+    lockUserId: number;
+    sn: number;
+    dpId: number;
+    addDpCode: "unlock_method_create_w" | "unlock_method_create";
+    addDpMap: DpMap;
+    addDpReportMap: DpMap;
+    dpData: DpMapDataType<readonly [{
+        readonly name: "type";
+    }, {
+        readonly name: "stage";
+    }, {
+        readonly name: "admin";
+        readonly type: "boolean";
+        readonly defaultValue: false;
+    }, {
+        readonly name: "memberId";
+    }, {
+        readonly name: "unlockId";
+    }, {
+        readonly name: "validConfig";
+        readonly type: "child";
+        readonly bytes: 17;
+        readonly childMap: readonly [{
+            readonly name: "startTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "endTime";
+            readonly bytes: 4;
+        }, {
+            readonly name: "loop";
+        }, {
+            readonly name: "loopConfig";
+            readonly condition: {
+                readonly type: "and";
+                readonly conditions: readonly [{
+                    readonly prop: "validConfig.loop";
+                    readonly value: 2;
+                    readonly operation: "neq";
+                }, {
+                    readonly prop: "loop";
+                    readonly value: 3;
+                    readonly operation: "neq";
+                }];
+            };
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "weeks";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 2;
+            };
+            readonly type: "custom";
+            readonly bytes: 4;
+            readonly parse: (value: number) => number[];
+            readonly format: (value: number[]) => string;
+            readonly defaultValue: readonly [0, 0, 0, 0, 0, 0, 0];
+        }, {
+            readonly name: "days";
+            readonly condition: {
+                readonly prop: "validConfig.loop";
+                readonly value: 3;
+            };
+            readonly type: "bits";
+            readonly bytes: 4;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "startMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endHour";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }, {
+            readonly name: "endMinute";
+            readonly type: "number";
+            readonly bytes: 1;
+            readonly defaultValue: 0;
+        }];
+    }, {
+        readonly name: "validNum";
+    }, {
+        readonly name: "pwdLength";
+    }, {
+        readonly name: "pwd";
+        readonly type: "number";
+        readonly limit: "pwdLength";
+        readonly loop: true;
+        readonly defaultValue: readonly [];
+    }, {
+        readonly name: "sn";
+        readonly bytes: 2;
+    }]>;
+}>;

package/lib/feature/unlock/method/internal/base.js

@@ -0,0 +1,89 @@
+import { fetchCreatePasswordSN } from "../../../../api/lock";
+import dpCodes from "../../../../config/dp-code";
+import { add as addMap, reportAdd as reportAddMap, } from "../../../../config/dp-map/unlock-method";
+import { add as addBigMap, reportAdd as reportAddBigMap, } from "../../../../config/dp-map/unlock-method-big";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../../utils";
+import { getPermanentSetting, isAdmin } from "../../../../utils";
+import { LoopTypes } from "../../../../utils/constant";
+import { getUserInfoForRuntime } from "../../../user/user";
+export async function getUnlockMethodBase(rt, type, userId) {
+    const { idsByCode, devInfo: { devId }, supportBigData, } = rt.config;
+    const unlockMethodConfig = getUnlockMethodTypeByTypeForRuntime(rt, type);
+    const addDpCode = supportBigData
+        ? dpCodes.unlockMethodCreateW
+        : dpCodes.unlockMethodCreate;
+    const dpId = idsByCode[unlockMethodConfig.code];
+    const [user, sn] = await Promise.all([
+        getUserInfoForRuntime(rt, {
+            userId: userId,
+        }),
+        fetchCreatePasswordSN({
+            devId: devId,
+            dpId,
+        }),
+    ]);
+    const { userType, lockUserId, timeScheduleInfo } = user;
+    let validConfig;
+    if (timeScheduleInfo) {
+        const { permanent, effectiveTime, expiredTime, scheduleDetails } = timeScheduleInfo;
+        if (permanent) {
+            validConfig = {
+                startTime: effectiveTime
+                    ? Math.floor(effectiveTime / 1000)
+                    : 0x386cd300,
+                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+                loop: LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: 0,
+                startMinute: 0,
+                endHour: 0,
+                endMinute: 0,
+            };
+        }
+        else {
+            validConfig = {
+                startTime: Math.floor((effectiveTime || +new Date()) / 1000),
+                endTime: expiredTime ? Math.floor(expiredTime / 1000) : 0x72bc9b7f,
+                loop: scheduleDetails?.repeat ? LoopTypes.WEEK : LoopTypes.NONE,
+                loopConfig: 0,
+                weeks: scheduleDetails?.repeat
+                    ? scheduleDetails?.weeks
+                    : [0, 0, 0, 0, 0, 0, 0],
+                days: [],
+                startHour: Math.floor((scheduleDetails?.effectiveTime ?? 0) / 60),
+                startMinute: (scheduleDetails?.effectiveTime ?? 0) % 60,
+                endHour: Math.floor((scheduleDetails?.invalidTime ?? 0) / 60),
+                endMinute: (scheduleDetails?.invalidTime ?? 0) % 60,
+            };
+        }
+    }
+    else {
+        validConfig = getPermanentSetting();
+    }
+    const dpData = {
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId: supportBigData ? 0xffff : 0xff,
+        validConfig,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+        sn,
+    };
+    return {
+        unlockMethodConfig,
+        devId,
+        userType,
+        lockUserId,
+        sn,
+        dpId,
+        addDpCode,
+        addDpMap: (supportBigData ? addBigMap : addMap),
+        addDpReportMap: (supportBigData ? reportAddBigMap : reportAddMap),
+        dpData,
+    };
+}

package/lib/feature/unlock/method/internal/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const getAddUnlockError: (status: number) => import("../../../..").ErrorData | {
+    devCode: number;
+    errorCode: number;
+    errorMsg: string;
+};

package/lib/feature/unlock/method/internal/errors.js

@@ -0,0 +1,13 @@
+import { getError } from "../../../../utils/errors";
+export const getAddUnlockError = (status) => {
+    if (status >= 0 && status <= 10) {
+        return getError(1015 + status);
+    }
+    if (status === 0xfe) {
+        return getError(1026);
+    }
+    return {
+        ...getError(1016),
+        devCode: status,
+    };
+};

package/lib/feature/unlock/method/internal/special-check.d.ts

@@ -0,0 +1,13 @@
+import type { NotifyInfo } from "../../../../interface";
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+import type { SpecialUnlockMethodInfo } from "../types";
+export declare function checkSpecialSupportPhoneForRuntime(rt: LockDeviceRuntime): boolean;
+export declare const checkSpecial: (rt: LockDeviceRuntime, isSpecial: boolean, params?: SpecialUnlockMethodInfo, oldSetting?: NotifyInfo) => {
+    unlockAttr: number;
+    notifyInfo: {
+        appSend: boolean;
+        msgPhone: string | undefined;
+        countryCode: string | undefined;
+        msgPhoneVerifyCode: string | undefined;
+    };
+};

package/lib/feature/unlock/method/internal/special-check.js

@@ -0,0 +1,38 @@
+import dpCodes from "../../../../config/dp-code";
+import { getError } from "../../../../utils/errors";
+export function checkSpecialSupportPhoneForRuntime(rt) {
+    return !!rt.config.dpSchema[dpCodes.message];
+}
+export const checkSpecial = (rt, isSpecial, params, oldSetting) => {
+    const supportedPhone = checkSpecialSupportPhoneForRuntime(rt);
+    if (isSpecial) {
+        if (!params?.appSend) {
+            if (!supportedPhone) {
+                throw getError(1057);
+            }
+            else if (!params?.msgSend) {
+                throw getError(1058);
+            }
+        }
+        if (supportedPhone && params?.msgSend) {
+            if (!params.msgPhone) {
+                throw getError(1066);
+            }
+            if (!params.countryCode) {
+                throw getError(1056);
+            }
+            if (params.msgPhone !== oldSetting?.msgPhone && !params.verifyCode) {
+                throw getError(1055);
+            }
+        }
+    }
+    return {
+        unlockAttr: isSpecial ? 1 : 0,
+        notifyInfo: {
+            appSend: !!params?.appSend,
+            msgPhone: supportedPhone && params?.msgSend ? params?.msgPhone : undefined,
+            countryCode: supportedPhone && params?.msgSend ? params?.countryCode : undefined,
+            msgPhoneVerifyCode: supportedPhone && params?.msgSend ? params?.verifyCode : undefined,
+        },
+    };
+};

package/lib/feature/unlock/method/types.d.ts

@@ -0,0 +1,70 @@
+import type { ErrorData, UnlockMethodType } from "../../../interface";
+export interface SpecialUnlockMethodInfo {
+    appSend?: boolean;
+    msgSend?: boolean;
+    msgPhone?: string;
+    verifyCode?: string;
+    countryCode?: string;
+}
+export interface AddUnlockMethodBaseParams {
+    userId: string;
+    name: string;
+    isSpecial?: boolean;
+    specialInfo?: SpecialUnlockMethodInfo;
+}
+export interface AddPasswordParams extends AddUnlockMethodBaseParams {
+    password: string;
+}
+export interface updateUnlockMethodParams {
+    id: number;
+    name: string;
+    isSpecial?: boolean;
+    specialInfo?: SpecialUnlockMethodInfo;
+}
+export interface StartAddUnlockMethodParams {
+    type: UnlockMethodType;
+    userId: string;
+    timeout?: number;
+}
+export interface CancelAddUnlockMethodParams extends StartAddUnlockMethodParams {
+}
+export interface BindUnlockMethodParams {
+    userId: string;
+    unlockList: {
+        type: UnlockMethodType;
+        unlockId: number;
+    }[];
+}
+interface BindUnlockMethodFromLogItem {
+    type: UnlockMethodType;
+    unlockId: number;
+}
+export interface BindUnlockMethodFromLogParams {
+    userId: string;
+    unlockList: BindUnlockMethodFromLogItem[];
+}
+export interface SendVerifyCodeParams {
+    account: string;
+}
+interface StepEvent {
+    type: UnlockMethodType;
+    lockUserId: number;
+    stage: "step";
+    step: number;
+    total: number;
+}
+interface SuccessEvent {
+    type: UnlockMethodType;
+    id: number;
+    name: string;
+    stage: "success";
+}
+interface ErrorEvent {
+    type: UnlockMethodType;
+    lockUserId: number;
+    stage: "fail";
+    error: ErrorData;
+}
+export type AddUnlockMethodEvent = StepEvent | SuccessEvent | ErrorEvent;
+export type AddUnlockMethodListener = (event: AddUnlockMethodEvent) => void;
+export {};

package/lib/feature/unlock/method/types.js

@@ -0,0 +1 @@
+export {};

package/lib/feature/unlock/method/update-remove.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { updateUnlockMethodParams } from "./types";
+export declare function updateUnlockMethodForRuntime(rt: LockDeviceRuntime, params: updateUnlockMethodParams): Promise<void>;
+export declare const deleteUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, id: number) => Promise<void>;