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

package/lib/feature/user/sync-user.js

@@ -0,0 +1,151 @@
+import { getUsersSyncLockData } from "../../api/user";
+import { deleteUserForRuntime } from "./delete-user-dp";
+import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
+import { publishDpsOnlyWithRuntime, } from "../dp/publish-dps";
+import dpCodes from "../../config/dp-code";
+import { isBlePureDeviceForRuntime } from "../misc/capability";
+import { sdkLog } from "../../utils/sdk-log";
+export async function syncDeleteUsersWithRuntime(runtime) {
+    if (runtime.config.devInfo.wifiEnableState !== 1) {
+        sdkLog("debug", "syncUser", "deleteUsersSkipped", {
+            devId: runtime.devId,
+            data: { reason: "wifiActive" },
+        });
+        return;
+    }
+    if (runtime.deviceStatus.isWifiMatter) {
+        sdkLog("debug", "syncUser", "deleteUsersSkipped", {
+            devId: runtime.devId,
+            data: { reason: "wifiMatter" },
+        });
+        return;
+    }
+    if (!isUseNearChannelForRuntime(runtime)) {
+        sdkLog("debug", "syncUser", "deleteUsersSkipped", {
+            devId: runtime.devId,
+            data: { reason: "notNearChannel" },
+        });
+        return;
+    }
+    if (runtime.sync.syncDeleteUsersBusy) {
+        sdkLog("debug", "syncUser", "deleteUsersSkipped", {
+            devId: runtime.devId,
+            data: { reason: "busy" },
+        });
+        return;
+    }
+    runtime.sync.syncDeleteUsersBusy = true;
+    sdkLog("info", "syncUser", "deleteUsersStart", {
+        devId: runtime.devId,
+    });
+    let count = 0;
+    const handleSync = async () => {
+        const startedAt = Date.now();
+        try {
+            const { removedUser = [], lockRandom, lockFitting, } = await getUsersSyncLockData(runtime.config.devInfo.devId);
+            sdkLog("debug", "syncUser", "deleteUsersCloudData", {
+                devId: runtime.devId,
+                data: {
+                    removedCount: removedUser.length,
+                    hasLockRandom: !!lockRandom?.distributed,
+                    hasLockFitting: !!lockFitting?.distributed,
+                    retryCount: count,
+                },
+            });
+            const isBleDevice = isBlePureDeviceForRuntime(runtime);
+            if (isBleDevice) {
+                if (lockRandom.distributed) {
+                    sdkLog("debug", "syncUser", "publishBleRandom", {
+                        devId: runtime.devId,
+                    });
+                    publishDpsOnlyWithRuntime(runtime, {
+                        [dpCodes.checkCodeSet]: lockRandom.wakeUpIns,
+                    });
+                }
+                if (lockFitting.distributed && lockFitting.ins) {
+                    sdkLog("debug", "syncUser", "publishFittingSync", {
+                        devId: runtime.devId,
+                        data: { count: lockFitting.ins.length },
+                    });
+                    setTimeout(() => {
+                        lockFitting.ins.forEach((item) => {
+                            publishDpsOnlyWithRuntime(runtime, {
+                                [dpCodes.checkCodeSet]: item,
+                            });
+                        });
+                    }, 500);
+                }
+            }
+            const deleteSerialCollectFailures = async (users) => {
+                const failed = [];
+                for (const item of users) {
+                    try {
+                        await deleteUserForRuntime(runtime, item);
+                    }
+                    catch {
+                        sdkLog("warn", "syncUser", "deleteUserItemFail", {
+                            devId: runtime.devId,
+                            data: { userId: item.userId, lockUserId: item.lockUserId },
+                        });
+                        failed.push(item);
+                    }
+                }
+                return failed;
+            };
+            let failed = await deleteSerialCollectFailures(removedUser);
+            if (failed.length > 0) {
+                failed = await deleteSerialCollectFailures(failed);
+                if (failed.length > 0 && count < 3) {
+                    count++;
+                    sdkLog("warn", "syncUser", "deleteUsersRetry", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: { failedCount: failed.length, retryCount: count },
+                    });
+                    setTimeout(async () => {
+                        await handleSync();
+                    }, 2000);
+                }
+                else {
+                    runtime.sync.syncDeleteUsersBusy = false;
+                    sdkLog("info", "syncUser", "deleteUsersEnd", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: { failedCount: failed.length },
+                    });
+                }
+            }
+            else {
+                runtime.sync.syncDeleteUsersBusy = false;
+                sdkLog("info", "syncUser", "deleteUsersEnd", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { failedCount: 0, removedCount: removedUser.length },
+                });
+            }
+        }
+        catch (e) {
+            if (e?.innerError?.errorCode === "DEVICE_KEY_NOT_FOUND" && count < 3) {
+                count++;
+                sdkLog("warn", "syncUser", "deleteUsersKeyMissingRetry", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    data: { retryCount: count },
+                    error: e,
+                });
+                setTimeout(async () => {
+                    await handleSync();
+                }, 2000);
+            }
+            else {
+                runtime.sync.syncDeleteUsersBusy = false;
+                sdkLog("error", "syncUser", "deleteUsersFail", {
+                    devId: runtime.devId,
+                    duration: Date.now() - startedAt,
+                    error: e,
+                });
+            }
+        }
+    };
+    handleSync();
+}

