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

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

@@ -0,0 +1,18 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getMediaUrlForRuntime, isSupportMediaForRuntime, openLocalAlbumForRuntime, getMediaInfoForRuntime, } 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));
+}
+export function getMediaInfo() {
+    return getMediaInfoForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function openLocalAlbum(params) {
+    return openLocalAlbumForRuntime(resolveRuntimeFromExportThis(this), params);
+}

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

@@ -0,0 +1,18 @@
+import { GotoServiceParams } from "../../../feature/service/goto-service";
+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<true>;
+export declare function gotoService(params?: GotoServiceParams): Promise<unknown>;
+export declare function validatePwdComplexity(password: string): Promise<boolean>;

package/lib/entries/main/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/main/exports/offline-dps.d.ts

@@ -0,0 +1,8 @@
+import type { DpValue, OfflineDps } from "../../../interface";
+export declare function onOfflineDpsUpdate(callback: (dps: OfflineDps) => void): void;
+export declare function offOfflineDpsUpdate(callback: (dps: OfflineDps) => void): void;
+export declare function publishOfflineDps(dps: Record<string, DpValue>): Promise<void>;
+export declare function getOfflineDps(isForce?: boolean): Promise<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/main/exports/offline-dps.js

@@ -0,0 +1,28 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { checkOfflineDpUpdateForRuntime, publishOfflineDpsForRuntime, getOfflineDpsForRuntime, getOfflineDpCacheForRuntime, onOfflineDpsUpdateForRuntime, offOfflineDpsUpdateForRuntime, } from "../../../feature/offline-dps";
+export function onOfflineDpsUpdate(callback) {
+    onOfflineDpsUpdateForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offOfflineDpsUpdate(callback) {
+    offOfflineDpsUpdateForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+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/main/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/main/exports/open/do-open-close-action.js

@@ -0,0 +1,68 @@
+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";
+import { sdkLog } from "../../../../utils/sdk-log";
+export const doOpenCloseAction = parallelOnlyForRuntime(async function doOpenCloseAction(rt, isOpen, timeout) {
+    const startedAt = Date.now();
+    let path;
+    sdkLog("info", "unlock", "start", {
+        devId: rt.devId,
+        data: {
+            isOpen,
+            timeout,
+            statusType: rt.deviceStatus.type,
+            onlineTypes: rt.deviceStatus.onlineTypes,
+        },
+    });
+    try {
+        await checkRemoteEnabledForRuntime(rt);
+        path = resolveOpenClosePath(rt);
+        sdkLog("debug", "unlock", "routeSelected", {
+            devId: rt.devId,
+            data: { route: path },
+        });
+        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);
+                break;
+            case "near_dual_mode":
+                await executeOpenCloseNearDualMode(rt, isOpen, timeout, memberId);
+                break;
+            case "ble_only":
+                await executeOpenCloseBleOnly(rt, isOpen, timeout, memberId);
+                break;
+            case "remote_cloud":
+                await executeOpenCloseRemoteCloud(rt, isOpen, timeout, memberId);
+                break;
+            default: {
+                const _exhaustive = path;
+                return _exhaustive;
+            }
+        }
+        sdkLog("info", "unlock", "success", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { isOpen, route: path },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "unlock", "fail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { isOpen, route: path },
+            error,
+        });
+        throw error;
+    }
+});

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

@@ -0,0 +1,16 @@
+import { getRemotePermissionList } from "../../../../feature/unlock/door/remote-permission";
+import { type OpenDoorCallOptions } from "../../../../feature/unlock/door/types";
+import { RemotePermissionType } from "../../../../constant";
+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/main/exports/open/index.js

@@ -0,0 +1,44 @@
+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 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/main/exports/open.d.ts

@@ -0,0 +1,16 @@
+import { getRemotePermissionList } from "../../../feature/unlock/door/remote-permission";
+import { type OpenDoorCallOptions } from "../../../feature/unlock/door/types";
+import { RemotePermissionType } from "packages/lock-sdk/src/constant";
+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/main/exports/open.js

