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

package/lib/entries/ble/build-instance.js

@@ -0,0 +1,50 @@
+import { clearPrimaryLockSDKInstanceIfDevId } from "./bootstrap/primary-instance";
+import { registerLockSDKInstanceRuntime } from "./bootstrap/lock-instance-runtime-ref";
+import { unregisterRuntime, getRegisteredRuntimeCount, } from "../../runtime/registry";
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { updateConfigForRuntime, } from "../../feature/misc/update-config";
+import * as DeviceExports from "./exports";
+const RESERVED_INSTANCE_METHOD_KEYS = new Set(["destroy", "updateConfig"]);
+let cachedFlatExportKeys = null;
+function collectFlatInstanceExportKeys() {
+    if (cachedFlatExportKeys !== null) {
+        return cachedFlatExportKeys;
+    }
+    const ex = DeviceExports;
+    cachedFlatExportKeys = Object.keys(ex)
+        .filter((k) => k !== "__esModule" && !RESERVED_INSTANCE_METHOD_KEYS.has(k))
+        .sort();
+    return cachedFlatExportKeys;
+}
+export function getFlatInstanceMethodKeysForTests() {
+    return collectFlatInstanceExportKeys();
+}
+export function buildLockSDKInstance(runtime) {
+    const instance = {
+        destroy() {
+            unregisterRuntime(runtime.devId);
+            clearPrimaryLockSDKInstanceIfDevId(runtime.devId);
+            clearStateForRuntime(runtime);
+            if (getRegisteredRuntimeCount() === 0) {
+                removeEvents();
+            }
+        },
+        updateConfig(options) {
+            updateConfigForRuntime(runtime, options);
+        },
+    };
+    registerLockSDKInstanceRuntime(instance, runtime);
+    const keys = collectFlatInstanceExportKeys();
+    const ex = DeviceExports;
+    for (const key of keys) {
+        const val = ex[key];
+        if (typeof val === "function") {
+            instance[key] = val.bind(instance);
+        }
+        else {
+            instance[key] = val;
+        }
+    }
+    return instance;
+}

package/lib/entries/ble/exports/capability.d.ts

@@ -0,0 +1,6 @@
+import type { ProductCommunicationType } from "../../../constant";
+export declare function hasCapability(capability: ProductCommunicationType): boolean;
+export declare function isBlePureDevice(): boolean;
+export declare function isShareThead(): boolean;
+export declare function isActiveThread(): Promise<boolean>;
+export declare function getDeviceAdvancedAbilities(): Promise<import("../../..").DeviceAdvancedAbility>;

package/lib/entries/ble/exports/capability.js

