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

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 {};

package/lib/feature/utils/index.js

@@ -0,0 +1,165 @@
+import dpCodes from "../../config/dp-code";
+import { getBackgroundFetchData, onBackgroundFetchData, } from "../../platform/device";
+import { getError } from "../../utils/errors";
+const unlockMethodConfigs = [
+    {
+        type: "password",
+        codes: [dpCodes.unlockPassword, dpCodes.unlockPasswordKit],
+        id: 1,
+    },
+    {
+        type: "card",
+        codes: [dpCodes.unlockCard, dpCodes.unlockCardKit],
+        id: 2,
+    },
+    {
+        type: "finger",
+        codes: [dpCodes.unlockFingerprint, dpCodes.unlockFingerprintKit],
+        id: 3,
+    },
+    {
+        type: "face",
+        codes: [dpCodes.unlockFace, dpCodes.unlockFaceKit],
+        id: 4,
+    },
+    {
+        type: "hand",
+        codes: [dpCodes.unlockHand, dpCodes.unlockHandKit],
+        id: 5,
+    },
+    {
+        type: "fingerVein",
+        codes: [dpCodes.unlockFingerVein, dpCodes.unlockFingerVeinKit],
+        id: 6,
+    },
+];
+const getUnlockMethodTypeForRuntime = (rt, cb) => {
+    const result = unlockMethodConfigs.find(cb);
+    if (result) {
+        const code = result.codes.find((code) => rt.config.dpSchema[code]);
+        if (code) {
+            return {
+                ...result,
+                code,
+            };
+        }
+    }
+    throw getError(1014);
+};
+export const getUnlockMethodTypeByDpCodeForRuntime = (rt, dpCode) => getUnlockMethodTypeForRuntime(rt, (item) => item.codes.includes(dpCode));
+export const getUnlockMethodTypeByIdForRuntime = (rt, id) => getUnlockMethodTypeForRuntime(rt, (item) => item.id === id);
+export const getUnlockMethodTypeByTypeForRuntime = (rt, type) => getUnlockMethodTypeForRuntime(rt, (item) => item.type === type);
+export const parseOfflinePasswordForRuntime = (rt, value) => {
+    const { passwordDigitalBase, passwordSupportZero } = rt.config;
+    if (passwordDigitalBase === 10) {
+        return value;
+    }
+    let digitalCode = Number(value).toString(passwordDigitalBase);
+    const zeroList = value.match(/(^0+)/);
+    if (zeroList) {
+        digitalCode = zeroList[0] + digitalCode;
+    }
+    if (passwordSupportZero === false) {
+        digitalCode = digitalCode
+            .split("")
+            .map((n) => {
+            return Number(n) + 1;
+        })
+            .join("");
+    }
+    return digitalCode;
+};
+export const parallelOnlyForRuntime = (cb) => {
+    const running = new WeakMap();
+    return async function (rt, ...args) {
+        if (running.get(rt)) {
+            throw getError(1052);
+        }
+        running.set(rt, true);
+        try {
+            return await cb.apply(this, [rt, ...args]);
+        }
+        finally {
+            running.delete(rt);
+        }
+    };
+};
+export const parallelMergeForRuntime = (cb) => {
+    const slotByRt = new WeakMap();
+    const getSlot = (rt) => {
+        let slot = slotByRt.get(rt);
+        if (!slot) {
+            slot = { isRunning: false, byKey: {} };
+            slotByRt.set(rt, slot);
+        }
+        return slot;
+    };
+    return async function (rt, ...args) {
+        const key = JSON.stringify(args);
+        const slot = getSlot(rt);
+        if (slot.isRunning) {
+            if (!slot.byKey[key]) {
+                slot.byKey[key] = [];
+            }
+            return new Promise((resolve, reject) => {
+                slot.byKey[key].push({ resolve, reject });
+            });
+        }
+        slot.isRunning = true;
+        try {
+            const result = (await cb.apply(this, [
+                rt,
+                ...args,
+            ]));
+            slot.isRunning = false;
+            if (slot.byKey[key]) {
+                const list = slot.byKey[key];
+                delete slot.byKey[key];
+                setTimeout(() => {
+                    list.forEach((item) => item.resolve(result));
+                }, 0);
+            }
+            return result;
+        }
+        catch (error) {
+            slot.isRunning = false;
+            if (slot.byKey[key]) {
+                const list = slot.byKey[key];
+                delete slot.byKey[key];
+                setTimeout(() => {
+                    list.forEach((item) => item.reject(error));
+                }, 0);
+            }
+            throw error;
+        }
+    };
+};
+const preFetchKeys = [
+    "getRotate",
+    "getCurrentUser",
+    "getDeviceProperties",
+];
+const preFetchData = {};
+onBackgroundFetchData(preFetchKeys, (res) => {
+    Object.keys(res?.fetchedData ?? {}).forEach((key) => {
+        preFetchData[key] = res.fetchedData[key].fetchedData;
+    });
+});
+export const getDataWithPreFetchForRuntime = async (rt, key, apiCb) => {
+    if (rt.config.preFetch) {
+        if (preFetchData[key]) {
+            return preFetchData[key];
+        }
+        try {
+            const result = await getBackgroundFetchData([key]);
+            if (result &&
+                result.fetchedData[key] &&
+                result.fetchedData[key].fetchedData) {
+                return result.fetchedData[key].fetchedData;
+            }
+        }
+        catch {
+        }
+    }
+    return apiCb();
+};

package/lib/feature/voice-file/voice-file.d.ts

@@ -0,0 +1,27 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface VoiceFileProgressEvent {
+    deviceId: string;
+    fileType?: number;
+    fileKey?: string;
+    version?: string;
+    progress: number;
+}
+export type VoiceFileProgressCallback = (event: VoiceFileProgressEvent) => void;
+export interface VoiceFileStatus {
+    fileType: number;
+    version: string;
+    status: number;
+}
+export declare function parseVoiceFileStatus(raw: unknown): VoiceFileStatus | null;
+export declare function voiceFileVersionToNumber(version?: string): number;
+export interface VoiceFileItem {
+    fileType: number;
+    fileKey: string;
+    version: string;
+    status: number;
+}
+export declare function getVoiceFileListForRuntime(runtime: LockDeviceRuntime): Promise<VoiceFileItem[]>;
+export declare function getCurrentVoiceFileForRuntime(runtime: LockDeviceRuntime): VoiceFileStatus | null;
+export declare function onVoiceFileProgressForRuntime(runtime: LockDeviceRuntime, callback: VoiceFileProgressCallback): void;
+export declare function offVoiceFileProgressForRuntime(runtime: LockDeviceRuntime, callback: VoiceFileProgressCallback): void;
+export declare function sendVoiceFileForRuntime(runtime: LockDeviceRuntime, file: VoiceFileItem): Promise<true>;