@@ -0,0 +1,44 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { checkRemoteEnabledForRuntime } from "../../../feature/unlock/door/check-remote";
+import { doOpenCloseActionForRuntime } from "../../../feature/unlock/door/door-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 async function checkRemoteEnabled() {
+    await checkRemoteEnabledForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function openDoor(option) {
+    return doOpenCloseActionForRuntime(resolveRuntimeFromExportThis(this), true, option?.timeout ?? OPEN_CLOSE_ACTION_DEFAULT_TIMEOUT_MS);
+}
+export function closeDoor(option) {
+    return doOpenCloseActionForRuntime(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/main/exports/screen/bind.d.ts

@@ -0,0 +1,4 @@
+import type { BindingResult, UnbindingResult } from "../../../../api/screen";
+export type { BindingResult, UnbindingResult };
+export declare function bindLockToScreen(lockDevId: string): Promise<BindingResult>;
+export declare function unbindLockFromScreen(relationId: string): Promise<UnbindingResult>;

package/lib/entries/main/exports/screen/bind.js

@@ -0,0 +1,8 @@
+import { bindLockForRuntime, unbindLockForRuntime, } from "../../../../feature/screen/bind";
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+export function bindLockToScreen(lockDevId) {
+    return bindLockForRuntime(resolveRuntimeFromExportThis(this), lockDevId);
+}
+export function unbindLockFromScreen(relationId) {
+    return unbindLockForRuntime(resolveRuntimeFromExportThis(this), relationId);
+}

package/lib/entries/main/exports/screen/list.d.ts

@@ -0,0 +1,5 @@
+import type { BindableLockListResult as ScreenBindableLockListResult, BindableLockItem as ScreenBindableLockItem, BoundLockListResult as ScreenBoundLockListResult, BoundLockItem as ScreenBoundLockItem, ScreenEventItem, ScreenEventListParams, ScreenEventListResult, ScreenEventLogType, ScreenEventType } from "../../../../api/screen";
+export type { ScreenEventItem, ScreenEventListParams, ScreenEventListResult, ScreenEventLogType, ScreenEventType, ScreenBindableLockItem, ScreenBoundLockItem, ScreenBoundLockListResult, ScreenBindableLockListResult, };
+export declare function getScreenEventList(params?: ScreenEventListParams): Promise<ScreenEventListResult>;
+export declare function getScreenBoundLockList(): Promise<ScreenBoundLockListResult>;
+export declare function getScreenBindableLockList(): Promise<ScreenBindableLockListResult>;

package/lib/entries/main/exports/screen/list.js

@@ -0,0 +1,13 @@
+import { getEventListForRuntime } from "../../../../feature/screen/event";
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { getBoundLockListForRuntime } from "../../../../feature/screen/list";
+import { getBindableLockListForRuntime } from "../../../../feature/screen/list";
+export function getScreenEventList(params) {
+    return getEventListForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getScreenBoundLockList() {
+    return getBoundLockListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getScreenBindableLockList() {
+    return getBindableLockListForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/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/main/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/main/exports/sleep.d.ts

@@ -0,0 +1,15 @@
+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;
+interface UpdateSleepPeriodParams {
+    start: number;
+    end: number;
+}
+export declare function updateSleepPeriod(params: UpdateSleepPeriodParams): Promise<void>;
+export declare function onSleepStatusChange(callback: SleepStatusListener): void;
+export declare function offSleepStatusChange(callback: SleepStatusListener): void;
+export {};

package/lib/entries/main/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/main/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/main/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/main/exports/temporary.d.ts

@@ -0,0 +1,32 @@
+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<boolean>;
+export declare function unfreezeTemp(params: FreezeParams): Promise<boolean>;
+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>;
+export declare function getTempLimitListForClear(): Promise<import("../../../feature/password/temporary/lists").LimitTempItem[]>;

package/lib/entries/main/exports/temporary.js

@@ -0,0 +1,86 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { createTempCustomForRuntime, removeTempCustomForRuntime, updateTempCustomForRuntime, } from "../../../feature/password/temporary/custom-dp";
+import { createTempCustomForRuntime as createTempCustomForRuntimeBle, updateTempCustomForRuntime as updateTempCustomForRuntimeBle, removeTempCustomForRuntime as removeTempCustomForRuntimeBle, } from "../../../feature/password/temporary/custom-dp-ble";
+import { createTempClearForRuntime, createTempDynamicForRuntime, createTempLimitForRuntime, createTempOnceForRuntime, } from "../../../feature/password/temporary/offline-create";
+import { clearTempInvalidListForRuntime, getTempEffectiveListForRuntime, getTempInvalidListForRuntime, getTempLimitListForClearForRuntime, } from "../../../feature/password/temporary/lists";
+import { freezeTempForRuntime, renameTempForRuntime, unfreezeTempForRuntime, } from "../../../feature/password/temporary/freeze-rename";
+import { getTempOnlineUnlimitedListForRuntime, removeTempOnlineUnlimitedForRuntime, saveTempOnlineUnlimitedForRuntime, } from "../../../feature/password/temporary/wifi-online";
+import { createTempOfflineForRuntime, getTempOfflineEffectiveListForRuntime, getTempOfflineInvalidListForRuntime, } from "../../../feature/password/temporary/wifi-offline";
+import { isBlePureDeviceForRuntime } from "../../../feature/misc/capability";
+export function createTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return createTempCustomForRuntimeBle(rt, params);
+    }
+    return createTempCustomForRuntime(rt, params);
+}
+export function removeTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return removeTempCustomForRuntimeBle(rt, params);
+    }
+    return removeTempCustomForRuntime(rt, params);
+}
+export function updateTempCustom(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    const isBlePureDevice = isBlePureDeviceForRuntime(rt);
+    if (isBlePureDevice) {
+        return updateTempCustomForRuntimeBle(rt, params);
+    }
+    return updateTempCustomForRuntime(rt, params);
+}
+export function getTempEffectiveList() {
+    return getTempEffectiveListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getTempInvalidList(params) {
+    return getTempInvalidListForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function clearTempInvalidList() {
+    return clearTempInvalidListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function freezeTemp(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    return freezeTempForRuntime(rt, params);
+}
+export function unfreezeTemp(params) {
+    const rt = resolveRuntimeFromExportThis(this);
+    return unfreezeTempForRuntime(rt, params);
+}
+export function renameTemp(params) {
+    return renameTempForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function saveTempOnlineUnlimited(params) {
+    return saveTempOnlineUnlimitedForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function removeTempOnlineUnlimited(id) {
+    return removeTempOnlineUnlimitedForRuntime(resolveRuntimeFromExportThis(this), id);
+}
+export function getTempOnlineUnlimitedList() {
+    return getTempOnlineUnlimitedListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function createTempOffline(params) {
+    return createTempOfflineForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getTempOfflineEffectiveList(pwdTypeCode) {
+    return getTempOfflineEffectiveListForRuntime(resolveRuntimeFromExportThis(this), pwdTypeCode);
+}
+export function getTempOfflineInvalidList(pwdTypeCode) {
+    return getTempOfflineInvalidListForRuntime(resolveRuntimeFromExportThis(this), pwdTypeCode);
+}
+export function createTempLimit(params) {
+    return createTempLimitForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function createTempOnce(params) {
+    return createTempOnceForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function createTempDynamic() {
+    return createTempDynamicForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function createTempClear(params) {
+    return createTempClearForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getTempLimitListForClear() {
+    return getTempLimitListForClearForRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/unlock/sync.d.ts

@@ -0,0 +1 @@
+export declare function syncUnlockMethod(): Promise<void>;

package/lib/entries/main/exports/unlock/sync.js

@@ -0,0 +1,5 @@
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+import { syncUnlockMethodWithRuntime } from "../../../../feature/unlock/sync/unlock-method";
+export async function syncUnlockMethod() {
+    return syncUnlockMethodWithRuntime(resolveRuntimeFromExportThis(this));
+}

package/lib/entries/main/exports/unlock-method.d.ts

@@ -0,0 +1,19 @@
+import type { AddPasswordParams, AddUnlockMethodBaseParams, AddUnlockMethodEvent, AddUnlockMethodListener, BindUnlockMethodFromLogParams, BindUnlockMethodParams, CancelAddUnlockMethodParams, SendVerifyCodeParams, SpecialUnlockMethodInfo, StartAddUnlockMethodParams, updateUnlockMethodParams } from "../../../feature/unlock/method/types";
+import type { UnlockMethodType } from "../../../interface";
+export type { AddPasswordParams, AddUnlockMethodBaseParams, AddUnlockMethodEvent, AddUnlockMethodListener, SpecialUnlockMethodInfo, updateUnlockMethodParams, };
+export declare function getUnlockMethodDetail(id: number): Promise<import("../../../interface").UnlockMethodDetail>;
+export declare function checkSpecialSupportPhone(): boolean;
+export declare function addPassword(params: AddPasswordParams): Promise<import("../../../api/lock").CreateUnlockMethodResult>;
+export declare function startAddUnlockMethod(params: StartAddUnlockMethodParams): Promise<import("../../../feature/unlock/method/add-flow").StartAddUnlockMethodResult>;
+export declare function cancelAddUnlockMethod(params: CancelAddUnlockMethodParams): Promise<void>;
+export declare function updateUnlockMethod(params: updateUnlockMethodParams): Promise<void>;
+export declare function deleteUnlockMethod(id: number): Promise<void>;
+export declare function checkUnBindUnlockMethods(): Promise<boolean>;
+export declare function getUnbindUnlockMethods(): Promise<import("../../../interface").UnBindUnlockMethodGroup[]>;
+export declare function bindUnlockMethod(params: BindUnlockMethodParams): Promise<boolean>;
+export declare function unbindUnlockMethod(id: number): Promise<void>;
+export declare function bindUnlockMethodFromLog(params: BindUnlockMethodFromLogParams): Promise<boolean>;
+export declare function sendVerifyCode(params: SendVerifyCodeParams): Promise<void>;
+export declare function onAddUnlockMethod(listener: AddUnlockMethodListener): void;
+export declare function offAddUnlockMethod(listener: AddUnlockMethodListener): void;
+export declare function getUnlockGuide(type: UnlockMethodType): Promise<import("../../../interface").UnlockGuide | null>;