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

package/lib/entries/fit/exports/device.js

@@ -0,0 +1,64 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { fitAddPasswordForRuntime } from "../../../feature/fit/method/add-password";
+import { fitCancelAddUnlockMethodForRuntime, fitStartAddUnlockMethodForRuntime, } from "../../../feature/fit/method/add-flow";
+import { fitDeleteUnlockMethodForRuntime, fitUpdateUnlockMethodForRuntime, } from "../../../feature/fit/method/update-remove";
+import { offFitAddUnlockMethodForRuntime, onFitAddUnlockMethodForRuntime, } from "../../../feature/fit/method/add-method-events";
+import { getFitUnlockMethodListForRuntime } from "../../../feature/fit/method/list";
+import { syncFitBindingsForRuntime, syncFitReportForRuntime, syncOpenModeRiseForRuntime, } from "../../../feature/fit/sync";
+import { getFitBleKeyListForRuntime, addFitBleKeyForRuntime, updateFitBleKeyForRuntime, removeFitBleKeyForRuntime, renameFitBleKeyForRuntime, } from "../../../feature/fit/ble-key";
+import { setFitSettingForRuntime } from "../../../feature/fit/setting";
+import { getFitUsersForRuntime, } from "../../../feature/fit/users";
+export function fitAddPassword(params) {
+    return fitAddPasswordForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function fitStartAddUnlockMethod(params) {
+    return fitStartAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function fitCancelAddUnlockMethod(params) {
+    return fitCancelAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function onFitAddUnlockMethod(listener) {
+    onFitAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function offFitAddUnlockMethod(listener) {
+    offFitAddUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), listener);
+}
+export function fitUpdateUnlockMethod(params) {
+    return fitUpdateUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function fitDeleteUnlockMethod(id, lockDevId) {
+    return fitDeleteUnlockMethodForRuntime(resolveRuntimeFromExportThis(this), id, lockDevId);
+}
+export function getFitUnlockMethodList(params) {
+    return getFitUnlockMethodListForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function syncFitBindings() {
+    return syncFitBindingsForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function syncFitReport(ins) {
+    return syncFitReportForRuntime(resolveRuntimeFromExportThis(this), ins);
+}
+export function syncOpenModeRise(dpIds) {
+    return syncOpenModeRiseForRuntime(resolveRuntimeFromExportThis(this), dpIds);
+}
+export function getFitBleKeyList() {
+    return getFitBleKeyListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function addFitBleKey(params) {
+    return addFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function updateFitBleKey(params) {
+    return updateFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function removeFitBleKey(params) {
+    return removeFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params.id);
+}
+export function renameFitBleKey(params) {
+    return renameFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function getFitUsers() {
+    return getFitUsersForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function setFitSetting(dpCode, value) {
+    return setFitSettingForRuntime(resolveRuntimeFromExportThis(this), dpCode, value);
+}

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

@@ -0,0 +1,3 @@
+export * from "./binding";
+export * from "./device";
+export * from "./temp";

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

@@ -0,0 +1,3 @@
+export * from "./binding";
+export * from "./device";
+export * from "./temp";

package/lib/entries/fit/exports/temp.d.ts

@@ -0,0 +1,19 @@
+import { type AddFitTempPwdParams, type RemoveFitTempPwdParams, type RenameFitTempPwdParams, type UpdateFitTempPwdParams } from "../../../feature/fit/temp-password";
+export declare function getFitPasswordList(): Promise<{
+    id: number;
+    unlockId: string;
+    unlockName: string;
+    photoUnlock: boolean;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devLockId: string;
+    effective: import("../../..").EffectiveConfig;
+}[]>;
+export declare function addFitTempPwd(params: AddFitTempPwdParams): Promise<{
+    pwdId: number;
+}>;
+export declare function removeFitTempPwd(params: RemoveFitTempPwdParams): Promise<void>;
+export declare function updateFitTempPwd(params: UpdateFitTempPwdParams): Promise<void>;
+export declare function renameFitTempPwd(params: RenameFitTempPwdParams): Promise<void>;
+export type { AddFitTempPwdParams, RemoveFitTempPwdParams, UpdateFitTempPwdParams, RenameFitTempPwdParams, };

package/lib/entries/fit/exports/temp.js

@@ -0,0 +1,18 @@
+import { getFitPasswordListForRuntime } from "../../../feature/fit/password-list";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { fitAddTempPwdForRuntime, fitRemoveTempPwdForRuntime, fitRenameTempPwdForRuntime, fitUpdateTempPwdForRuntime, } from "../../../feature/fit/temp-password";
+export function getFitPasswordList() {
+    return getFitPasswordListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function addFitTempPwd(params) {
+    return fitAddTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function removeFitTempPwd(params) {
+    return fitRemoveTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function updateFitTempPwd(params) {
+    return fitUpdateTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function renameFitTempPwd(params) {
+    return fitRenameTempPwdForRuntime(resolveRuntimeFromExportThis(this), params);
+}

package/lib/entries/fit/index.d.ts

@@ -0,0 +1,8 @@
+import type { LockSDKOption } from "../../interface";
+import type { FitSDKInstance } from "./build-instance";
+export * from "./exports";
+export type { FitSDKInstance };
+export type { FitSdkBoundExportThis } from "./bootstrap/resolve-runtime-from-export-this";
+export declare const createFitSDK: (options?: Omit<LockSDKOption, "preFetch">) => Promise<FitSDKInstance>;
+export declare const initFit: (options?: LockSDKOption) => Promise<void>;
+export declare const destroyFit: () => void;

package/lib/entries/fit/index.js

@@ -0,0 +1,36 @@
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { bootstrapRegisteredFitInstance } from "./bootstrap/bootstrap-lock-instance";
+import { clearPrimaryFitSDKInstance, setPrimaryFitSDKInstance, } from "./bootstrap/primary-instance";
+import { clearAllRuntimes, listRegisteredRuntimes, } from "../../runtime/registry";
+import { getLaunchOptionsSync } from "../../platform/device";
+import { getError } from "../../utils/errors";
+export * from "./exports";
+export const createFitSDK = async (options) => {
+    const { instance } = await bootstrapRegisteredFitInstance({
+        ...options,
+        preFetch: false,
+    });
+    return instance;
+};
+export const initFit = async (options) => {
+    const opts = { ...options };
+    const { devInfo, deviceId } = opts;
+    if (!devInfo && !deviceId) {
+        const { query } = getLaunchOptionsSync();
+        opts.deviceId = query.deviceId;
+        if (!opts.deviceId) {
+            throw getError(1000);
+        }
+    }
+    const { instance } = await bootstrapRegisteredFitInstance(opts);
+    setPrimaryFitSDKInstance(instance);
+};
+export const destroyFit = () => {
+    removeEvents();
+    for (const rt of listRegisteredRuntimes()) {
+        clearStateForRuntime(rt);
+    }
+    clearAllRuntimes();
+    clearPrimaryFitSDKInstance();
+};

package/lib/entries/main/bootstrap/bootstrap-lock-instance.d.ts

@@ -0,0 +1,7 @@
+import type { LockSDKOption } from "../../../interface";
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { type LockSDKInstance } from "../build-instance";
+export declare function bootstrapRegisteredLockInstance(options?: LockSDKOption): Promise<{
+    runtime: LockDeviceRuntime;
+    instance: LockSDKInstance;
+}>;

package/lib/entries/main/bootstrap/bootstrap-lock-instance.js

@@ -0,0 +1,12 @@
+import { addEvents } from "../../../feature/state/platform-routing";
+import { initState } from "../../../feature/state/init-state";
+import { registerRuntime } from "../../../runtime/registry";
+import { buildLockSDKInstance, } from "../build-instance";
+import { createBootstrappedRuntime } from "./bootstrap";
+export async function bootstrapRegisteredLockInstance(options) {
+    const runtime = await createBootstrappedRuntime(options);
+    registerRuntime(runtime);
+    addEvents(runtime);
+    await initState(runtime);
+    return { runtime, instance: buildLockSDKInstance(runtime) };
+}

package/lib/entries/main/bootstrap/bootstrap.d.ts

@@ -0,0 +1,4 @@
+import type { LockSDKOption } from "../../../interface";
+import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function applyLockOptionsToRuntime(runtime: LockDeviceRuntime, options?: LockSDKOption): Promise<void>;
+export declare function createBootstrappedRuntime(options?: LockSDKOption): Promise<LockDeviceRuntime>;

package/lib/entries/main/bootstrap/bootstrap.js

@@ -0,0 +1,69 @@
+import dpCodes from "../../../config/dp-code";
+import { getCapabilities } from "../../../utils";
+import { getDeviceInfo, trackEvent, } from "../../../platform/device";
+import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import { sdkLog, setSDKLogConfig } from "../../../utils/sdk-log";
+export async function applyLockOptionsToRuntime(runtime, options) {
+    setSDKLogConfig({
+        level: options?.logLevel ?? "warn",
+        sink: options?.logger,
+        console: options?.logToConsole ?? false,
+    });
+    const { config } = runtime;
+    let { devInfo, deviceId } = options || {};
+    if (!devInfo && !deviceId) {
+        throw new Error("deviceId is required in lock sdk");
+    }
+    if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
+        devInfo = await getDeviceInfo(deviceId);
+    }
+    let dpSchema = {};
+    const codesById = {};
+    const idsByCode = {};
+    if (devInfo.schema) {
+        dpSchema = devInfo.schema.reduce((acc, cur) => {
+            acc[cur.code] = cur;
+            codesById[cur.id] = cur.code;
+            idsByCode[cur.code] = cur.id;
+            return acc;
+        }, {});
+    }
+    else if (devInfo.dpSchema) {
+        dpSchema = devInfo.dpSchema;
+        Object.keys(dpSchema).forEach((key) => {
+            const item = dpSchema[key];
+            codesById[item.id] = item.code;
+            idsByCode[item.code] = item.id;
+        });
+    }
+    config.strictMode = options?.strictMode ?? true;
+    config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
+    config.passwordSupportZero = options?.passwordSupportZero ?? true;
+    config.supportMultipleFace = options?.supportMultipleFace ?? false;
+    config.supportOfflineDps = options?.supportOfflineDps ?? false;
+    config.devInfo = devInfo;
+    config.dpSchema = dpSchema;
+    config.codesById = codesById;
+    config.idsByCode = idsByCode;
+    config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
+    config.preFetch = options?.preFetch ?? false;
+    config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
+    sdkLog("info", "bootstrap", "applyOptions", {
+        devId: config.devInfo.devId,
+        data: {
+            productId: config.devInfo.productId,
+            strictMode: config.strictMode,
+            supportOfflineDps: config.supportOfflineDps,
+            supportBigData: config.supportBigData,
+            communication: config.communication,
+        },
+    });
+    trackEvent("t$y_UztB3Lj9Qns375R0r7dA0L5Kr2VytH3J".replace("$", ""), {
+        pid: devInfo.productId,
+    });
+}
+export async function createBootstrappedRuntime(options) {
+    const runtime = new LockDeviceRuntime();
+    await applyLockOptionsToRuntime(runtime, options);
+    return runtime;
+}

package/lib/entries/main/bootstrap/lock-instance-runtime-ref.d.ts

@@ -0,0 +1,3 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function registerLockSDKInstanceRuntime(instance: object, runtime: LockDeviceRuntime): void;
+export declare function getRuntimeForLockSDKInstance(instance: object): LockDeviceRuntime | undefined;

package/lib/entries/main/bootstrap/lock-instance-runtime-ref.js

@@ -0,0 +1,7 @@
+const runtimeByInstance = new WeakMap();
+export function registerLockSDKInstanceRuntime(instance, runtime) {
+    runtimeByInstance.set(instance, runtime);
+}
+export function getRuntimeForLockSDKInstance(instance) {
+    return runtimeByInstance.get(instance);
+}

package/lib/entries/main/bootstrap/primary-instance.d.ts

@@ -0,0 +1,6 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { LockSDKInstance } from "../build-instance";
+export declare function setPrimaryLockSDKInstance(instance: LockSDKInstance): void;
+export declare function getPrimaryLockSDKRuntime(): LockDeviceRuntime | null;
+export declare function clearPrimaryLockSDKInstance(): void;
+export declare function clearPrimaryLockSDKInstanceIfDevId(devId: string): void;

package/lib/entries/main/bootstrap/primary-instance.js

@@ -0,0 +1,24 @@
+import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
+let primaryDevId = null;
+let primaryRuntime = null;
+export function setPrimaryLockSDKInstance(instance) {
+    const runtime = getRuntimeForLockSDKInstance(instance);
+    if (!runtime) {
+        throw new Error("setPrimaryLockSDKInstance: instance must be returned by createLockSDK or init");
+    }
+    primaryDevId = runtime.devId;
+    primaryRuntime = runtime;
+}
+export function getPrimaryLockSDKRuntime() {
+    return primaryRuntime;
+}
+export function clearPrimaryLockSDKInstance() {
+    primaryDevId = null;
+    primaryRuntime = null;
+}
+export function clearPrimaryLockSDKInstanceIfDevId(devId) {
+    if (primaryDevId === devId) {
+        primaryDevId = null;
+        primaryRuntime = null;
+    }
+}

package/lib/entries/main/bootstrap/resolve-runtime-from-export-this.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export type LockSdkBoundExportThis = {
+    devId: string;
+};
+export declare function resolveRuntimeFromExportThis(thisArg: unknown): LockDeviceRuntime;

package/lib/entries/main/bootstrap/resolve-runtime-from-export-this.js

@@ -0,0 +1,29 @@
+import { getRuntimeByDevId } from "../../../runtime/registry";
+import { getRuntimeForLockSDKInstance } from "./lock-instance-runtime-ref";
+import { resolveTopLevelTargetRuntime } from "./top-level-runtime";
+export function resolveRuntimeFromExportThis(thisArg) {
+    if (thisArg !== null &&
+        thisArg !== undefined &&
+        typeof thisArg === "object") {
+        const rtFromInstance = getRuntimeForLockSDKInstance(thisArg);
+        if (rtFromInstance) {
+            return rtFromInstance;
+        }
+    }
+    if (thisArg !== null &&
+        thisArg !== undefined &&
+        typeof thisArg === "object" &&
+        "devId" in thisArg &&
+        typeof thisArg.devId === "string") {
+        const devId = thisArg.devId;
+        if (devId.length === 0) {
+            throw new Error("Lock SDK: bound context devId must be non-empty");
+        }
+        const rt = getRuntimeByDevId(devId);
+        if (!rt) {
+            throw new Error(`Lock SDK: no registered runtime for devId "${devId}"; use createLockSDK or init first`);
+        }
+        return rt;
+    }
+    return resolveTopLevelTargetRuntime();
+}

package/lib/entries/main/bootstrap/top-level-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+export declare function resolveTopLevelTargetRuntime(): LockDeviceRuntime;

package/lib/entries/main/bootstrap/top-level-runtime.js

@@ -0,0 +1,9 @@
+import { getError } from "../../../utils/errors";
+import { getPrimaryLockSDKRuntime } from "./primary-instance";
+export function resolveTopLevelTargetRuntime() {
+    const primary = getPrimaryLockSDKRuntime();
+    if (!primary) {
+        throw getError(1071);
+    }
+    return primary;
+}

package/lib/entries/main/build-instance.d.ts

@@ -0,0 +1,7 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import * as DeviceExports from "./exports";
+export interface LockSDKInstance extends Omit<typeof DeviceExports, ""> {
+    destroy(): void;
+}
+export declare function getFlatInstanceMethodKeysForTests(): string[];
+export declare function buildLockSDKInstance(runtime: LockDeviceRuntime): LockSDKInstance;

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

@@ -0,0 +1,49 @@
+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 { sdkLog } from "../../utils/sdk-log";
+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() {
+            sdkLog("info", "lifecycle", "destroy", { devId: runtime.devId });
+            unregisterRuntime(runtime.devId);
+            clearPrimaryLockSDKInstanceIfDevId(runtime.devId);
+            clearStateForRuntime(runtime);
+            if (getRegisteredRuntimeCount() === 0) {
+                removeEvents();
+            }
+        },
+    };
+    registerLockSDKInstanceRuntime(instance, runtime);
+    sdkLog("info", "lifecycle", "createInstance", { devId: runtime.devId });
+    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/main/exports/accessory-binding.d.ts

@@ -0,0 +1 @@
+export * from "./fit";

package/lib/entries/main/exports/accessory-binding.js

@@ -0,0 +1 @@
+export * from "./fit";

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

@@ -0,0 +1,11 @@
+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>;
+interface PublishDpsOption {
+    timeout?: number;
+    checkReport?: (dps: Record<string, unknown>) => boolean | Record<string, unknown>;
+}
+export declare function publishDps(dpData: Record<string, DpValue>, option?: PublishDpsOption): Promise<Record<string, DpValue>>;
+export {};

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

@@ -0,0 +1,8 @@
+import { BoundFitLockItem, UnbindFitItem } from "../../../api/fit";
+export type { BoundFitLockItem, UnbindFitItem };
+export declare function bindFitToLock(fit: UnbindFitItem): Promise<unknown>;
+export declare function unbindFitToLock(fit: BoundFitLockItem & {
+    bindingId: string;
+}): Promise<unknown>;
+export declare function getBoundFitList(): Promise<BoundFitLockItem[]>;
+export declare function getUnbindFitList(): Promise<UnbindFitItem[]>;

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

@@ -0,0 +1,14 @@
+import { bindFitToLockForRuntime, getBoundFitListForRuntime, getUnbindFitListForRuntime, unbindFitToLockForRuntime, } from "../../../feature/fit/bind-fit-to-lock";
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+export function bindFitToLock(fit) {
+    return bindFitToLockForRuntime(resolveRuntimeFromExportThis(this), fit);
+}
+export function unbindFitToLock(fit) {
+    return unbindFitToLockForRuntime(resolveRuntimeFromExportThis(this), fit);
+}
+export function getBoundFitList() {
+    return getBoundFitListForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getUnbindFitList() {
+    return getUnbindFitListForRuntime(resolveRuntimeFromExportThis(this));
+}

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

@@ -0,0 +1,20 @@
+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 "./voice-file";
+export * from "./linkage";
+export * from "./capability";
+export * from "./accessory-binding";
+export * from "./screen/list";
+export * from "./screen/bind";

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

@@ -0,0 +1,20 @@
+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 "./voice-file";
+export * from "./linkage";
+export * from "./capability";
+export * from "./accessory-binding";
+export * from "./screen/list";
+export * from "./screen/bind";

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

@@ -0,0 +1,10 @@
+import { GetLogsParams, GetAlarmsParams, GetAlbumsParams, GetLockLogListParams } 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>;
+export declare function getLockLogList(params: GetLockLogListParams): Promise<import("../../../feature/log/log").GetLockLogListResult>;

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,6 @@
+import { GetMediaUrlParams, OpenLocalAlbumParams } 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>;