@ray-js/lock-sdk 1.1.1-beta.2 → 1.1.1-beta.21

package/lib/api/index.d.ts

@@ -27,4 +27,12 @@ export declare const fetchOfflineDpData: (deviceId: string) => Promise<{
 }[]>;
 export declare const publishOfflineDpData: (deviceId: string, dpData: Record<string, DpValue>) => Promise<unknown>;
 export declare const clearOfflineDpData: (deviceId: string) => Promise<unknown>;
+export declare const getFileRemoteUrl: ({ biz, resources, }: {
+    biz: string;
+    resources: {
+        objectKey: string;
+    }[];
+}) => Promise<{
+    signedUrls: Record<string, string>;
+}>;
 export {};

package/lib/api/index.js

@@ -70,3 +70,13 @@ export const clearOfflineDpData = async (deviceId) => {
         version: "1.0",
     });
 };
+export const getFileRemoteUrl = ({ biz, resources, }) => {
+    return requestApi({
+        api: `${THING}.web.fastroute.download.sign`,
+        version: "2.0",
+        data: {
+            biz,
+            signedRequest: { resources },
+        },
+    });
+};

package/lib/api/lock.d.ts

@@ -124,4 +124,9 @@ interface BindUnlockMethodToUserByRecordParams {
     unlockIds: string[];
 }
 export declare const bindUnlockMethodToUserByRecord: (params: BindUnlockMethodToUserByRecordParams) => Promise<boolean>;
+interface ValidatePasswordComplexityParams {
+    devId: string;
+    password: string;
+}
+export declare const validatePasswordComplexity: (params: ValidatePasswordComplexityParams) => Promise<boolean>;
 export {};

package/lib/api/lock.js

@@ -116,3 +116,10 @@ export const bindUnlockMethodToUserByRecord = (params) => {
         data: params,
     });
 };
