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

package/lib/feature/fit/users.js

@@ -0,0 +1,25 @@
+import { getFitUserListApi } from "../../api/fit";
+import { sdkLog } from "../../utils/sdk-log";
+const pickFitUserItem = (raw) => ({
+    userId: raw.userId,
+    lockUserId: raw.lockUserId,
+    avatarUrl: raw.avatarUrl,
+    nickName: raw.nickName,
+    userType: raw.userType,
+    userContact: raw.userContact,
+    phase: raw.phase,
+});
+export async function getFitUsersForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getUsersStart", {
+        devId: runtime.devId,
+    });
+    const list = await getFitUserListApi(runtime.devId);
+    const result = Array.isArray(list) ? list.map(pickFitUserItem) : [];
+    sdkLog("info", "fit", "getUsersSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result.length },
+    });
+    return result;
+}

package/lib/feature/linkage/linkage.d.ts

@@ -0,0 +1,10 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface RemainingInfo {
+    message: number;
+    phone: number;
+}
+export declare const getRemainingInfo: () => Promise<RemainingInfo>;
+export declare function getDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<import("../../api/linkage").LinkageRule | undefined>;
+export declare function enableDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;
+export declare function disableDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;
+export declare function toSetDoorbellServiceForRuntime(rt: LockDeviceRuntime): Promise<void>;

package/lib/{linkage.js → feature/linkage/linkage.js}

@@ -1,8 +1,7 @@
-import { disableLinkage, enableLinkage, getLinkageList, getRemainingMessage, getRemainingPhone, saveLinkage, } from "./api/linkage";
-import config from "./config";
-import { getHomeInfo } from "./utils";
-import { createAction, editAction } from "./utils/device";
-import { getError } from "./utils/errors";
+import { disableLinkage, enableLinkage, getLinkageList, getRemainingMessage, getRemainingPhone, saveLinkage, } from "../../api/linkage";
+import { getHomeInfo } from "../../utils";
+import { createAction, editAction } from "../../platform/device";
+import { getError } from "../../utils/errors";
 const DOORBELL_RING_TYPE = "doorbell_ring";
 const TARGET_KEY = "appPushTrigger";
 const ACTION_TYPE = "kafkaSend";
@@ -19,22 +18,16 @@ export const getRemainingInfo = async () => {
         phone,
     };
 };
-export const getDoorbellService = async () => {
+export async function getDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const list = await getLinkageList(config.devInfo.devId, homeInfo.homeId);
+    const list = await getLinkageList(rt.config.devInfo.devId, homeInfo.homeId);
     return list.find((item) => item.code === DOORBELL_RING_TYPE && item.ruleId);
-};
-const createDoorbellService = async () => {
-    const actions = await createAction({
-        createType: "remind",
-        smartType: "auto",
-    });
-    await saveDoorbellService(actions);
-};
-const saveDoorbellService = async (actions) => {
+}
+const saveDoorbellServiceForRuntime = async (rt, actions) => {
     const homeInfo = await getHomeInfo();
+    const devId = rt.config.devInfo.devId;
     saveLinkage({
-        devId: config.devInfo.devId,
+        devId,
         ownerId: homeInfo.homeId,
         name: "doorbell",
         enabled: true,
@@ -55,7 +48,7 @@ const saveDoorbellService = async (actions) => {
                 conditions: [
                     {
                         entityType: 23,
-                        entityId: config.devInfo.devId,
+                        entityId: devId,
                         entitySubIds: "",
                         iconUrl: "",
                         expr: [],
@@ -99,27 +92,34 @@ const saveDoorbellService = async (actions) => {
         ],
     }, homeInfo.homeId);
 };
-export const enableDoorbellService = async () => {
+const createDoorbellServiceForRuntime = async (rt) => {
+    const actions = await createAction({
+        createType: "remind",
+        smartType: "auto",
+    });
+    await saveDoorbellServiceForRuntime(rt, actions);
+};
+export async function enableDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const service = await getDoorbellService();
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId) {
         await enableLinkage(service.ruleId, homeInfo.homeId);
     }
     else {
-        await createDoorbellService();
+        await createDoorbellServiceForRuntime(rt);
     }
-};
-export const disableDoorbellService = async () => {
+}
+export async function disableDoorbellServiceForRuntime(rt) {
     const homeInfo = await getHomeInfo();
-    const service = await getDoorbellService();
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId) {
         await disableLinkage(service.ruleId, homeInfo.homeId);
         return;
     }
     throw getError(1059);
-};
-export const toSetDoorbellService = async () => {
-    const service = await getDoorbellService();
+}
+export async function toSetDoorbellServiceForRuntime(rt) {
+    const service = await getDoorbellServiceForRuntime(rt);
     if (service && service.ruleId && service.ruleVO) {
         const findIndex = service.ruleVO.actions.findIndex((item) => item.actionExecutor === TARGET_KEY ||
             item.actionExecutor === ACTION_TYPE);
@@ -135,9 +135,9 @@ export const toSetDoorbellService = async () => {
                 return item;
             }),
         });
