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

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

package/lib/feature/voice-file/voice-file.js

@@ -0,0 +1,203 @@
+import { Base64 } from "js-base64";
+import dpUtils from "@ray-js/tuya-dp-transform";
+import dpCodes from "../../config/dp-code";
+import { getVoiceFileDownloadUrlApi, getVoiceFileListApi, } from "../../api/voice-file";
+import { offBLEBigDataChannelProgressEvent, onBLEBigDataChannelProgressEvent, postBLEFileTransfer, } from "../../platform/device";
+import emitter from "../../utils/event";
+import { bleVoiceData } from "../../config/dp-map/ble-voice-data";
+import { hasDpForRuntime } from "../dp/has-dp";
+import { getError } from "../../utils/errors";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { sdkLog } from "../../utils/sdk-log";
+const VOICE_FILE_PROGRESS_EVENT = "voice_file_progress";
+const VOICE_FILE_ALREADY_EXISTS_CODE = "205158";
+const activeTransfers = new Map();
+let bridgeRegistered = false;
+let progressListenerCount = 0;
+function getVoiceFileProgressEvent(runtime) {
+    return `${VOICE_FILE_PROGRESS_EVENT}_${runtime.devId}`;
+}
+function normalizeProgress(progress) {
+    const value = Number(progress);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, Math.trunc(value)));
+}
+const handleNativeProgress = (data) => {
+    const deviceId = data.deviceId;
+    if (!deviceId) {
+        return;
+    }
+    const target = activeTransfers.get(deviceId);
+    emitter.emit(`${VOICE_FILE_PROGRESS_EVENT}_${deviceId}`, {
+        deviceId,
+        fileType: target?.fileType,
+        fileKey: target?.fileKey,
+        version: target?.version,
+        progress: normalizeProgress(data.progress),
+    });
+};
+function ensureProgressBridge() {
+    if (!bridgeRegistered) {
+        onBLEBigDataChannelProgressEvent(handleNativeProgress);
+        bridgeRegistered = true;
+    }
+}
+function cleanupProgressBridge() {
+    if (bridgeRegistered &&
+        progressListenerCount <= 0 &&
+        activeTransfers.size === 0) {
+        offBLEBigDataChannelProgressEvent(handleNativeProgress);
+        bridgeRegistered = false;
+    }
+}
+export function parseVoiceFileStatus(raw) {
+    if (typeof raw !== "string" || raw.length < 14) {
+        return {
+            fileType: 0,
+            version: "0.0.0",
+            status: 0,
+        };
+    }
+    const res = dpUtils.parse(raw, bleVoiceData);
+    return {
+        fileType: res.type,
+        version: `${res.major}.${res.minor}.${res.patch}`,
+        status: res.status,
+    };
+}
+export function voiceFileVersionToNumber(version = "0") {
+    const hex = version.split(".").reduce((acc, part) => {
+        return acc + Number(part).toString(16).padStart(2, "0");
+    }, "");
+    return parseInt(`0x${hex.padStart(8, "0")}`, 16);
+}
+export async function getVoiceFileListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "voiceFile", "getListStart", {
+        devId: runtime.devId,
+    });
+    if (!hasDpForRuntime(runtime, dpCodes.voiceData)) {
+        const error = getError(1014);
+        sdkLog("warn", "voiceFile", "getListUnsupported", {
+            devId: runtime.devId,
+            error,
+        });
+        throw error;
+    }
+    const list = await getVoiceFileListApi(runtime.devId);
+    const result = list.map((item) => ({
+        fileType: item.fileType,
+        fileKey: item.fileKey,
+        version: item.version,
+        status: item.fileStatus,
+    }));
+    sdkLog("info", "voiceFile", "getListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result.length },
+    });
+    return result;
+}
+export function getCurrentVoiceFileForRuntime(runtime) {
+    return parseVoiceFileStatus(runtime.cache.dpState[dpCodes.voiceData]);
+}
+export function onVoiceFileProgressForRuntime(runtime, callback) {
+    progressListenerCount += 1;
+    ensureProgressBridge();
+    emitter.on(getVoiceFileProgressEvent(runtime), callback);
+}
+export function offVoiceFileProgressForRuntime(runtime, callback) {
+    progressListenerCount = Math.max(0, progressListenerCount - 1);
+    emitter.off(getVoiceFileProgressEvent(runtime), callback);
+    cleanupProgressBridge();
+}
+function isVoiceFileAlreadyExistsError(error) {
+    const data = error;
+    const values = [data?.code, data?.errorCode, data?.innerError?.errorCode];
+    return values.some((value) => String(value ?? "").includes(VOICE_FILE_ALREADY_EXISTS_CODE));
+}
+export async function sendVoiceFileForRuntime(runtime, file) {
+    const devId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "voiceFile", "sendStart", {
+        devId,
+        data: {
+            fileType: file.fileType,
+            version: file.version,
+            status: file.status,
+        },
+    });
+    if (!hasDpForRuntime(runtime, dpCodes.voiceData)) {
+        const error = getError(1014);
+        sdkLog("warn", "voiceFile", "sendUnsupported", {
+            devId,
+            error,
+        });
+        throw error;
+    }
+    const isOnline = getDeviceStatusForRuntime(runtime).type === "online";
+    if (!isOnline) {
+        const error = getError(1001);
+        sdkLog("warn", "voiceFile", "sendOffline", {
+            devId,
+            error,
+        });
+        throw error;
+    }
+    activeTransfers.set(devId, file);
+    ensureProgressBridge();
+    try {
+        sdkLog("info", "voiceFile", "downloadUrlStart", {
+            devId,
+            data: { fileType: file.fileType },
+        });
+        const res = await getVoiceFileDownloadUrlApi({
+            devId,
+            fileKey: file.fileKey,
+        });
+        const filePath = Base64.decode(res.url);
+        sdkLog("info", "voiceFile", "bleTransferStart", {
+            devId,
+            data: {
+                fileType: file.fileType,
+                versionNumber: voiceFileVersionToNumber(file.version),
+            },
+        });
+        const result = await postBLEFileTransfer({
+            deviceId: devId,
+            fileId: Number(file.fileType),
+            fileIdentifier: file.fileKey,
+            fileVersion: voiceFileVersionToNumber(file.version),
+            filePath,
+        });
+        sdkLog("info", "voiceFile", "sendSuccess", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: { fileType: file.fileType, result: result.result },
+        });
+        return true;
+    }
+    catch (error) {
+        if (isVoiceFileAlreadyExistsError(error)) {
+            sdkLog("info", "voiceFile", "sendAlreadyExists", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: { fileType: file.fileType },
+            });
+            return true;
+        }
+        sdkLog("error", "voiceFile", "sendFail", {
+            devId,
+            duration: Date.now() - startedAt,
+            data: { fileType: file.fileType },
+            error,
+        });
+        throw error;
+    }
+    finally {
+        activeTransfers.delete(devId);
+        cleanupProgressBridge();
+    }
+}