package/lib/feature/user/user.d.ts

@@ -0,0 +1,37 @@
+import { EffectiveConfig, UserInfo } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export { addSharedUserForRuntime, removeSharedUserForRuntime, updateSharedUserForRuntime, type AddSharedUserParams, type RemoveSharedUserParams, type UpdateSharedUserParams, } from "./share-user";
+interface getUsersParams {
+    page?: number;
+    pageSize?: number;
+    keyword?: string;
+}
+export interface getUsersResult {
+    list: UserInfo[];
+    hasMore: boolean;
+}
+export declare function getUsersForRuntime(rt: LockDeviceRuntime, params?: getUsersParams): Promise<getUsersResult>;
+interface getUserInfoParams {
+    userId: string;
+}
+export declare function getUserInfoForRuntime(rt: LockDeviceRuntime, params: getUserInfoParams): Promise<UserInfo>;
+interface GetUserInfoOnDevParams {
+    devId: string;
+    userId: string;
+}
+export declare function getUserInfoOnDevForRuntime(rt: LockDeviceRuntime, params: GetUserInfoOnDevParams): Promise<UserInfo>;
+interface updateUserLimitTimeParams {
+    userId: string;
+    lockUserId: number;
+    permanent: boolean;
+    effective?: EffectiveConfig;
+    offlineUnlock?: boolean;
+}
+export declare function updateUserLimitTimeForRuntime(rt: LockDeviceRuntime, params: updateUserLimitTimeParams): Promise<void>;
+export declare const openAddFamilyUser: () => Promise<void>;
+export declare function openFamilyUserDetailForRuntime(rt: LockDeviceRuntime, userId: string): Promise<void>;
+interface AddUserParams {
+    name: string;
+}
+export declare function addUserForRuntime(rt: LockDeviceRuntime, params: AddUserParams): Promise<void>;
+export declare function removeUserForRuntime(rt: LockDeviceRuntime, userId: string): Promise<void>;

package/lib/feature/user/user.js