-        await saveDoorbellService(actions);
+        await saveDoorbellServiceForRuntime(rt, actions);
     }
     else {
-        await createDoorbellService();
+        await createDoorbellServiceForRuntime(rt);
     }
-};
+}

package/lib/feature/log/log.d.ts

@@ -0,0 +1,63 @@
+import { LockLogCategory } from "../../api/log";
+import { AlbumMessage, LogData, UnlockMethodType } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export type LogsRefreshListener = () => void;
+export declare function getLogsRefreshEvent(runtime: LockDeviceRuntime): string;
+export declare const unlockDp2Type: Record<string, UnlockMethodType>;
+export interface GetLatestLogsResult {
+    data: LogData[];
+    unreadCount: number;
+}
+export declare function getLatestLogsForRuntime(rt: LockDeviceRuntime): Promise<GetLatestLogsResult>;
+export declare const onLogsRefreshForRuntime: (rt: LockDeviceRuntime, cb: LogsRefreshListener) => void;
+export declare const offLogsRefreshForRuntime: (rt: LockDeviceRuntime, cb: LogsRefreshListener) => void;
+export interface GetLogsParams {
+    page?: number;
+    pageSize?: number;
+}
+export declare const openDps: ("unlock_matter_kw" | "unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "open_inside" | "lock_local_record" | "unlock_inside" | "door_opened" | "unlock_app")[];
+export interface GetLogsResult {
+    list: LogData[];
+    hasMore: boolean;
+    total: number;
+}
+export declare function getLogsForRuntime(rt: LockDeviceRuntime, params?: GetLogsParams): Promise<GetLogsResult>;
+export interface GetAlarmsParams {
+    page?: number;
+    pageSize?: number;
+}
+export interface GetAlarmsResult {
+    list: LogData[];
+    hasMore: boolean;
+    total: number;
+}
+export declare function getAlarmsForRuntime(rt: LockDeviceRuntime, params?: GetAlarmsParams): Promise<GetAlarmsResult>;
+export interface GetAlbumsParams {
+    page?: number;
+    pageSize?: number;
+    startTime?: number;
+    endTime?: number;
+}
+export interface GetAlbumsResult {
+    hasMore: boolean;
+    list: AlbumMessage[];
+    allAitypes: number[];
+    types: number[];
+    langMap: string[];
+}
+export declare function getAlbumsForRuntime(rt: LockDeviceRuntime, params?: GetAlbumsParams): Promise<GetAlbumsResult>;
+export interface GetLockLogListParams {
+    logCategories?: LockLogCategory[];
+    userIds?: string;
+    onlyShowMediaRecord?: boolean;
+    startTime?: number;
+    endTime?: number;
+    lastRowKey?: string;
+    limit: number;
+}
+export interface GetLockLogListResult {
+    list: LogData[];
+    hasNext: boolean;
+    lastRowKey: string;
+}
+export declare const getLockLogListForRuntime: (rt: LockDeviceRuntime, params: GetLockLogListParams) => Promise<GetLockLogListResult>;

package/lib/feature/log/log.js

@@ -0,0 +1,438 @@
+import { getAlarmList, getAlbumMessages, getLatest2Log, getLockLogList, getRecordList, } from "../../api/log";
+import dpCodes from "../../config/dp-code";
+import { getCurrentUserForRuntime } from "../user/current-user";
+import base64ToHex from "../../utils/base64-to-hex";
+import { LOGCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { handleLocalOperation } from "../../utils/log";
+import { parseWeek } from "../../utils";
+export function getLogsRefreshEvent(runtime) {
+    return `${LOGCHANGE}_${runtime.devId}`;
+}
+export const unlockDp2Type = {
+    [dpCodes.unlockFingerprint]: "finger",
+    [dpCodes.unlockPassword]: "password",
+    [dpCodes.unlockCard]: "card",
+    [dpCodes.unlockFace]: "face",
+    [dpCodes.unlockFingerVein]: "fingerVein",
+    [dpCodes.unlockHand]: "hand",
+    [dpCodes.unlockEye]: "eye",
+};
+function handleLockLogs(list, cfg) {
+    return list.map((item) => {
+        let type = item.logCategory;
+        let operateType = undefined;
+        let dpCode = cfg.codesById[item.dpId];
+        const dpSchema = cfg.dpSchema[dpCode];
+        let itemData = item.data || "";
+        if (dpSchema?.type === "raw") {
+            itemData = base64ToHex(item.data);
+        }
+        if (typeof itemData === "string" && itemData.includes("[")) {
+            try {
+                itemData = JSON.parse(itemData);
+            }
+            catch {
+            }
+        }
+        let userName = item.userName;
+        let unlockName = item.unlockName;
+        let tempPwdInfo = undefined;
+        let clearInfo = undefined;
+        let userEffectiveInfo = undefined;
+        let unlockInfo = undefined;
+        if (type === "operation") {
+            operateType = item.logType;
+            switch (operateType) {
+                case "temp_pwd_create":
+                case "temp_pwd_meta_update": {
+                    const [name, effectiveDate, expiredDate, [allDay, effectiveTime = 0, expiredTime = 0, workingDay = 0],] = itemData;
+                    tempPwdInfo = {
+                        name: name,
+                        effectiveConfig: {
+                            effectiveDate: effectiveDate,
+                            expiredDate: expiredDate,
+                            repeat: allDay ? "none" : "week",
+                            weeks: parseWeek(workingDay),
+                            effectiveTime: effectiveTime,
+                            expiredTime: expiredTime,
+                        },
+                    };
+                    break;
+                }
+                case "offline_pwd_name_update":
+                case "temp_pwd_name_update": {
+                    tempPwdInfo = {
+                        originName: itemData[0],
+                        name: itemData[1],
+                    };
+                    break;
+                }
+                case "temp_pwd_del": {
+                    tempPwdInfo = {
+                        name: itemData[0],
+                    };
+                    break;
+                }
+                case "offline_pwd_clear_achieve": {
+                    const [name, effectiveDate, expiredDate] = itemData;
+                    clearInfo = {
+                        name: name,
+                        effectiveConfig: {
+                            effectiveDate: effectiveDate,
+                            expiredDate: expiredDate,
+                        },
+                    };
+                    break;
+                }
+                case "offline_pwd_clear_single_achieve": {
+                    const [name, effectiveDate, expiredDate, targetName] = itemData;
+                    clearInfo = {
+                        name: name,
+                        effectiveConfig: {
+                            effectiveDate: effectiveDate,
+                            expiredDate: expiredDate,
+                        },
+                        targetName: targetName,
+                    };
+                    break;
+                }
+                case "unlock_del":
+                case "unlock_add": {
+                    const [userId, userName, unlockName, type] = itemData;
+                    unlockInfo = {
+                        userId: userId,
+                        userName: userName,
+                        unlockName,
+                        type: unlockDp2Type[type],
+                    };
+                    break;
+                }
+                case "member_schedule_update": {
+                    const [name, permanent, effectiveDate, expiredDate, [allDay, effectiveTime = 0, expiredTime = 0, workingDay = 0] = [],] = itemData;
+                    userEffectiveInfo = {
+                        userName: name,
+                        permanent: permanent,
+                        effectiveConfig: permanent
+                            ? undefined
+                            : {
+                                effectiveDate: effectiveDate,
+                                expiredDate: expiredDate,
+                                repeat: allDay ? "none" : "week",
+                                weeks: parseWeek(workingDay),
+                                effectiveTime: effectiveTime,
+                                expiredTime: expiredTime,
+                            },
+                    };
+                    break;
+                }
+                case "remote_voice_pwd_setting":
+                case "remote_unlock_setting":
+                default: {
+                    if (cfg.dpSchema[operateType]) {
+                        item.dpId = cfg.dpSchema[operateType].id;
+                        dpCode = operateType;
+                    }
+                    itemData = itemData[0];
+                    break;
+                }
+            }
+        }
+        if (dpIdsForUsernameToUnlockName.includes(item.dpId)) {
+            unlockName = item.userName;
+            userName = "";
+        }
+        const log = {
+            type,
+            operationType: operateType,
+            logId: item.logId,
+            dpId: item.dpId,
+            dpCode,
+            data: itemData,
+            userId: item.userId,
+            userName: userName || "",
+            unlockName: unlockName || "",
+            mediaInfo: item.mediaInfoList,
+            localRecord: handleLocalOperation(item.localOperateRecordInfo, itemData),
+            unionUnlockInfo: item.unionUnlockInfo?.map((item1) => {
+                return {
+                    userId: item1.userId,
+                    userName: item1.userName,
+                    unlockName: item1.unlockName,
+                    sn: item1.sn,
+                    type: unlockDp2Type[item1.opMode],
+                };
+            }),
+            closeValue: item.unlockNameRosettaKey?.replace("HISTORY_LOCK_", ""),
+            time: item.time,
+            currentUser: !!item.currentUser,
+            bindable: item.memberBindableFlag,
+            unlockInfo,
+            userEffectiveInfo,
+            tempPwdInfo,
+            clearInfo,
+        };
+        if (item.matterRecordInfo) {
+            log.matterRecord = {
+                sn: item.matterRecordInfo.matterSn,
+                type: item.matterRecordInfo.matterType,
+                source: item.matterRecordInfo.matterSource,
+            };
+        }
+        return log;
+    });
+}
+export async function getLatestLogsForRuntime(rt) {
+    const cfg = rt.config;
+    const data = await getLatest2Log(cfg.devInfo.devId);
+    if (data.operateRecordVOList && data.operateRecordVOList.length) {
+        return {
+            data: handleLockLogs(data?.operateRecordVOList ?? [], cfg),
+            unreadCount: data?.unReadCount ?? 0,
+        };
+    }
+    return {
+        data: [],
+        unreadCount: 0,
+    };
+}
+export const onLogsRefreshForRuntime = (rt, cb) => {
+    emitter.on(getLogsRefreshEvent(rt), cb);
+};
+export const offLogsRefreshForRuntime = (rt, cb) => {
+    emitter.off(getLogsRefreshEvent(rt), cb);
+};
+export const openDps = [
+    dpCodes.openInside,
+    dpCodes.lockLocalRecord,
+    dpCodes.unlockPassword,
+    dpCodes.lockRecord,
+    dpCodes.unlockFingerprint,
+    dpCodes.unlockCard,
+    dpCodes.unlockFace,
+    dpCodes.unlockHand,
+    dpCodes.unlockFingerVein,
+    dpCodes.unlockEye,
+    dpCodes.unlockTemporary,
+    dpCodes.unlockDoubleKit,
+    dpCodes.unlockKey,
+    dpCodes.unlockPhoneRemote,
+    dpCodes.unlockVoiceRemote,
+    dpCodes.unlockDoubleKitW,
+    dpCodes.unlockBle,
+    dpCodes.unlockOfflinePd,
+    dpCodes.unlockDynamic,
+    dpCodes.unlockInside,
+    dpCodes.doorOpened,
+    dpCodes.unlockApp,
+    dpCodes.unlockMatterKw,
+];
+const closeTypes = [
+    "UNDEFINED",
+    "APP_REMOTE",
+    "VOICE_REMOTE",
+    "GEO_FENCE",
+    "APP",
+    "FITTINGS",
+    "AUTO",
+    "LOCAL_MANUAL",
+];
+const dpIdsForUsernameToUnlockName = [89, 69, 55, 67, 3, 32];
+export async function getLogsForRuntime(rt, params) {
+    const cfg = rt.config;
+    const { page = 1, pageSize = 50 } = params || {};
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const data = await getRecordList({
+        devId: cfg.devInfo.devId,
+        dpIds: openDps.reduce((res, item) => {
+            if (cfg.idsByCode[item]) {
+                res.push(cfg.idsByCode[item]);
+            }
+            return res;
+        }, []),
+        offset: (page - 1) * pageSize,
+        limit: pageSize,
+    });
+    if (data.datas.length) {
+        const result = data.datas.map((record) => {
+            let closeValue = undefined;
+            let dpValue = record.dpValue;
+            const dpCode = cfg.codesById[record.dpId];
+            let type = dpCode === dpCodes.lockRecord ? "close_record" : "unlock_record";
+            const dpSchema = cfg.dpSchema[dpCode];
+            if (dpSchema.type === "raw") {
+                dpValue = base64ToHex(dpValue);
+            }
+            if (type === "close_record") {
+                const closeType = parseInt(dpValue.slice(0, 2), 16);
+                closeValue = closeTypes[closeType] || closeTypes[0];
+            }
+            if (dpCode === dpCodes.lockLocalRecord) {
+                type = "local_operation";
+            }
+            let userName = record.userName;
+            let unlockName = record.unlockName;
+            if (dpIdsForUsernameToUnlockName.includes(record.dpId)) {
+                unlockName = record.userName;
+                userName = "";
+            }
+            const log = {
+                type,
+                logId: record.historyId.toString(),
+                userId: record.userId,
+                dpId: record.dpId,
+                data: dpValue,
+                dpCode,
+                userName,
+                unlockName,
+                mediaInfo: record.mediaInfoList,
+                unionUnlockInfo: record.unionUnlockInfo?.map((item) => ({
+                    userId: item.userId,
+                    userName: item.userName,
+                    unlockName: item.unlockName,
+                    sn: item.sn,
+                    type: unlockDp2Type[item.opMode],
+                })),
+                closeValue,
+                time: record.gmtCreate,
+                currentUser: +record.userId === +currentUser.userId,
+                bindable: record.memberBindableFlag === 1,
+                unlockMethod: type === "unlock_record" ? unlockDp2Type[dpCode] : undefined,
+                localRecord: handleLocalOperation(record.localOperateRecordInfo, dpValue),
+            };
+            if (record.matterRecordInfo) {
+                log.matterRecord = {
+                    sn: record.matterRecordInfo.matterSn,
+                    type: record.matterRecordInfo.matterType,
+                    source: record.matterRecordInfo.matterSource,
+                };
+            }
+            return log;
+        });
+        return {
+            list: result,
+            hasMore: data.hasNext,
+            total: data.totalCount,
+        };
+    }
+    return {
+        list: [],
+        hasMore: false,
+        total: 0,
+    };
+}
+const alarmDps = [
+    dpCodes.doorbell,
+    dpCodes.familyCall,
+    dpCodes.alarmReminder,
+    dpCodes.alarmLock,
+    dpCodes.unlockOfflineClear,
+    dpCodes.unlockOfflineClearSingle,
+    dpCodes.hijack,
+];
+export async function getAlarmsForRuntime(rt, params) {
+    const cfg = rt.config;
+    const { page = 1, pageSize = 50 } = params || {};
+    const currentUser = await getCurrentUserForRuntime(rt);
+    const data = await getAlarmList({
+        devId: cfg.devInfo.devId,
+        dpIds: alarmDps.reduce((res, item) => {
+            if (cfg.idsByCode[item]) {
+                res.push(cfg.idsByCode[item]);
+            }
+            return res;
+        }, []),
+        offset: (page - 1) * pageSize,
+        limit: pageSize,
+    });
+    if (data.datas.length) {
+        const result = data.datas.map((record) => {
+            let dpId = record.dpId;
+            let dpValue = record.dpValue;
+            let dpCode = cfg.codesById[dpId];
+            const dpSchema = cfg.dpSchema[dpCode];
+            if (dpSchema.type === "raw") {
+                dpValue = base64ToHex(dpValue);
+            }
+            const isHijack = record.dps?.some((item) => Object.keys(item)[0] === "98");
+            return {
+                type: "alarm_record",
+                logId: record.historyId.toString(),
+                userId: record.userId,
+                dpId: record.dpId,
+                data: dpValue,
+                dpCode,
+                userName: record.userName,
+                unlockName: record.unlockName,
+                mediaInfo: record.mediaInfoList,
+                time: record.gmtCreate,
+                currentUser: +record.userId === +currentUser.userId,
+                bindable: false,
+                isHijack,
+            };
+        });
+        return {
+            list: result,
+            hasMore: data.hasNext,
+            total: data.totalCount,
+        };
+    }
+    return {
+        list: [],
+        hasMore: false,
+        total: 0,
+    };
+}
+export async function getAlbumsForRuntime(rt, params) {
+    const cfg = rt.config;
+    const now = Date.now();
+    const beforeYear = now - 365 * 24 * 60 * 60 * 1000;
+    const { page = 1, pageSize = 20, startTime = beforeYear, endTime = now, } = params || {};
+    const data = await getAlbumMessages({
+        devId: cfg.devInfo.devId,
+        limit: pageSize,
+        offset: (page - 1) * pageSize,
+        safeMode: false,
+        picInclude: true,
+        startTime,
+        endTime,
+    });
+    return {
+        hasMore: data.hasNext,
+        list: data.albumList.map((item) => ({
+            id: item.fileId,
+            mediaPath: item.mediaPath,
+            fileKey: item.fileKey,
+            fileUrl: item.fileUrl,
+            mediaBucket: item.mediaBucket,
+            mediaKey: item.mediaKey,
+            aiTypes: item.aiTypes,
+            describe: item.describe,
+            aiInfos: item.aiDetectResults.map((x) => ({
+                id: x.bizId,
+                type: x.aiType,
+                name: x.eventTypeDesc,
+                desc: x.desc,
+                happenTime: x.happenTime,
+                isCorrected: x.missStep,
+            })),
+            type: item.eventType,
+            createTime: item.uploadMilTime,
+        })),
+        allAitypes: data.allAitypes,
+        types: data.eventTypes,
+        langMap: data.eventLangMap,
+    };
+}
+export const getLockLogListForRuntime = async (rt, params) => {
+    const cfg = rt.config;
+    const data = await getLockLogList({
+        devId: cfg.devInfo.devId,
+        ...params,
+    });
+    return {
+        list: handleLockLogs(data?.records ?? [], cfg),
+        hasNext: !!data?.hasMore,
+        lastRowKey: data?.lastRowKey ?? "",
+    };
+};

package/lib/feature/media/media.d.ts

@@ -0,0 +1,31 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface GetMediaUrlParams {
+    mediaPath: string;
+    mediaBucket: string;
+}
+export interface GetFileUrlParams {
+    filePath: string;
+    bucket: string;
+}
+export interface MediaUrlResult {
+    mediaUrl: string;
+}
+export declare const getMediaUrlForRuntime: (runtime: LockDeviceRuntime, params: GetMediaUrlParams) => Promise<MediaUrlResult>;
+export declare const isSupportMediaForRuntime: (runtime: LockDeviceRuntime) => boolean;
+export interface OpenLocalAlbumParams {
+    theme?: string;
+    isLandscape?: boolean;
+    title?: string;
+    serviceCode?: string;
+}
+export declare const openLocalAlbumForRuntime: (runtime: LockDeviceRuntime, params?: OpenLocalAlbumParams) => Promise<void>;
+export interface MediaInfo {
+    imageAngle: number;
+    videoAngle: number;
+    mediaWidth: number;
+    mediaHeight: number;
+    isSEI: boolean;
+    supportTalk: boolean;
+    isTwoWayTalk: boolean;
+}
+export declare const getMediaInfoForRuntime: (runtime: LockDeviceRuntime) => MediaInfo;