package/lib/fit.d.ts

@@ -0,0 +1,4 @@
+export * from "./entries/fit/index";
+export * from "./interface";
+export * from "./constant";
+export type { SDKLogConfig, SDKLogEntry, SDKLogLevel, SDKLogSink, } from "./utils/sdk-log";

package/lib/fit.js

@@ -0,0 +1,3 @@
+export * from "./entries/fit/index";
+export * from "./interface";
+export * from "./constant";

package/lib/index.d.ts

@@ -1,23 +1,4 @@
-import { hasCapability, hasDp, updateConfig } from "./config";
-import { LockSDKOption } from "./interface";
-import { getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate } from "./state";
-import { syncUnlockMethod } from "./sync/unlock-method";
-import syncDeleteUsers from "./sync/user";
-import { publishDps } from "./utils/publishDps";
-import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache } from "./offline-dps";
-export * from "./user";
-export * from "./unlock-method";
-export * from "./temporary";
-export * from "./open";
-export * from "./log";
-export * from "./signal";
-export * from "./sleep";
+export * from "./entries/main/index";
 export * from "./interface";
 export * from "./constant";
-export * from "./other";
-export * from "./media";
-export * from "./linkage";
-export * from "./capability";
-export declare const init: (options?: LockSDKOption) => Promise<void>;
-export declare const destroy: () => void;
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export type { SDKLogConfig, SDKLogEntry, SDKLogLevel, SDKLogSink, } from "./utils/sdk-log";