@@ -0,0 +1,484 @@
+import { getCurrentUserInfo, getUserDetailQuery, getUserList, } from "../../api/user";
+import { update as updateMap, reportUpdate as reportUpdateMap, } from "../../config/dp-map/unlock-method";
+import { update as updateMapBig, reportUpdate as reportUpdateMapBig, } from "../../config/dp-map/unlock-method-big";
+import { publishDpsForRuntime } from "../dp/publish-dps";
+import dpCodes from "../../config/dp-code";
+import DpUtils from "@ray-js/tuya-dp-transform";
+import { getError, handleCloudError } from "../../utils/errors";
+import { updateUserTimeSchedule, addNormalUser, removeNormalUser, } from "../../api/user";
+import { validConfigDpMap } from "../../config/dp-map/common";
+import { isUseNearChannelForRuntime } from "../misc/is-use-near-channel-for-runtime";
+import { getUnlockMethodTypeByDpCodeForRuntime } from "../utils";
+import { formatTimestampToMilliseconds, formatWeek, getPermanentSetting, isAdmin, parseWeek, validateEffectiveConfig, } from "../../utils";
+import { getCurrentHomeInfo, isSupportShortLink } from "../../platform/device";
+import { LoopTypes } from "../../utils/constant";
+import { getCurrentUserForRuntime } from "./current-user";
+import { deleteUserForRuntime } from "./delete-user-dp";
+import { UserType } from "../../constant";
+import { sdkLog } from "../../utils/sdk-log";
+export { addSharedUserForRuntime, removeSharedUserForRuntime, updateSharedUserForRuntime, } from "./share-user";
+const handleUserDetail = (rt, user) => {
+    const { timeScheduleInfo, unlockDetail, ...rest } = user;
+    let scheduleInfo = {
+        permanent: true,
+    };
+    if (!timeScheduleInfo.permanent &&
+        timeScheduleInfo.scheduleDetails &&
+        timeScheduleInfo.scheduleDetails.length > 0) {
+        Object.assign(scheduleInfo, {
+            permanent: false,
+            effectiveTime: formatTimestampToMilliseconds(timeScheduleInfo.effectiveTime || 0),
+            expiredTime: formatTimestampToMilliseconds(timeScheduleInfo.expiredTime || 0),
+            scheduleDetails: {
+                repeat: !timeScheduleInfo.scheduleDetails[0].allDay,
+                effectiveTime: timeScheduleInfo.scheduleDetails[0].effectiveTime,
+                invalidTime: timeScheduleInfo.scheduleDetails[0].invalidTime,
+                timeZoneId: timeScheduleInfo.scheduleDetails[0].timeZoneId,
+                weeks: parseWeek(timeScheduleInfo.scheduleDetails[0].workingDay),
+            },
+        });
+    }
+    let unlockDetails = unlockDetail.map((detail) => {
+        const unlockList = detail.unlockList.map((unlockItem) => {
+            return {
+                unlockId: +unlockItem.unlockId.split("-")[1],
+                unlockName: unlockItem.unlockName,
+                id: unlockItem.opModeId,
+                isBound: unlockItem.allocateFlag === 1,
+                photoUnlock: unlockItem.photoUnlock,
+                isSpecial: unlockItem.unlockAttr === 1,
+            };
+        });
+        const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, detail.dpCode);
+        return {
+            count: unlockList.length,
+            dpCode: detail.dpCode,
+            dpId: detail.dpId,
+            type: unlockMethodConfig.type,
+            unlockList,
+        };
+    });
+    return {
+        ...rest,
+        timeScheduleInfo: scheduleInfo,
+        unlockDetails,
+        isAccountUser: user.userListType === "group_user",
+        isFamilyUser: user.userListType === "group_user",
+    };
+};
+const concactUserList = (rt, list, result) => {
+    return list.reduce((acc, item) => {
+        acc.push(handleUserDetail(rt, item));
+        return acc;
+    }, result);
+};
+const getUserDpCodes = async (rt) => {
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const dps = [];
+    if (currentUser.allOpenDps) {
+        currentUser.allOpenDps.split(",").reduce((acc, cur) => {
+            const code = rt.config.codesById[cur];
+            if (code) {
+                acc.push(code);
+            }
+            return acc;
+        }, dps);
+    }
+    return dps;
+};
+export async function getUsersForRuntime(rt, params) {
+    const { page = 1, pageSize = 10, keyword = "" } = params || {};
+    const startedAt = Date.now();
+    sdkLog("info", "user", "getUsersStart", {
+        devId: rt.devId,
+        data: { page, pageSize, hasKeyword: !!keyword },
+    });
+    const dps = await getUserDpCodes(rt);
+    const res = await getUserList({
+        dpCodes: dps.join(","),
+        devId: rt.config.devInfo.devId,
+        offset: (page - 1) * pageSize,
+        limit: pageSize,
+        keyword,
+    });
+    let list = [];
+    if (res.admin && res.admin.length > 0) {
+        concactUserList(rt, res.admin, list);
+    }
+    if (res.user && res.user.length > 0) {
+        concactUserList(rt, res.user, list);
+    }
+    sdkLog("info", "user", "getUsersSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { count: list.length, hasMore: res.hasNext },
+    });
+    return {
+        list,
+        hasMore: res.hasNext,
+    };
+}
+export async function getUserInfoForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "user", "getUserInfoStart", {
+        devId: rt.devId,
+        data: { userId: params.userId },
+    });
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const res = await getUserDetailQuery({
+        devId: rt.config.devInfo.devId,
+        userId: params.userId,
+        dpIds: currentUser.allOpenDps,
+    });
+    const result = handleUserDetail(rt, res);
+    sdkLog("info", "user", "getUserInfoSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { userId: params.userId, userType: result.userType },
+    });
+    return result;
+}
+export async function getUserInfoOnDevForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "user", "getUserInfoOnDevStart", {
+        devId: rt.devId,
+        data: { targetDevId: params.devId, userId: params.userId },
+    });
+    const currentUser = await getCurrentUserInfo(params.devId);
+    const res = await getUserDetailQuery({
+        devId: params.devId,
+        userId: params.userId,
+        dpIds: currentUser.allOpenDps || "",
+    });
+    const result = handleUserDetail(rt, res);
+    sdkLog("info", "user", "getUserInfoOnDevSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { targetDevId: params.devId, userId: params.userId },
+    });
+    return result;
+}
+export async function updateUserLimitTimeForRuntime(rt, params) {
+    const { userId, lockUserId, permanent, effective } = params;
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "user", "updateLimitTimeStart", {
+        devId: rt.devId,
+        data: {
+            userId,
+            lockUserId,
+            permanent,
+            offlineUnlock: !!params.offlineUnlock,
+            repeat: effective?.repeat,
+        },
+    });
+    const dpCode = cfg.supportBigData
+        ? dpCodes.unlockMethodEditW
+        : dpCodes.unlockMethodEdit;
+    if (!cfg.dpSchema[dpCode]) {
+        const error = getError(1014);
+        sdkLog("warn", "user", "updateLimitTimeUnsupportedDp", {
+            devId: rt.devId,
+            data: { dpCode },
+            error,
+        });
+        throw error;
+    }
+    if (!permanent) {
+        validateEffectiveConfig(effective);
+    }
+    const currentUser = await getCurrentUserForRuntime(rt);
+    if (!isAdmin(currentUser.userType)) {
+        const error = getError(1069);
+        sdkLog("warn", "user", "updateLimitTimeNoPermission", {
+            devId: rt.devId,
+            data: { currentUserType: currentUser.userType },
+            error,
+        });
+        throw error;
+    }
+    const { userType } = await getUserInfoForRuntime(rt, {
+        userId,
+    });
+    if (isAdmin(userType)) {
+        const error = getError(1049);
+        sdkLog("warn", "user", "updateLimitTimeTargetAdmin", {
+            devId: rt.devId,
+            data: { userId, userType },
+            error,
+        });
+        throw error;
+    }
+    const { repeat, effectiveTime = 0, expiredTime = 1439 } = effective || {};
+    const loopType = repeat
+        ?
+            LoopTypes[repeat.toUpperCase()]
+        : LoopTypes.NONE;
+    const dpValue = {
+        type: 0,
+        stage: 0,
+        admin: false,
+        memberId: lockUserId,
+        unlockId: 255,
+        validNum: 0,
+        pwdLength: 0,
+        pwd: [],
+        validConfig: permanent
+            ? getPermanentSetting()
+            : {
+                startTime: effective.effectiveDate,
+                endTime: effective.expiredDate,
+                loop: loopType,
+                loopConfig: 0,
+                weeks: effective?.repeat !== "week" || effective?.weeks === undefined
+                    ? [0, 0, 0, 0, 0, 0, 0]
+                    : effective.weeks,
+                days: [],
+                startHour: Math.floor(effectiveTime / 60),
+                startMinute: effectiveTime % 60,
+                endHour: Math.floor(expiredTime / 60),
+                endMinute: expiredTime % 60,
+            },
+    };
+    const res = (await publishDpsForRuntime(rt, {
+        [dpCode]: DpUtils.format(dpValue, (cfg.supportBigData ? updateMapBig : updateMap)),
+    }, {
+        checkReport: (dps) => {
+            if (typeof dps[dpCode] !== "undefined") {
+                const result = DpUtils.parse(dps[dpCode], (cfg.supportBigData
+                    ? reportUpdateMapBig
+                    : reportUpdateMap));
+                if (result.type === 0) {
+                    if (result.memberId === lockUserId) {
+                        return result;
+                    }
+                    else {
+                        console.warn("An incorrect member id was returned");
+                        sdkLog("warn", "user", "updateLimitTimeMemberMismatch", {
+                            devId: rt.devId,
+                            data: { userId },
+                        });
+                    }
+                }
+            }
+            return false;
+        },
+    }));
+    if (res.status !== 255) {
+        const error = getError(1011);
+        sdkLog("warn", "user", "updateLimitTimeDpFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { status: res.status },
+            error,
+        });
+        throw error;
+    }
+    try {
+        await updateUserTimeSchedule({
+            devId: cfg.devInfo.devId,
+            userId: userId,
+            timeScheduleInfo: {
+                permanent,
+                userTimeSet: DpUtils.format(dpValue.validConfig, validConfigDpMap.childMap),
+                effectiveTime: dpValue.validConfig.startTime,
+                expiredTime: dpValue.validConfig.endTime,
+                scheduleDetails: [
+                    {
+                        allDay: loopType === LoopTypes.NONE,
+                        effectiveTime: permanent ? 0 : effectiveTime,
+                        invalidTime: permanent ? 0 : expiredTime,
+                        workingDay: permanent ? 0 : formatWeek(dpValue.validConfig.weeks),
+                    },
+                ],
+            },
+        });
+        sdkLog("info", "user", "updateLimitTimeSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { userId, permanent },
+        });
+        return;
+    }
+    catch (e) {
+        sdkLog("error", "user", "updateLimitTimeCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { userId },
+            error: e,
+        });
+        handleCloudError(e, 1012);
+    }
+}
+export const openAddFamilyUser = async () => {
+    const homeInfo = await getCurrentHomeInfo();
+    let link = await isSupportShortLink("tysh_family_add_member_rn");
+    if (!link) {
+        link = await isSupportShortLink("thingsh_family_add_member_rn");
+    }
+    if (link) {
+        const url = `tuyaSmart://${link}?homeId=${homeInfo.homeId}`;
+        return new Promise((resolve, reject) => {
+            ty.router({
+                url: url,
+                success: () => {
+                    resolve();
+                },
+                fail: (e) => {
+                    reject(e);
+                },
+            });
+        });
+    }
+    return Promise.reject(getError(1013));
+};
+const userTypeMap = {
+    "10": 1,
+    "20": 0,
+    "40": -1,
+    "50": 2,
+};
+export async function openFamilyUserDetailForRuntime(rt, userId) {
+    const startedAt = Date.now();
+    sdkLog("info", "user", "openFamilyUserDetailStart", {
+        devId: rt.devId,
+        data: { userId },
+    });
+    const { homeId } = await getCurrentHomeInfo();
+    const { userType: currentUserType } = await getCurrentUserForRuntime(rt);
+    const role = userTypeMap[currentUserType];
+    let link = await isSupportShortLink("member_info");
+    if (link) {
+        const url = `tuyaSmart://member_info?homeId=${homeId}&memberId=${userId}&role=${role}`;
+        ty.router({
+            url: url,
+            fail: (e) => {
+                console.error("openFamilyUserDetail fail", e);
+                sdkLog("error", "user", "openFamilyUserDetailRouteFail", {
+                    devId: rt.devId,
+                    duration: Date.now() - startedAt,
+                    data: { userId, role },
+                    error: e,
+                });
+            },
+        });
+        sdkLog("info", "user", "openFamilyUserDetailSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { userId, role },
+        });
+        return;
+    }
+    const error = getError(1013);
+    sdkLog("warn", "user", "openFamilyUserDetailUnsupported", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { userId, role },
+        error,
+    });
+    return Promise.reject(error);
+}
+export async function addUserForRuntime(rt, params) {
+    if (!rt.config.supportBigData) {
+        const error = getError(1060);
+        sdkLog("warn", "user", "addUserUnsupported", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    if (!params.name) {
+        const error = getError(1009, "name");
+        sdkLog("warn", "user", "addUserMissingName", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "user", "addUserStart", {
+        devId: rt.devId,
+        data: { nameLength: params.name.length },
+    });
+    try {
+        await addNormalUser({
+            devId: rt.config.devInfo.devId,
+            name: params.name,
+        });
+        sdkLog("info", "user", "addUserSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (e) {
+        if (e?.innerError?.errorCode === "DEFINITION_PARAM_NAME_REPEAT") {
+            const error = getError(1068);
+            sdkLog("warn", "user", "addUserNameRepeat", {
+                devId: rt.devId,
+                duration: Date.now() - startedAt,
+                error,
+            });
+            throw error;
+        }
+        sdkLog("error", "user", "addUserFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error: e,
+        });
+        throw e;
+    }
+}
+export async function removeUserForRuntime(rt, userId) {
+    if (!rt.config.supportBigData) {
+        const error = getError(1060);
+        sdkLog("warn", "user", "removeUserUnsupported", {
+            devId: rt.devId,
+            data: { userId },
+            error,
+        });
+        throw error;
+    }
+    const startedAt = Date.now();
+    sdkLog("info", "user", "removeUserStart", {
+        devId: rt.devId,
+        data: { userId },
+    });
+    const res = await getUserInfoForRuntime(rt, {
+        userId,
+    });
+    if (res.isFamilyUser) {
+        const error = getError(1072);
+        sdkLog("warn", "user", "removeUserFamilyUser", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { userId, userType: res.userType },
+            error,
+        });
+        throw error;
+    }
+    if (isUseNearChannelForRuntime(rt)) {
+        const result = await deleteUserForRuntime(rt, {
+            userId,
+            lockUserId: res.lockUserId,
+            admin: res.userType === UserType.ADMIN || res.userType === UserType.OWNER,
+        });
+        sdkLog("info", "user", "removeUserSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { userId, route: "nearDp" },
+        });
+        return result;
+    }
+    const result = await removeNormalUser({
+        devId: rt.config.devInfo.devId,
+        userId,
+        shouldDeleteUnlockInfo: true,
+        issueDp: true,
+    });
+    sdkLog("info", "user", "removeUserSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { userId, route: "cloud" },
+    });
+    return result;
+}

