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

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

@@ -0,0 +1,24 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getLatestLogsForRuntime, getLogsForRuntime, getAlarmsForRuntime, getAlbumsForRuntime, onLogsRefreshForRuntime, offLogsRefreshForRuntime, getLockLogListForRuntime, } 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);
+}
+export async function getLockLogList(params) {
+    return getLockLogListForRuntime(resolveRuntimeFromExportThis(this), params);
+}

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

@@ -0,0 +1,15 @@
+import { GetMediaUrlParams, OpenLocalAlbumParams, GotoPlaybackParams } 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;
+export declare function getMediaInfo(): import("../../../feature/media/media").MediaInfo;
+export declare function openLocalAlbum(params?: OpenLocalAlbumParams): Promise<void>;
+export declare function gotoPlayback(params?: GotoPlaybackParams): Promise<void>;
+export declare function isSupportMultiCamera(): boolean;
+export declare function getCameraInfo(): import("../../../feature/media/camera").CameraDpInfo | undefined;
+export declare function queryCameraInfo(): Promise<import("../../../feature/media/camera").CameraInfo | undefined>;
+export declare function switchCamera(index: number): Promise<true>;
+export declare function getMediaViewTimes(): Promise<import("../../../api/video").MediaViewTimesResult>;
+export declare function addMediaViewTimes(): Promise<import("../../../api/video").MediaViewTimesResult>;
+export declare function getAlbumDateList(): Promise<import("../../../api/video").getAlbumDateListResult>;
+export declare function getCameraConfig(): import("../../..").CameraConfig[];

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

@@ -0,0 +1,46 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getMediaUrlForRuntime, isSupportMediaForRuntime, openLocalAlbumForRuntime, gotoPlaybackForRuntime, getMediaInfoForRuntime, getMediaViewTimesForRuntime, setMediaViewTimesForRuntime, getAlbumDateListForRuntime, } from "../../../feature/media/media";
+import { getMediaRotateForRuntime } from "../../../feature/media/rotate";
+import { isSupportMultiCameraForRuntime, getCameraInfoForRuntime, queryCameraInfoForRuntime, switchCameraForRuntime, getCameraConfigForRuntime, } from "../../../feature/media/camera";
+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);
+}
+export function gotoPlayback(params) {
+    return gotoPlaybackForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function isSupportMultiCamera() {
+    return isSupportMultiCameraForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getCameraInfo() {
+    return getCameraInfoForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function queryCameraInfo() {
+    return queryCameraInfoForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function switchCamera(index) {
+    return switchCameraForRuntime(resolveRuntimeFromExportThis(this), index);
+}
+export async function getMediaViewTimes() {
+    return getMediaViewTimesForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function addMediaViewTimes() {
+    return setMediaViewTimesForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getAlbumDateList() {
+    return getAlbumDateListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getCameraConfig() {
+    return getCameraConfigForRuntime(resolveRuntimeFromExportThis(this));
+}

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/notify.d.ts

@@ -0,0 +1,7 @@
+export type { VasNotifyConfig, VasNotifyScene, VasNotifyPushConfig, UpdateVasNotifyConfigParams, } from "../../../api/notify";
+export declare function getVasNotifyConfig(): Promise<import("../../../api/notify").VasNotifyConfig>;
+export declare function updateVasNotifyConfig(params: {
+    key: string;
+    enable: boolean;
+    userId?: string;
+}): Promise<import("../../../api/notify").VasNotifyConfig>;

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

@@ -0,0 +1,8 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getVasNotifyConfigForRuntime, updateVasNotifyConfigForRuntime, } from "../../../feature/notify/notify";
+export async function getVasNotifyConfig() {
+    return getVasNotifyConfigForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function updateVasNotifyConfig(params) {
+    return updateVasNotifyConfigForRuntime(resolveRuntimeFromExportThis(this), params);
+}

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,7 @@
+import { type BindLockToScreenEvent, type BindLockToScreenListener } from "../../../../feature/screen/bind-watch";
+import type { AddBindingResult, BindingResult, UnbindingResult } from "../../../../api/screen";
+export type { AddBindingResult, BindingResult, UnbindingResult, BindLockToScreenEvent, BindLockToScreenListener, };
+export declare function bindLockToScreen(lockDevId: string): Promise<AddBindingResult>;
+export declare function onBindLockToScreen(listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreen(listener: BindLockToScreenListener): void;
+export declare function unbindLockFromScreen(relationId: string): Promise<UnbindingResult>;

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

@@ -0,0 +1,15 @@
+import { bindLockForRuntime, unbindLockForRuntime, } from "../../../../feature/screen/bind";
+import { onBindLockToScreenForRuntime, offBindLockToScreenForRuntime, } from "../../../../feature/screen/bind-watch";
+import { resolveRuntimeFromExportThis } from "../../bootstrap/resolve-runtime-from-export-this";
+export function bindLockToScreen(lockDevId) {
+    return bindLockForRuntime(resolveRuntimeFromExportThis(this), lockDevId);
+}
+export function onBindLockToScreen(listener) {
+    onBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offBindLockToScreen(listener) {
+    offBindLockToScreenForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+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/service.d.ts

@@ -0,0 +1,4 @@
+export type { CloudServiceStatus, ServiceBenefitPopupItem, ClaimResultItem, } from "../../../api/service";
+export declare function getCloudServiceStatus(): Promise<import("../../../api/service").CloudServiceStatus>;
+export declare function getServicePopupList(): Promise<import("../../../api/service").ServiceBenefitPopupItem[]>;
+export declare function claimService(batchId: string): Promise<import("../../../api/service").ClaimResultItem[]>;

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

@@ -0,0 +1,11 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getCloudServiceStatusForRuntime, getServicePopupListForRuntime, claimServiceForRuntime, } from "../../../feature/service/value-added";
+export async function getCloudServiceStatus() {
+    return getCloudServiceStatusForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getServicePopupList() {
+    return getServicePopupListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function claimService(batchId) {
+    return claimServiceForRuntime(resolveRuntimeFromExportThis(this), batchId);
+}

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