package/lib/index.js

@@ -1,76 +1,3 @@
-import config, { hasCapability, hasDp, updateConfig } from "./config";
-import dpCodes from "./config/dp-code";
-import { addEvents, clearState, initState, removeEvents, getCurrentUser, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, getCurrentUserSync, getMediaRotate, } from "./state";
-import { getCapabilities } from "./utils";
-import { getDeviceInfo, getLaunchOptionsSync, trackEvent, } from "./utils/device";
-import { syncUnlockMethod } from "./sync/unlock-method";
-import syncDeleteUsers from "./sync/user";
-import { publishDps } from "./utils/publishDps";
-import { publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, } from "./offline-dps";
-export * from "./user";
-export * from "./unlock-method";
-export * from "./temporary";
-export * from "./open";
-export * from "./log";
-export * from "./signal";
-export * from "./sleep";
+export * from "./entries/main/index";
 export * from "./interface";
 export * from "./constant";
-export * from "./other";
-export * from "./media";
-export * from "./linkage";
-export * from "./capability";
-export const init = async (options) => {
-    let { devInfo, deviceId } = options || {};
-    if (!devInfo && !deviceId) {
-        const { query } = getLaunchOptionsSync();
-        deviceId = query.deviceId;
-        if (!deviceId) {
-            throw new Error("deviceId is required in lock sdk");
-        }
-    }
-    if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
-        devInfo = await getDeviceInfo(deviceId);
-    }
-    let dpSchema = {};
-    const codesById = {};
-    const idsByCode = {};
-    if (devInfo.schema) {
-        dpSchema = devInfo.schema.reduce((acc, cur) => {
-            acc[cur.code] = cur;
-            codesById[cur.id] = cur.code;
-            idsByCode[cur.code] = cur.id;
-            return acc;
-        }, {});
-    }
-    else if (devInfo.dpSchema) {
-        dpSchema = devInfo.dpSchema;
-        Object.keys(dpSchema).forEach((key) => {
-            const item = dpSchema[key];
-            codesById[item.id] = item.code;
-            idsByCode[item.code] = item.id;
-        });
-    }
-    config.strictMode = options?.strictMode ?? true;
-    config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
-    config.passwordSupportZero = options?.passwordSupportZero ?? true;
-    config.supportMultipleFace = options?.supportMultipleFace ?? false;
-    config.supportOfflineDps = options?.supportOfflineDps ?? false;
-    config.devInfo = devInfo;
-    config.dpSchema = dpSchema;
-    config.codesById = codesById;
-    config.idsByCode = idsByCode;
-    config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
-    config.preFetch = options?.preFetch ?? false;
-    config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    addEvents();
-    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
-        pid: devInfo.productId,
-    });
-    await initState();
-};
-export const destroy = () => {
-    clearState();
-    removeEvents();
-};
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/interface.d.ts

@@ -1,4 +1,5 @@
 import { CommunicationType, LocalOperateCategory, LocalOperateUserType, ModuleType, RotateType, UserType, VedioStreamType, VedioType, VoiceType } from "./constant";
+import type { SDKLogLevel, SDKLogSink } from "./utils/sdk-log";
 export type ParamType<T> = T extends (param: infer K) => any ? K : never;
 export type DpValue = string | boolean | number;
 export type DpData = Record<string, DpValue>;