package/lib/feature/utils/index.d.ts

@@ -0,0 +1,12 @@
+import type { UnlockMethodConfig } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const getUnlockMethodTypeByDpCodeForRuntime: (rt: LockDeviceRuntime, dpCode: string) => UnlockMethodConfig;
+export declare const getUnlockMethodTypeByIdForRuntime: (rt: LockDeviceRuntime, id: number | string) => UnlockMethodConfig;
+export declare const getUnlockMethodTypeByTypeForRuntime: (rt: LockDeviceRuntime, type: string) => UnlockMethodConfig;
+export declare const parseOfflinePasswordForRuntime: (rt: LockDeviceRuntime, value: string) => string;
+export declare const parallelOnlyForRuntime: <T extends (rt: LockDeviceRuntime, ...args: any[]) => Promise<any>>(cb: T) => (this: unknown, rt: LockDeviceRuntime, ...args: Parameters<T> extends [LockDeviceRuntime, ...infer R] ? R : never) => Promise<Awaited<ReturnType<T>>>;
+export declare const parallelMergeForRuntime: <T extends (rt: LockDeviceRuntime, ...args: any[]) => Promise<any>>(cb: T) => (this: unknown, rt: LockDeviceRuntime, ...args: Parameters<T> extends [LockDeviceRuntime, ...infer R] ? R : never) => Promise<Awaited<ReturnType<T>>>;
+declare const preFetchKeys: readonly ["getRotate", "getCurrentUser", "getDeviceProperties"];
+type PreFetchKey = (typeof preFetchKeys)[number];
+export declare const getDataWithPreFetchForRuntime: <T>(rt: LockDeviceRuntime, key: PreFetchKey, apiCb: () => Promise<T>) => Promise<T>;
+export {};