+export const validatePasswordComplexity = (params) => {
+    return requestApi({
+        api: "m.lock.password.simplicity.check",
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/api/user.d.ts

@@ -82,26 +82,12 @@ export declare const getUserList: (params: getUserListParams) => Promise<{
     user: UserListItem[];
     hasNext: boolean;
 }>;
-interface GetUserDetailParams {
+interface GetUserDetailQueryParams {
     devId: string;
     userId: string;
+    dpIds: string;
 }
-interface UserDetail {
-    allOpenType: number[];
-    avatarUrl: string;
-    lockUserId: number;
-    nickName: string;
-    phase: number;
-    productAttribute: number;
-    status: number;
-    supportOpenType: number[];
-    uid: string;
-    userContact: string;
-    userId: string;
-    userTimeSet: string;
-    userType: number;
-}
-export declare const getUserDetail: (params: GetUserDetailParams) => Promise<UserDetail>;
+export declare const getUserDetailQuery: (params: GetUserDetailQueryParams) => Promise<UserListItem>;
 export interface RemovedUserData {
     userId: string;
     lockUserId: number;

package/lib/api/user.js

@@ -38,17 +38,17 @@ export const getUserList = (params) => {
         data: params,
     });
 };
-export const getUserDetail = (params) => {
+export const getUserDetailQuery = (params) => {
     return requestApi({
-        api: `${THING}.m.device.member.detail`,
-        version: "4.0",
+        api: "m.lock.user.detail.query",
+        version: "1.0",
         data: params,
     });
 };
 export const getUsersSyncLockData = (deviceId) => {
     return requestApi({
         api: `${THING}.m.device.lock.sync.batch`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId: deviceId,
         },
@@ -57,7 +57,7 @@ export const getUsersSyncLockData = (deviceId) => {
 export const removeUser = (devId, userId) => {
     return requestApi({
         api: `${THING}.m.device.member.remove`,
-        version: "2.0",
+        version: "1.0",
         data: {
             devId,
             userId,

package/lib/capability.js

@@ -8,7 +8,7 @@ export const isActiveThread = async () => {
     const hasThread = hasCapability(ProductCommunicationType.THREAD);
     if (hasThread) {
         const deviceStatus = getDeviceStatus();
-        if (deviceStatus.onlineType === "cloud" ||
+        if (deviceStatus.onlineTypes.includes("cloud") ||
             config.communication.length === 1) {
             return true;
         }
@@ -45,6 +45,7 @@ export const getDeviceAdvancedAbilities = async () => {
             "tyabi4ucx5",
             "tyabis9tpe",
             "tyabiwxrn9",
+            "tyabipd4hh",
         ]),
         getDeviceAdvancedAbility(config.devInfo.devId),
     ]);
@@ -68,27 +69,52 @@ export const getDeviceAdvancedAbilities = async () => {
             support: false,
             config: {},
         },
+        unlockGuide: {
+            support: false,
+            config: {},
+        },
     };
     productAbilities.forEach((item) => {
-        const data = JSON.parse(item.extConfig);
-        if (item.abilityCode === "tyabi4ucx5" && item.isOpen) {
-            deviceAdvanceAbilityCache.ai.config = data;
-            const dataReport = data?.ai_data_report ?? false;
-            const itemRecognition = data?.ai_recognition?.[0]?.item_recognition ?? false;
-            const petRecognition = data?.ai_recognition?.[0]?.pet_recognition ?? false;
-            const voice = data?.ai_voice ?? false;
-            const message = data?.ai_message ?? false;
-            deviceAdvanceAbilityCache.ai.support =
-                dataReport || itemRecognition || petRecognition || voice || message;
-        }
-        else if (item.abilityCode === "tyabis9tpe" && item.isOpen) {
-            deviceAdvanceAbilityCache.wechat.support = true;
-            deviceAdvanceAbilityCache.wechat.config = data;
+        try {
+            if (item.isOpen) {
+                const data = JSON.parse(item.extConfig);
+                switch (item.abilityCode) {
+                    case "tyabi4ucx5": {
+                        deviceAdvanceAbilityCache.ai.config = data;
+                        const dataReport = data?.ai_data_report ?? false;
+                        const itemRecognition = data?.ai_recognition?.[0]?.item_recognition ?? false;
+                        const petRecognition = data?.ai_recognition?.[0]?.pet_recognition ?? false;
+                        const voice = data?.ai_voice ?? false;
+                        const message = data?.ai_message ?? false;
+                        deviceAdvanceAbilityCache.ai.support =
+                            dataReport ||
+                                itemRecognition ||
+                                petRecognition ||
+                                voice ||
+                                message;
+                        break;
+                    }
+                    case "tyabis9tpe": {
+                        deviceAdvanceAbilityCache.wechat.support = true;
+                        deviceAdvanceAbilityCache.wechat.config = data;
+                        break;
+                    }
+                    case "tyabiwxrn9": {
+                        deviceAdvanceAbilityCache.wechatVoip.support =
+                            !!data?.voipType?.includes("0");
+                        deviceAdvanceAbilityCache.wechatVoip.config = data;
+                        break;
+                    }
+                    case "tyabipd4hh": {
+                        deviceAdvanceAbilityCache.unlockGuide.support = true;
+                        deviceAdvanceAbilityCache.unlockGuide.config = data;
+                        break;
+                    }
+                }
+            }
         }
-        else if (item.abilityCode === "tyabiwxrn9" && item.isOpen) {
-            deviceAdvanceAbilityCache.wechatVoip.support =
-                !!data?.voipType?.includes("0");
-            deviceAdvanceAbilityCache.wechatVoip.config = data;
+        catch (error) {
+            console.warn(`setting [${item.abilityCode}] config error`, error);
         }
     });
     return deviceAdvanceAbilityCache;

package/lib/config/dp-map/common.js

@@ -52,7 +52,7 @@ export const validConfigDpMap = {
                     .slice(0, 7);
             },
             format: (value) => {
-                const weekHex = parseInt(value.reverse().join(""), 2)
+                const weekHex = parseInt([...value].reverse().join(""), 2)
                     .toString(16)
                     .padStart(2, "0");
                 return `000000${weekHex}`;

package/lib/config/dp-map/unlock-method-big.js

@@ -89,7 +89,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "category",
+        name: "operation",
     },
 ];
 const reportRemove = [

package/lib/config/dp-map/unlock-method.d.ts

@@ -161,7 +161,7 @@ declare const remove: readonly [{
 }, {
     readonly name: "unlockId";
 }, {
-    readonly name: "target";
+    readonly name: "operation";
 }];
 declare const reportRemove: ({
     readonly name: "type";
@@ -176,7 +176,7 @@ declare const reportRemove: ({
 } | {
     readonly name: "unlockId";
 } | {
-    readonly name: "target";
+    readonly name: "operation";
 } | {
     name: string;
 })[];
@@ -649,7 +649,7 @@ declare const _default: {
     }, {
         readonly name: "unlockId";
     }, {
-        readonly name: "target";
+        readonly name: "operation";
     }];
     reportRemove: ({
         readonly name: "type";
@@ -664,7 +664,7 @@ declare const _default: {
     } | {
         readonly name: "unlockId";
     } | {
-        readonly name: "target";
+        readonly name: "operation";
     } | {
         name: string;
     })[];

package/lib/config/dp-map/unlock-method.js

@@ -87,7 +87,7 @@ const reportAdd = [
 const remove = [
     ...common,
     {
-        name: "target",
+        name: "operation",
     },
 ];
 const reportRemove = [

package/lib/config/index.d.ts

@@ -18,9 +18,10 @@ declare const config: {
     videoAngle: number;
     supportMultipleFace: boolean;
     supportOfflineDps: boolean;
+    preFetch: boolean;
     deviceStatus: DeviceStatus;
 };
-type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId">;
+type UpdateConfigParams = Omit<LockSDKOption, "devInfo" | "deviceId" | "preFetch">;
 export declare const updateConfig: (options: UpdateConfigParams) => void;
 export declare const hasCapability: (capability: ProductCommunicationType) => boolean;
 export declare const hasDp: (dpCode: string) => boolean;

package/lib/config/index.js

@@ -16,6 +16,7 @@ const config = {
     videoAngle: 0,
     supportMultipleFace: false,
     supportOfflineDps: false,
+    preFetch: false,
     deviceStatus: {
         type: "offline",
         connectEnable: false,

package/lib/index.d.ts

@@ -2,6 +2,7 @@ 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";
@@ -19,4 +20,4 @@ export * from "./linkage";
 export * from "./capability";
 export declare const init: (options?: LockSDKOption) => Promise<void>;
 export declare const destroy: () => void;
-export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/index.js

@@ -2,8 +2,9 @@ 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 } from "./utils/device";
+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";
@@ -60,12 +61,16 @@ export const init = async (options) => {
     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, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };
+export { getCurrentUser, getMediaRotate, getCurrentUserSync, syncUnlockMethod, syncDeleteUsers, getDeviceStatus, onDeviceStatusChange, offDeviceStatusChange, updateConfig, hasCapability, hasDp, publishDps, publishOfflineDps, getOfflineDps, isOfflineDpSyncing, onOfflineDpsUpdate, offOfflineDpsUpdate, getOfflineDpCache, };

package/lib/interface.d.ts

@@ -10,6 +10,7 @@ export interface LockSDKOption {
     passwordSupportZero?: boolean;
     supportMultipleFace?: boolean;
     supportOfflineDps?: boolean;
+    preFetch?: boolean;
 }
 export interface ErrorData {
     errorCode: number;
@@ -81,7 +82,7 @@ export interface CurrentUser {
     permanent: boolean;
 }
 export interface UnlockMethodBaseInfo {
-    unlockId: string;
+    unlockId: number;
     unlockName: string;
     isBound: boolean;
     id: number;
@@ -143,11 +144,13 @@ export type DpMapDataType<T extends DpMapType> = {
 };
 export interface NotifyInfo {
     appSend?: boolean;
+    msgSend?: boolean;
     msgPhone?: string;
     countryCode?: string;
 }
 export interface UnlockMethodDetail {
     isBound: boolean;
+    type: UnlockMethodType;
     phase: number;
     dpId: number;
     isSpecial: boolean;
@@ -312,6 +315,10 @@ export interface DeviceAdvancedAbility {
         support: boolean;
         config: Record<string, any>;
     };
+    unlockGuide: {
+        support: boolean;
+        config: Record<string, any>;
+    };
 }
 export interface OfflineDpInfo {
     value: DpValue;
@@ -320,4 +327,9 @@ export interface OfflineDpInfo {
 export interface OfflineDps {
     [code: string]: OfflineDpInfo;
 }
+export interface UnlockGuide {
+    videoUrl: string;
+    picUrl: string;
+    expireTime: number;
+}
 export {};

package/lib/log.js

@@ -36,6 +36,12 @@ export const getLatestLogs = async () => {
                 catch {
                 }
             }
+            let userName = item.userName;
+            let unlockName = item.unlockName;
+            if (item.dpId === 89 || item.dpId === 69) {
+                unlockName = item.userName;
+                userName = "";
+            }
             return {
                 type,
                 logId: item.logId,
@@ -43,8 +49,8 @@ export const getLatestLogs = async () => {
                 dpCode,
                 data: itemData,
                 userId: item.userId,
-                userName: item.userName,
-                unlockName: item.unlockName,
+                userName,
+                unlockName,
                 mediaInfo: item.mediaInfoList,
                 unionUnlockInfo: item.unionUnlockInfo?.map((item1) => {
                     return {
@@ -142,6 +148,12 @@ export const getLogs = async (params) => {
             if (dpCode === dpCodes.lockLocalRecord) {
                 type = "local_operation";
             }
+            let userName = record.userName;
+            let unlockName = record.unlockName;
+            if (record.dpId === 89 || record.dpId === 69) {
+                unlockName = record.userName;
+                userName = "";
+            }
             return {
                 type,
                 logId: record.historyId.toString(),
@@ -149,8 +161,8 @@ export const getLogs = async (params) => {
                 dpId: record.dpId,
                 data: dpValue,
                 dpCode,
-                userName: record.userName,
-                unlockName: record.unlockName,
+                userName,
+                unlockName,
                 mediaInfo: record.mediaInfoList,
                 unionUnlockInfo: record.unionUnlockInfo?.map((item) => ({
                     userId: item.userId,

package/lib/offline-dps.js

@@ -29,14 +29,14 @@ export const checkOfflineDpUpdate = async (dps, isForce) => {
     if (!config.supportOfflineDps) {
         return;
     }
-    const hasOne = Object.keys(dps).some((code) => cache[code]?.pushStatus === false);
+    const hasOne = Object.keys(dps).some((code) => cache?.[code]?.pushStatus === false);
     if (hasOne || isForce) {
         const res = await getOfflineDps(true);
         emitter.emit(OFFLINE_DPS_UPDATE, res);
     }
 };
 export const getOfflineDpCache = (code) => {
-    return cache[code];
+    return cache?.[code];
 };
 export const publishOfflineDps = async (dps) => {
     const { devInfo, dpSchema } = config;
@@ -52,20 +52,12 @@ export const publishOfflineDps = async (dps) => {
         return acc;
     }, {});
     await publishOfflineDpData(devInfo.devId, dpData);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 export const clearOfflineDps = async () => {
     const { devInfo } = config;
     await clearOfflineDpData(devInfo.devId);
-    try {
-        await checkOfflineDpUpdate({}, true);
-    }
-    catch {
-    }
+    checkOfflineDpUpdate({}, true);
 };
 const OFFLINE_DPS_UPDATE = "offline_dps_update";
 export const onOfflineDpsUpdate = (callback) => {

package/lib/open/ble-dedicated-dp.d.ts

@@ -0,0 +1,4 @@
+export declare const isDedicatedBleHexSuccess: (raw: string) => boolean;
+export declare const resolveDedicatedBleCommandDp: () => string | null;
+export declare const executeDedicatedBleManualLock: (timeout: number) => Promise<void>;
+export declare const executeDedicatedBleRawAction: (isOpen: boolean, timeout: number) => Promise<void>;

package/lib/open/ble-dedicated-dp.js

@@ -0,0 +1,148 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { getDoorKey } from "../api/lock";
+import config, { hasDp } from "../config";
+import dpCodes from "../config/dp-code";
+import { open as openMap, reportOpen as reportOpenMap, } from "../config/dp-map/open";
+import syncRemoteSerectKey from "../sync/remote-serect-key";
+import { stringToBytes } from "../utils/byte";
+import { decrypt } from "../utils/device";
+import { getError } from "../utils/errors";
+import { publishDps } from "../utils/publishDps";
+import { getOpenDoorMemberId } from "./ble-remote-no-dp-key";
+import { mapRemoteOpenReportStatus } from "./report-status";
+const normalizeHex = (raw) => raw.replace(/\s/g, "").toLowerCase();
+export const isDedicatedBleHexSuccess = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    return n.startsWith("00") || n.endsWith("00");
+};
+const parseDedicatedBleHexStatus = (raw) => {
+    const n = normalizeHex(raw);
+    if (n.length < 2) {
+        return false;
+    }
+    if (isDedicatedBleHexSuccess(raw)) {
+        return { status: 0 };
+    }
+    if (n.includes("06")) {
+        return { status: 0x06 };
+    }
+    return { status: 0x01 };
+};
+const tryParseStandardUnlockReport = (raw, memberId) => {
+    try {
+        const result = dpUtils.parse(raw, reportOpenMap);
+        if (result.memberId !== memberId) {
+            return false;
+        }
+        if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+            return false;
+        }
+        return result;
+    }
+    catch {
+        return false;
+    }
+};
+export const resolveDedicatedBleCommandDp = () => {
+    if (hasDp(dpCodes.bleUnlockCheck)) {
+        return dpCodes.bleUnlockCheck;
+    }
+    if (hasDp(dpCodes.bluetoothUnlock)) {
+        return dpCodes.bluetoothUnlock;
+    }
+    if (hasDp(dpCodes.unlockBle)) {
+        return dpCodes.unlockBle;
+    }
+    return null;
+};
+const createDedicatedBleCheckReport = (commandDp, memberId) => {
+    return (dpData) => {
+        if (hasDp(dpCodes.lockMotorState)) {
+            if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                return { status: 0 };
+            }
+        }
+        if (typeof dpData[commandDp] !== "undefined") {
+            const raw = dpData[commandDp];
+            const standard = tryParseStandardUnlockReport(raw, memberId);
+            if (standard) {
+                return standard;
+            }
+            const hexStatus = parseDedicatedBleHexStatus(raw);
+            if (hexStatus !== false) {
+                return hexStatus;
+            }
+        }
+        if (typeof dpData[dpCodes.remoteNoDpKey] !== "undefined") {
+            const result = dpUtils.parse(dpData[dpCodes.remoteNoDpKey], reportOpenMap);
+            if (result.memberId === memberId) {
+                if (hasDp(dpCodes.lockMotorState) && result.status === 0) {
+                    return false;
+                }
+                return result;
+            }
+        }
+        return false;
+    };
+};
+export const executeDedicatedBleManualLock = async (timeout) => {
+    if (!hasDp(dpCodes.manualLock)) {
+        throw getError(1014);
+    }
+    await publishDps({
+        [dpCodes.manualLock]: true,
+    }, {
+        timeout,
+        checkReport: (dpData) => {
+            if (hasDp(dpCodes.lockMotorState)) {
+                if (typeof dpData[dpCodes.lockMotorState] !== "undefined") {
+                    return { status: 0 };
+                }
+            }
+            if (typeof dpData[dpCodes.manualLock] !== "undefined") {
+                return { status: 0 };
+            }
+            return false;
+        },
+    });
+};
+export const executeDedicatedBleRawAction = async (isOpen, timeout) => {
+    if (!isOpen && hasDp(dpCodes.manualLock)) {
+        await executeDedicatedBleManualLock(timeout);
+        return;
+    }
+    const commandDp = resolveDedicatedBleCommandDp();
+    if (!commandDp) {
+        throw getError(1014);
+    }
+    await syncRemoteSerectKey();
+    let pw = "";
+    try {
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    catch {
+        await syncRemoteSerectKey(true);
+        const { password } = await getDoorKey(config.devInfo.devId);
+        pw = await decrypt(config.devInfo.devId, password);
+    }
+    const memberId = await getOpenDoorMemberId();
+    const payload = dpUtils.format({
+        status: Number(isOpen),
+        memberId,
+        key: stringToBytes(pw),
+        type: 3,
+    }, openMap);
+    const response = (await publishDps({
+        [commandDp]: payload,
+    }, {
+        timeout,
+        checkReport: createDedicatedBleCheckReport(commandDp, memberId),
+    }));
+    if (response.status !== 0) {
+        throw mapRemoteOpenReportStatus(response.status);
+    }
+};

package/lib/open/ble-remote-no-dp-key.d.ts

@@ -0,0 +1,4 @@
+import { DpValue } from "../interface";
+export declare const createRemoteNoDpKeyBleCheckReport: (memberId: number) => (dpData: Record<string, DpValue>) => any;
+export declare const executeBleRemoteNoDpKeyAction: (isOpen: boolean, timeout: number, memberId: number) => Promise<void>;
+export declare const getOpenDoorMemberId: () => Promise<number>;