@@ -11,6 +12,9 @@ export interface LockSDKOption {
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
     preFetch?: boolean;
+    logLevel?: SDKLogLevel;
+    logger?: SDKLogSink;
+    logToConsole?: boolean;
 }
 export interface ErrorData {
     errorCode: number;
@@ -44,6 +48,7 @@ export interface DeviceInfo {
     dpsTime: Record<string, string>;
     parentId?: string;
     isMatter?: boolean;
+    yuNetState?: number;
 }
 export interface DpSchema {
     type: "raw" | "obj";
@@ -81,6 +86,9 @@ export interface CurrentUser {
     admin: boolean;
     offlineUnlock: boolean;
     permanent: boolean;
+    expireTime?: number;
+    effectiveTime?: number;
+    expireDay?: number;
 }
 export interface UnlockMethodBaseInfo {
     unlockId: number;
@@ -126,6 +134,7 @@ export interface UserInfo {
     userContact: string;
     userType: UserType;
     isAccountUser: boolean;
+    isFamilyUser: boolean;
 }
 type MapItem = {
     readonly name: string;
@@ -171,7 +180,6 @@ export interface EffectiveConfig {
     effectiveTime?: number;
     expiredTime?: number;
 }
-export type RemotePermission = "everyOne" | "adminsOnly" | "noOne";
 export interface UnBindUnlockMethod {
     dpId: number;
     dpCode: string;
@@ -189,7 +197,7 @@ export interface DeviceStatus {
     type: "offline" | "online" | "sleep";
     connectEnable: boolean;
     onlineType: "local" | "cloud" | "ble" | "none" | "unknown";
-    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "unknown">;
+    onlineTypes: Array<"local" | "cloud" | "ble" | "localMatter" | "yuChannel" | "unknown">;
     sleepPeriod?: {
         start: number;
         end: number;
@@ -247,13 +255,15 @@ export interface MediaInfo {
     mediaBucket: string;
     mediaKey: string;
 }
-export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation" | "dev_bind";
+export type LogType = "alarm_record" | "close_record" | "unlock_record" | "operation" | "local_operation";
 export type CloseValue = "UNDEFINED" | "VOICE_REMOTE" | "APP_REMOTE" | "AUTO" | "LOCAL_MANUAL" | "FITTINGS" | "APP" | "GEO_FENCE";
+export type OperationType = "dev_bind" | "member_schedule_update" | "unlock_add" | "unlock_del" | "temp_pwd_create" | "temp_pwd_del" | "temp_pwd_meta_update" | "temp_pwd_name_update" | "offline_pwd_achieve" | "offline_pwd_clear_achieve" | "offline_pwd_clear_single_achieve" | "offline_pwd_name_update" | "arming_switch" | "unlock_switch" | "automatic_lock" | "auto_lock_time" | "verify_lock_switch" | "do_not_disturb" | "special_control" | "special_function" | "beep_volume" | "remote_unlock_setting" | "remote_voice_pwd_setting";
 export interface LogData {
     logId: string;
     time: number;
     currentUser: boolean;
     type: LogType;
+    operationType?: OperationType;
     userId: string;
     dpId: number;
     dpCode: string;
@@ -272,6 +282,28 @@ export interface LogData {
         source: number;
         type: number;
     };
+    tempPwdInfo?: {
+        name: string;
+        originName?: string;
+        effectiveConfig?: EffectiveConfig;
+    };
+    clearInfo?: {
+        name: string;
+        originName?: string;
+        effectiveConfig?: EffectiveConfig;
+        targetName?: string;
+    };
+    unlockInfo?: {
+        userName: string;
+        userId: string;
+        unlockName: string;
+        type: UnlockMethodType;
+    };
+    userEffectiveInfo?: {
+        userName: string;
+        permanent: boolean;
+        effectiveConfig?: EffectiveConfig;
+    };
 }
 export type TemporaryPasswordType = "custom" | "once" | "limit" | "clear" | "clearOne";
 export interface TempPasswordResult {
@@ -326,6 +358,10 @@ export interface DeviceAdvancedAbility {
         support: boolean;
         config: Record<string, any>;
     };
+    yuChannel: {
+        support: boolean;
+        value: 1 | 2;
+    };
 }
 export interface OfflineDpInfo {
     value: DpValue;
@@ -339,4 +375,15 @@ export interface UnlockGuide {
     picUrl: string;
     expireTime: number;
 }
+export interface SharedUserInfo {
+    id: string;
+    name: string;
+    effectiveType: "once" | "permanent" | "limit";
+    effectiveConfig: EffectiveConfig;
+    account: string;
+    countryCode: string;
+    offlineUnlock: boolean;
+    lockUserId: number;
+    userExist: boolean;
+}
 export {};