@@ -0,0 +1,17 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, isShareTheadForRuntime, isActiveThreadForRuntime, getDeviceAdvancedAbilitiesForRuntime, } from "../../../feature/misc/capability";
+export function hasCapability(capability) {
+    return hasCapabilityForRuntime(resolveRuntimeFromExportThis(this), capability);
+}
+export function isBlePureDevice() {
+    return isBlePureDeviceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function isShareThead() {
+    return isShareTheadForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function isActiveThread() {
+    return isActiveThreadForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getDeviceAdvancedAbilities() {
+    return getDeviceAdvancedAbilitiesForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/ble/exports/config.d.ts

@@ -0,0 +1,3 @@
+import { type UpdateConfigParams } from "../../../feature/misc/update-config";
+export type { UpdateConfigParams };
+export declare function updateConfig(options: UpdateConfigParams): void;

package/lib/entries/ble/exports/config.js

@@ -0,0 +1,5 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { updateConfigForRuntime, } from "../../../feature/misc/update-config";
+export function updateConfig(options) {
+    updateConfigForRuntime(resolveRuntimeFromExportThis(this), options);
+}

package/lib/entries/ble/exports/dp.d.ts

@@ -0,0 +1,9 @@
+import type { DpValue } from "../../../interface";
+import { getDpValueForRuntime } from "../../../feature/dp/get-dp-value";
+import { hasDpForRuntime } from "../../../feature/dp/has-dp";
+export declare function getDpValue(code: string): ReturnType<typeof getDpValueForRuntime>;
+export declare function hasDp(dpCode: string): ReturnType<typeof hasDpForRuntime>;
+export declare function publishDps(dpData: Record<string, DpValue>, option?: {
+    timeout?: number;
+    checkReport?: (dps: Record<string, unknown>) => boolean | Record<string, unknown>;
+}): Promise<Record<string, DpValue>>;

package/lib/entries/ble/exports/dp.js

@@ -0,0 +1,13 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getDpValueForRuntime } from "../../../feature/dp/get-dp-value";
+import { hasDpForRuntime } from "../../../feature/dp/has-dp";
+import { publishDpsForRuntime } from "../../../feature/dp/publish-dps";
+export function getDpValue(code) {
+    return getDpValueForRuntime(resolveRuntimeFromExportThis(this), code);
+}
+export function hasDp(dpCode) {
+    return hasDpForRuntime(resolveRuntimeFromExportThis(this), dpCode);
+}
+export async function publishDps(dpData, option) {
+    return publishDpsForRuntime(resolveRuntimeFromExportThis(this), dpData, option);
+}

package/lib/entries/ble/exports/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./config";
+export * from "./state";
+export * from "./dp";
+export * from "./offline-dps";
+export * from "./user";
+export * from "./unlock/sync";
+export * from "./unlock-method";
+export * from "./temporary";
+export * from "./open";
+export * from "./log";
+export * from "./signal";
+export * from "./sleep";
+export * from "./misc";
+export * from "./media";
+export * from "./linkage";
+export * from "./capability";

package/lib/entries/ble/exports/index.js

@@ -0,0 +1,16 @@
+export * from "./config";
+export * from "./state";
+export * from "./dp";
+export * from "./offline-dps";
+export * from "./user";
+export * from "./unlock/sync";
+export * from "./unlock-method";
+export * from "./temporary";
+export * from "./open";
+export * from "./log";
+export * from "./signal";
+export * from "./sleep";
+export * from "./misc";
+export * from "./media";
+export * from "./linkage";
+export * from "./capability";

package/lib/entries/ble/exports/linkage.d.ts

@@ -0,0 +1,5 @@
+export { getRemainingInfo } from "../../../feature/linkage/linkage";
+export declare function getDoorbellService(): Promise<import("../../../api/linkage").LinkageRule | undefined>;
+export declare function enableDoorbellService(): Promise<void>;
+export declare function disableDoorbellService(): Promise<void>;
+export declare function toSetDoorbellService(): Promise<void>;

package/lib/entries/ble/exports/linkage.js

@@ -0,0 +1,15 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getDoorbellServiceForRuntime, enableDoorbellServiceForRuntime, disableDoorbellServiceForRuntime, toSetDoorbellServiceForRuntime, } from "../../../feature/linkage/linkage";
+export { getRemainingInfo } from "../../../feature/linkage/linkage";
+export async function getDoorbellService() {
+    return getDoorbellServiceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function enableDoorbellService() {
+    return enableDoorbellServiceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function disableDoorbellService() {
+    return disableDoorbellServiceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function toSetDoorbellService() {
+    return toSetDoorbellServiceForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/ble/exports/log.d.ts

@@ -0,0 +1,9 @@
+import { GetLogsParams, GetAlarmsParams, GetAlbumsParams } from "../../../feature/log/log";
+import type { LogsRefreshListener } from "../../../feature/log/log";
+export declare function onLogsRefresh(cb: LogsRefreshListener): void;
+export declare function offLogsRefresh(cb: LogsRefreshListener): void;
+export { unlockDp2Type } from "../../../feature/log/log";
+export declare function getLatestLogs(): Promise<import("../../../feature/log/log").GetLatestLogsResult>;
+export declare function getLogs(params?: GetLogsParams): Promise<import("../../../feature/log/log").GetLogsResult>;
+export declare function getAlarms(params?: GetAlarmsParams): Promise<import("../../../feature/log/log").GetAlarmsResult>;
+export declare function getAlbums(params?: GetAlbumsParams): Promise<import("../../../feature/log/log").GetAlbumsResult>;

package/lib/entries/ble/exports/log.js

@@ -0,0 +1,21 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getLatestLogsForRuntime, getLogsForRuntime, getAlarmsForRuntime, getAlbumsForRuntime, onLogsRefreshForRuntime, offLogsRefreshForRuntime, } from "../../../feature/log/log";
+export function onLogsRefresh(cb) {
+    onLogsRefreshForRuntime(resolveRuntimeFromExportThis(this), cb);
+}
+export function offLogsRefresh(cb) {
+    offLogsRefreshForRuntime(resolveRuntimeFromExportThis(this), cb);
+}
+export { unlockDp2Type } from "../../../feature/log/log";
+export async function getLatestLogs() {
+    return getLatestLogsForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getLogs(params) {
+    return getLogsForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getAlarms(params) {
+    return getAlarmsForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getAlbums(params) {
+    return getAlbumsForRuntime(resolveRuntimeFromExportThis(this), params);
+}

package/lib/entries/ble/exports/media.d.ts

@@ -0,0 +1,4 @@
+import { GetMediaUrlParams } from "../../../feature/media/media";
+export declare function getMediaUrl(params: GetMediaUrlParams): Promise<import("../../../feature/media/media").MediaUrlResult>;
+export declare function isSupportMedia(): boolean;
+export declare function getMediaRotate(): import("../../../feature/media/rotate").MediaRotate;

package/lib/entries/ble/exports/media.js

@@ -0,0 +1,12 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getMediaUrlForRuntime, isSupportMediaForRuntime, } from "../../../feature/media/media";
+import { getMediaRotateForRuntime } from "../../../feature/media/rotate";
+export async function getMediaUrl(params) {
+    return getMediaUrlForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function isSupportMedia() {
+    return isSupportMediaForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getMediaRotate() {
+    return getMediaRotateForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/ble/exports/misc.d.ts

@@ -0,0 +1,19 @@
+import type { OpenSceneOptions } from "../../../feature/misc/types";
+export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
+export { formatDpPeriodTime } from "../../../feature/misc/dp-period";
+export declare function openScene(options?: OpenSceneOptions): Promise<void>;
+export declare function isSupportBleControl(): boolean;
+export declare function getDpPeriodTime(dpCode: string): import("../../../feature/misc/dp-period").GetDpPeriodTimeResult;
+export interface UpdateDpPeriodTimeParams {
+    start: number;
+    end: number;
+}
+export interface UpdateDpPeriodTimeOption {
+    offlineDp?: boolean;
+}
+export declare function updateDpPeriodTime(dpCode: string, data: UpdateDpPeriodTimeParams, option?: UpdateDpPeriodTimeOption): Promise<void>;
+export declare function connectDevice(): Promise<unknown>;
+export declare function gotoService(params?: {
+    tab?: "cloudStorage" | "AI";
+}): Promise<unknown>;
+export declare function validatePwdComplexity(password: string): Promise<boolean>;

package/lib/entries/ble/exports/misc.js

@@ -0,0 +1,30 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { openSceneForRuntime } from "../../../feature/misc/open-scene";
+import { isSupportBleControlForRuntime } from "../../../feature/misc/ble-control";
+import { getDpPeriodTimeForRuntime, updateDpPeriodTimeForRuntime, } from "../../../feature/misc/dp-period";
+import { connectDeviceForRuntime } from "../../../feature/misc/connect-device";
+import { validatePwdComplexityForRuntime } from "../../../feature/misc/validate-pwd";
+import { gotoServiceForRuntime } from "../../../feature/service/goto-service";
+export { parseDpPeriodTime } from "../../../feature/misc/dp-period";
+export { formatDpPeriodTime } from "../../../feature/misc/dp-period";
+export async function openScene(options) {
+    return openSceneForRuntime(resolveRuntimeFromExportThis(this), options);
+}
+export function isSupportBleControl() {
+    return isSupportBleControlForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getDpPeriodTime(dpCode) {
+    return getDpPeriodTimeForRuntime(resolveRuntimeFromExportThis(this), dpCode);
+}
+export function updateDpPeriodTime(dpCode, data, option) {
+    return updateDpPeriodTimeForRuntime(resolveRuntimeFromExportThis(this), dpCode, data, option);
+}
+export async function connectDevice() {
+    return connectDeviceForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function gotoService(params) {
+    return gotoServiceForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function validatePwdComplexity(password) {
+    return validatePwdComplexityForRuntime(resolveRuntimeFromExportThis(this), password);
+}

package/lib/entries/ble/exports/offline-dps.d.ts

@@ -0,0 +1,8 @@
+import type { DpValue } from "../../../interface";
+export { onOfflineDpsUpdate } from "../../../feature/offline-dps";
+export { offOfflineDpsUpdate } from "../../../feature/offline-dps";
+export declare function publishOfflineDps(dps: Record<string, DpValue>): Promise<void>;
+export declare function getOfflineDps(isForce?: boolean): Promise<import("../../../interface").OfflineDps>;
+export declare function getOfflineDpCache(code: string): import("../../../interface").OfflineDpInfo | undefined;
+export declare function checkOfflineDpUpdate(dps: Record<string, DpValue>, isForce?: boolean): Promise<void>;
+export declare function isOfflineDpSyncing(code: string): boolean;

package/lib/entries/ble/exports/offline-dps.js

@@ -0,0 +1,24 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { checkOfflineDpUpdateForRuntime, publishOfflineDpsForRuntime, getOfflineDpsForRuntime, getOfflineDpCacheForRuntime, } from "../../../feature/offline-dps";
+export { onOfflineDpsUpdate } from "../../../feature/offline-dps";
+export { offOfflineDpsUpdate } from "../../../feature/offline-dps";
+export async function publishOfflineDps(dps) {
+    return publishOfflineDpsForRuntime(resolveRuntimeFromExportThis(this), dps);
+}
+export async function getOfflineDps(isForce) {
+    return getOfflineDpsForRuntime(resolveRuntimeFromExportThis(this), isForce);
+}
+export function getOfflineDpCache(code) {
+    return getOfflineDpCacheForRuntime(resolveRuntimeFromExportThis(this), code);
+}
+export async function checkOfflineDpUpdate(dps, isForce) {
+    return checkOfflineDpUpdateForRuntime(resolveRuntimeFromExportThis(this), dps, isForce);
+}
+export function isOfflineDpSyncing(code) {
+    const rt = resolveRuntimeFromExportThis(this);
+    if (!rt.config.supportOfflineDps) {
+        return false;
+    }
+    const cache = getOfflineDpCacheForRuntime(rt, code);
+    return !!(cache && cache.pushStatus === false);
+}

package/lib/entries/ble/exports/open/do-open-close-action.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../../runtime/LockDeviceRuntime";
+export declare const doOpenCloseAction: (this: unknown, rt: LockDeviceRuntime, isOpen: boolean, timeout: number) => Promise<void>;

package/lib/entries/ble/exports/open/do-open-close-action.js

@@ -0,0 +1,36 @@
+import { parallelOnlyForRuntime } from "../../../../feature/utils";
+import { checkRemoteEnabledForRuntime } from "../../../../feature/unlock/door/check-remote";
+import { getCurrentUserForRuntime } from "../../../../feature/user/current-user";
+import { resolveOpenClosePath } from "../../../../feature/unlock/door/open-close-path";
+import { executeOpenCloseMatterLan } from "../../../../feature/unlock/door/door-matter-lan";
+import { executeOpenCloseNearDualMode } from "../../../../feature/unlock/door/door-near-dual-mode";
+import { executeOpenCloseBleOnly } from "../../../../feature/unlock/door/door-ble-only";
+import { executeOpenCloseRemoteCloud } from "../../../../feature/unlock/door/door-remote-cloud";
+import { checkCurrentUserValid } from "../../../../feature/unlock/door/check-user-valid";
+export const doOpenCloseAction = parallelOnlyForRuntime(async function doOpenCloseAction(rt, isOpen, timeout) {
+    await checkRemoteEnabledForRuntime(rt);
+    const path = resolveOpenClosePath(rt);
+    const currentUser = await getCurrentUserForRuntime(rt);
+    await checkCurrentUserValid(rt);
+    const memberId = currentUser.lockUserId !== 0
+        ? currentUser.lockUserId
+        : currentUser.userId;
+    switch (path) {
+        case "matter_lan":
+            await executeOpenCloseMatterLan(rt, isOpen);
+            return;
+        case "near_dual_mode":
+            await executeOpenCloseNearDualMode(rt, isOpen, timeout, memberId);
+            return;
+        case "ble_only":
+            await executeOpenCloseBleOnly(rt, isOpen, timeout, memberId);
+            return;
+        case "remote_cloud":
+            await executeOpenCloseRemoteCloud(rt, isOpen, timeout, memberId);
+            return;
+        default: {
+            const _exhaustive = path;
+            return _exhaustive;
+        }
+    }
+});

package/lib/entries/ble/exports/open/index.d.ts

@@ -0,0 +1,18 @@
+import { doOpenCloseAction } from "./do-open-close-action";
+import { getRemotePermissionList } from "../../../../feature/unlock/door/remote-permission";
+import { type OpenDoorCallOptions } from "../../../../feature/unlock/door/types";
+import { RemotePermissionType } from "../../../../constant";
+export { doOpenCloseAction as doOpenCloseActionForRuntime };
+export declare function checkRemoteEnabled(): Promise<void>;
+export declare function openDoor(option?: OpenDoorCallOptions): Promise<void>;
+export declare function closeDoor(option?: OpenDoorCallOptions): Promise<void>;
+export declare function remoteEnabled(state: boolean): Promise<void>;
+export declare function getRemoteEnabled(): boolean;
+export { getRemotePermissionList };
+export declare function getRemotePermission(): RemotePermissionType;
+export declare function updateRemotePermission(permission: RemotePermissionType): Promise<void>;
+export declare function agreeOpenDoor(option?: OpenDoorCallOptions): Promise<void>;
+export declare function rejectOpenDoor(option?: OpenDoorCallOptions): Promise<void>;
+export declare function getVoiceUnlockPwdEnabled(): Promise<boolean>;
+export declare function voiceUnlockPwdDisabled(): Promise<boolean>;
+export declare function updateVoiceUnlockPwd(password: string): Promise<boolean>;

package/lib/entries/ble/exports/open/index.js

@@ -0,0 +1,45 @@
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { checkRemoteEnabledForRuntime } from "../../../../feature/unlock/door/check-remote";
+import { doOpenCloseAction } from "./do-open-close-action";
+import { handleOpenDoorForRuntime } from "../../../../feature/unlock/door/wifi-pro-confirm";
+import { getRemotePermissionList, remoteEnabledForRuntime, updateRemotePermissionForRuntime, } from "../../../../feature/unlock/door/remote-permission";
+import { getVoiceUnlockPwdEnabledForRuntime, voiceUnlockPwdDisabledForRuntime, updateVoiceUnlockPwdForRuntime, } from "../../../../feature/unlock/door/voice-unlock-pwd";
+import { OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS, } from "../../../../feature/unlock/door/types";
+export { doOpenCloseAction as doOpenCloseActionForRuntime };
+export async function checkRemoteEnabled() {
+    await checkRemoteEnabledForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function openDoor(option) {
+    return doOpenCloseAction(resolveRuntimeFromExportThis(this), true, option?.timeout ?? OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS);
+}
+export function closeDoor(option) {
+    return doOpenCloseAction(resolveRuntimeFromExportThis(this), false, option?.timeout ?? OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS);
+}
+export async function remoteEnabled(state) {
+    await remoteEnabledForRuntime(resolveRuntimeFromExportThis(this), state);
+}
+export function getRemoteEnabled() {
+    return resolveRuntimeFromExportThis(this).config.remoteOpenEnabled;
+}
+export { getRemotePermissionList };
+export function getRemotePermission() {
+    return resolveRuntimeFromExportThis(this).config.remoteOpenPermission;
+}
+export async function updateRemotePermission(permission) {
+    await updateRemotePermissionForRuntime(resolveRuntimeFromExportThis(this), permission);
+}
+export function agreeOpenDoor(option) {
+    return handleOpenDoorForRuntime(resolveRuntimeFromExportThis(this), true, option?.timeout ?? OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS);
+}
+export function rejectOpenDoor(option) {
+    return handleOpenDoorForRuntime(resolveRuntimeFromExportThis(this), false, option?.timeout ?? OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS);
+}
+export async function getVoiceUnlockPwdEnabled() {
+    return getVoiceUnlockPwdEnabledForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function voiceUnlockPwdDisabled() {
+    return voiceUnlockPwdDisabledForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function updateVoiceUnlockPwd(password) {
+    return updateVoiceUnlockPwdForRuntime(resolveRuntimeFromExportThis(this), password);
+}

package/lib/entries/ble/exports/signal.d.ts

@@ -0,0 +1,6 @@
+import type { WiFiSignalChangeListener } from "../../../feature/misc/signal";
+export type { WiFiSignalChangeListener } from "../../../feature/misc/signal";
+export declare function getWiFiSignal(): Promise<void>;
+export declare function getCurrentWiFiSignal(): number | "unknown";
+export declare function onWiFiSignalChange(cb: WiFiSignalChangeListener): void;
+export declare function offWiFiSignalChange(cb: WiFiSignalChangeListener): void;

package/lib/entries/ble/exports/signal.js

@@ -0,0 +1,14 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getWiFiSignalForRuntime, getCurrentWiFiSignalForRuntime, onWiFiSignalChangeForRuntime, offWiFiSignalChangeForRuntime, } from "../../../feature/misc/signal";
+export function getWiFiSignal() {
+    return getWiFiSignalForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getCurrentWiFiSignal() {
+    return getCurrentWiFiSignalForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function onWiFiSignalChange(cb) {
+    onWiFiSignalChangeForRuntime(resolveRuntimeFromExportThis(this), cb);
+}
+export function offWiFiSignalChange(cb) {
+    offWiFiSignalChangeForRuntime(resolveRuntimeFromExportThis(this), cb);
+}

package/lib/entries/ble/exports/sleep.d.ts

@@ -0,0 +1,13 @@
+import type { SleepStatusListener } from "../../../feature/misc/sleep";
+export declare function isSleep(): boolean;
+export declare function hasSleepAbility(): boolean;
+export declare function isEnabledSleep(): boolean;
+export declare function enableSleep(): Promise<void>;
+export declare function disableSleep(): Promise<void>;
+export declare function getSleepPeriod(): import("../../../feature/misc/dp-period").GetDpPeriodTimeResult;
+export declare function updateSleepPeriod(params: {
+    start: number;
+    end: number;
+}): Promise<void>;
+export declare function onSleepStatusChange(callback: SleepStatusListener): void;
+export declare function offSleepStatusChange(callback: SleepStatusListener): void;

package/lib/entries/ble/exports/sleep.js

@@ -0,0 +1,31 @@
+import dpCodes from "../../../config/dp-code";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getDpPeriodTimeForRuntime, updateDpPeriodTimeForRuntime, } from "../../../feature/misc/dp-period";
+import { isSleepForRuntime, hasSleepAbilityForRuntime, getSwitchStatusForRuntime, setSleepStatusForRuntime, onSleepStatusChangeForRuntime, offSleepStatusChangeForRuntime, } from "../../../feature/misc/sleep";
+export function isSleep() {
+    return isSleepForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function hasSleepAbility() {
+    return hasSleepAbilityForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function isEnabledSleep() {
+    return getSwitchStatusForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function enableSleep() {
+    return setSleepStatusForRuntime(resolveRuntimeFromExportThis(this), true);
+}
+export async function disableSleep() {
+    return setSleepStatusForRuntime(resolveRuntimeFromExportThis(this), false);
+}
+export function getSleepPeriod() {
+    return getDpPeriodTimeForRuntime(resolveRuntimeFromExportThis(this), dpCodes.dormantTimeSet);
+}
+export function updateSleepPeriod(params) {
+    return updateDpPeriodTimeForRuntime(resolveRuntimeFromExportThis(this), dpCodes.dormantTimeSet, params, { offlineDp: true });
+}
+export function onSleepStatusChange(callback) {
+    onSleepStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offSleepStatusChange(callback) {
+    offSleepStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}

package/lib/entries/ble/exports/state.d.ts

@@ -0,0 +1,6 @@
+import { type DeviceStatus } from "../../../interface";
+export declare function getCurrentUser(isForce?: boolean): Promise<import("../../../interface").CurrentUser>;
+export declare function getCurrentUserSync(): import("../../../interface").CurrentUser | null;
+export declare function getDeviceStatus(): DeviceStatus;
+export declare function onDeviceStatusChange(callback: (status: DeviceStatus) => void): void;
+export declare function offDeviceStatusChange(callback: (status: DeviceStatus) => void): void;

package/lib/entries/ble/exports/state.js

@@ -0,0 +1,19 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getCurrentUserForRuntime } from "../../../feature/user/current-user";
+import { getDeviceStatusForRuntime } from "../../../feature/state/device-status";
+import { onDeviceStatusChangeForRuntime, offDeviceStatusChangeForRuntime, } from "../../../feature/state/device-status-events";
+export async function getCurrentUser(isForce) {
+    return getCurrentUserForRuntime(resolveRuntimeFromExportThis(this), isForce);
+}
+export function getCurrentUserSync() {
+    return resolveRuntimeFromExportThis(this).cache.currentUser;
+}
+export function getDeviceStatus() {
+    return getDeviceStatusForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function onDeviceStatusChange(callback) {
+    onDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offDeviceStatusChange(callback) {
+    offDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}

package/lib/entries/ble/exports/temporary.d.ts

@@ -0,0 +1,31 @@
+import type { CreateClearParams, CreateCustomParams, CreateLimitParams, CreateOfflineParams, CreateOnceParams, CreateOnlineUnlimitedParams, FreezeParams, GetInvalidListParams, OfflinePasswordType, RemoveCustomProps, RenameParams, UpdateTempPasswordParams } from "../../../feature/password/temporary/types";
+import type { TempPasswordResult } from "../../../interface";
+export type { EffectivePasswrodItem, InvalidPasswordItem, OfflinePasswordItem, OfflinePasswordType, OfflineTempResult, OfflineTempType, OnlinePasswordItem, } from "../../../feature/password/temporary/types";
+export declare function createTempCustom(params: CreateCustomParams): Promise<TempPasswordResult>;
+export declare function removeTempCustom(params: RemoveCustomProps): Promise<boolean>;
+export declare function updateTempCustom(params: UpdateTempPasswordParams): Promise<boolean>;
+export declare function getTempEffectiveList(): Promise<import("../../../feature/password/temporary/types").EffectivePasswrodItem[]>;
+export declare function getTempInvalidList(params?: GetInvalidListParams): Promise<{
+    list: import("../../../feature/password/temporary/types").InvalidPasswordItem[];
+    hasMore: boolean;
+    total: number;
+}>;
+export declare function clearTempInvalidList(): Promise<boolean>;
+export declare function freezeTemp(params: FreezeParams): Promise<unknown>;
+export declare function unfreezeTemp(params: FreezeParams): Promise<unknown>;
+export declare function renameTemp(params: RenameParams): Promise<void>;
+export declare function saveTempOnlineUnlimited(params: CreateOnlineUnlimitedParams): Promise<{
+    type: "custom";
+    name: string;
+    pwdId: string;
+    effectiveConfig: import("../../../interface").EffectiveConfig;
+}>;
+export declare function removeTempOnlineUnlimited(id: string): Promise<void>;
+export declare function getTempOnlineUnlimitedList(): Promise<import("../../../feature/password/temporary/wifi-online").OnlinePasswordItem[]>;
+export declare function createTempOffline(params: CreateOfflineParams): Promise<import("../../../feature/password/temporary/types").OfflineTempResult>;
+export declare function getTempOfflineEffectiveList(pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;
+export declare function getTempOfflineInvalidList(pwdTypeCode: OfflinePasswordType): Promise<import("../../../api/temp").EffectivePasswrodItem[]>;
+export declare function createTempLimit(params: CreateLimitParams): Promise<TempPasswordResult>;
+export declare function createTempOnce(params: CreateOnceParams): Promise<TempPasswordResult>;
+export declare function createTempDynamic(): Promise<TempPasswordResult>;
+export declare function createTempClear(params: CreateClearParams): Promise<TempPasswordResult>;