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

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

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

package/lib/entries/screen/index.js

@@ -0,0 +1,36 @@
+import { clearStateForRuntime } from "../../feature/state/clear";
+import { removeEvents } from "../../feature/state/platform-routing";
+import { bootstrapRegisteredScreenInstance } from "./bootstrap/bootstrap-lock-instance";
+import { clearPrimaryScreenSDKInstance, setPrimaryScreenSDKInstance, } 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 createScreenSDK = async (options) => {
+    const { instance } = await bootstrapRegisteredScreenInstance({
+        ...options,
+        preFetch: false,
+    });
+    return instance;
+};
+export const initScreen = 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 bootstrapRegisteredScreenInstance(opts);
+    setPrimaryScreenSDKInstance(instance);
+};
+export const destroyScreen = () => {
+    removeEvents();
+    for (const rt of listRegisteredRuntimes()) {
+        clearStateForRuntime(rt);
+    }
+    clearAllRuntimes();
+    clearPrimaryScreenSDKInstance();
+};

package/lib/feature/dp/get-dp-value.d.ts

@@ -0,0 +1,3 @@
+import type { DpValue } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getDpValueForRuntime(runtime: LockDeviceRuntime, code: string): DpValue | undefined;

package/lib/feature/dp/get-dp-value.js

@@ -0,0 +1,3 @@
+export function getDpValueForRuntime(runtime, code) {
+    return runtime.cache.dpState[code];
+}

package/lib/feature/dp/has-dp.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const hasDpForRuntime: (runtime: LockDeviceRuntime, dpCode: string) => boolean;

package/lib/feature/dp/has-dp.js

@@ -0,0 +1 @@
+export const hasDpForRuntime = (runtime, dpCode) => !!runtime.config.dpSchema[dpCode];

package/lib/feature/dp/publish-dps.d.ts

@@ -0,0 +1,7 @@
+import type { DpValue } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const publishDpsOnlyWithRuntime: (runtime: LockDeviceRuntime, dpData: Record<string, string | number | boolean>) => Promise<void>;
+export declare const publishDpsForRuntime: (runtime: LockDeviceRuntime, dpData: Record<string, DpValue>, option?: {
+    timeout?: number;
+    checkReport?: (dps: Record<string, unknown>) => boolean | Record<string, unknown>;
+}) => Promise<Record<string, DpValue>>;

package/lib/feature/dp/publish-dps.js

@@ -0,0 +1,155 @@
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { isOnlineByType } from "../../utils";
+import { isYuDeviceOnlineSync, publishDeviceDps } from "../../platform";
+import { sdkLog } from "../../utils/sdk-log";
+export const publishDpsOnlyWithRuntime = async (runtime, dpData) => {
+    if (runtime.deviceStatus.type === "offline") {
+        const error = getError(1001);
+        sdkLog("warn", "dp", "publishOffline", {
+            devId: runtime.devId,
+            data: { codes: Object.keys(dpData) },
+            error,
+        });
+        throw error;
+    }
+    const option = {};
+    if (runtime.deviceStatus.isWifiMatter &&
+        runtime.deviceStatus.onlineTypes.includes("cloud")) {
+        option.pipelines = [1];
+    }
+    if (isOnlineByType(runtime.config.onlineType, 2)) {
+        if (runtime.cache.deviceAdvanceAbilityCache?.yuChannel.support) {
+            const isYuOnline = isYuDeviceOnlineSync(runtime.config.devInfo.devId);
+            option.pipelines = [isYuOnline ? 12 : 3];
+        }
+        else {
+            option.pipelines = [3];
+        }
+    }
+    const { devInfo: { devId }, idsByCode, } = runtime.config;
+    const dps = Object.keys(dpData).reduce((acc, key) => {
+        const id = idsByCode[key];
+        if (id) {
+            acc[id] = dpData[key];
+        }
+        return acc;
+    }, {});
+    if (Object.keys(dps).length > 0) {
+        const startedAt = Date.now();
+        sdkLog("info", "dp", "publish", {
+            devId,
+            data: {
+                codes: Object.keys(dpData),
+                pipelines: option.pipelines,
+            },
+        });
+        try {
+            await publishDeviceDps({
+                deviceId: devId,
+                dps,
+                ...option,
+            });
+            sdkLog("debug", "dp", "publishSuccess", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    pipelines: option.pipelines,
+                },
+            });
+        }
+        catch (error) {
+            sdkLog("error", "dp", "publishFail", {
+                devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    pipelines: option.pipelines,
+                },
+                error,
+            });
+            throw error;
+        }
+    }
+};
+export const publishDpsForRuntime = async (runtime, dpData, option) => {
+    const { timeout = 15000, checkReport } = option || {};
+    const startedAt = Date.now();
+    return new Promise((resolve, reject) => {
+        const codes = Object.keys(dpData);
+        const result = {};
+        const handleChangeDp = (dpCodes) => {
+            if (checkReport) {
+                const pass = checkReport(dpCodes);
+                if (pass) {
+                    emitter.off(DPCHANGE, handleChangeDp);
+                    clearTimeout(timer);
+                    sdkLog("debug", "dp", "reportMatched", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: {
+                            codes: Object.keys(dpData),
+                            reportCodes: Object.keys(dpCodes),
+                        },
+                    });
+                    resolve(typeof pass !== "boolean"
+                        ? pass
+                        : dpCodes);
+                }
+            }
+            else {
+                Object.keys(dpCodes).forEach((code) => {
+                    const eixst = codes.indexOf(code);
+                    if (eixst > -1) {
+                        codes.splice(eixst, 1)[0];
+                        result[code] = dpCodes[code];
+                    }
+                });
+                if (codes.length === 0) {
+                    emitter.off(DPCHANGE, handleChangeDp);
+                    clearTimeout(timer);
+                    sdkLog("debug", "dp", "reportMatched", {
+                        devId: runtime.devId,
+                        duration: Date.now() - startedAt,
+                        data: {
+                            codes: Object.keys(dpData),
+                            reportCodes: Object.keys(dpCodes),
+                        },
+                    });
+                    resolve(result);
+                }
+            }
+        };
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            const error = getError(1002);
+            sdkLog("warn", "dp", "reportTimeout", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    timeout,
+                },
+                error,
+            });
+            reject(error);
+        }, timeout);
+        emitter.on(DPCHANGE, handleChangeDp);
+        publishDpsOnlyWithRuntime(runtime, dpData).catch((e) => {
+            emitter.off(DPCHANGE, handleChangeDp);
+            clearTimeout(timer);
+            reject(e);
+            sdkLog("error", "dp", "publishDps", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: {
+                    codes: Object.keys(dpData),
+                    timeout,
+                },
+                error: e,
+            });
+        });
+    });
+};

package/lib/feature/fit/bind-fit-to-lock.d.ts

@@ -0,0 +1,6 @@
+import { type BoundFitLockItem, type LockFitItemBase } from "../../api/fit";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getBoundFitListForRuntime(runtime: LockDeviceRuntime): Promise<BoundFitLockItem[]>;
+export declare function getUnbindFitListForRuntime(runtime: LockDeviceRuntime): Promise<import("../../api/fit").UnbindFitItem[]>;
+export declare function bindFitToLockForRuntime(runtime: LockDeviceRuntime, fit: LockFitItemBase): Promise<unknown>;
+export declare function unbindFitToLockForRuntime(runtime: LockDeviceRuntime, fit: BoundFitLockItem): Promise<unknown>;

package/lib/feature/fit/bind-fit-to-lock.js

@@ -0,0 +1,222 @@
+import { bindLockAndFit, getBoundFitListApi, getUnbindFitListApi, unbindFitFromLockCloud, unbindLockFromFitCloud, } from "../../api/fit";
+import { getUsersSyncLockData } from "../../api/user";
+import dpCodes from "../../config/dp-code";
+import { getBLEOnlineState } from "../../platform/device";
+import { DPCHANGE } from "../../utils/constant";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+import { FIT_BIND_TIMEOUT_MS, FIT_OPERATION_CODE, normalizeHex, buildLockCheckCodeTemplate, publishFitTransparentFlow, } from "./shared";
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export async function getBoundFitListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getBoundFitListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getBoundFitListApi(runtime.devId);
+    sdkLog("info", "fit", "getBoundFitListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+export async function getUnbindFitListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "getUnbindFitListStart", {
+        devId: runtime.devId,
+    });
+    const list = await getUnbindFitListApi(runtime.devId);
+    sdkLog("info", "fit", "getUnbindFitListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: Array.isArray(list) ? list.length : 0 },
+    });
+    return list;
+}
+function parseLockCheckCodeReport(raw) {
+    const hex = normalizeHex(raw).toLowerCase();
+    if (hex.length < 32) {
+        throw getError(1051);
+    }
+    return {
+        operation: hex.slice(24, 26),
+        targetMasterId: hex.slice(26, 30),
+        result: hex.slice(30, 32),
+    };
+}
+function waitLockCheckCodeResult(params) {
+    const { expectedOperation, timeout = FIT_BIND_TIMEOUT_MS } = params;
+    return new Promise((resolve, reject) => {
+        const onDp = (dps) => {
+            const raw = dps[dpCodes.checkCodeSet];
+            if (typeof raw !== "string") {
+                return;
+            }
+            let report;
+            try {
+                report = parseLockCheckCodeReport(raw);
+            }
+            catch {
+                return;
+            }
+            if (report.operation !== expectedOperation) {
+                return;
+            }
+            if (report.result === "00" && report.targetMasterId !== "ffff") {
+                clearTimeout(timer);
+                emitter.off(DPCHANGE, onDp);
+                resolve();
+                return;
+            }
+            clearTimeout(timer);
+            emitter.off(DPCHANGE, onDp);
+            reject(getError(1004));
+        };
+        const timer = setTimeout(() => {
+            emitter.off(DPCHANGE, onDp);
+            reject(getError(1002));
+        }, timeout);
+        emitter.on(DPCHANGE, onDp);
+    });
+}
+async function publishFitTransparent(runtime, operation, fit) {
+    sdkLog("info", "fit", "publishTransparentStart", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+    if (!(await getBLEOnlineState(fit.fittingId)) && fit.online) {
+        const error = getError(1013);
+        sdkLog("warn", "fit", "publishTransparentOffline", {
+            devId: runtime.devId,
+            data: { operation, fittingId: fit.fittingId },
+            error,
+        });
+        throw error;
+    }
+    await publishFitTransparentFlow(fit.fittingId, runtime.devId, operation, fit);
+    sdkLog("info", "fit", "publishTransparentSuccess", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+}
+async function publishLockCheckCode(runtime, operation, fit) {
+    sdkLog("info", "fit", "publishLockCheckCodeStart", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+    const { lockRandom } = await getUsersSyncLockData(runtime.devId);
+    const template = buildLockCheckCodeTemplate(operation, fit);
+    const payload = `${template.slice(0, 8)}${lockRandom.ins}${template.slice(8)}`;
+    const waitResult = waitLockCheckCodeResult({
+        expectedOperation: FIT_OPERATION_CODE[operation],
+    });
+    if (lockRandom.distributed) {
+        await delay(1000);
+        await publishDpsOnlyWithRuntime(runtime, {
+            [dpCodes.checkCodeSet]: lockRandom.wakeUpIns,
+        });
+        await delay(1000);
+    }
+    await publishDpsOnlyWithRuntime(runtime, {
+        [dpCodes.checkCodeSet]: payload,
+    });
+    await waitResult;
+    sdkLog("info", "fit", "publishLockCheckCodeSuccess", {
+        devId: runtime.devId,
+        data: { operation, fittingId: fit.fittingId },
+    });
+}
+export async function bindFitToLockForRuntime(runtime, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "bindFitToLockStart", {
+        devId: runtime.devId,
+        data: { fittingId: fit.fittingId },
+    });
+    try {
+        await publishFitTransparent(runtime, "bind", fit);
+        await bindLockAndFit({
+            devId: runtime.devId,
+            fittingId: fit.fittingId,
+            stage: 1,
+        });
+        sdkLog("info", "fit", "bindFitToLockStage1Success", {
+            devId: runtime.devId,
+            data: { fittingId: fit.fittingId },
+        });
+        await publishLockCheckCode(runtime, "bind", fit);
+        const result = await bindLockAndFit({
+            devId: runtime.devId,
+            fittingId: fit.fittingId,
+            stage: 2,
+        });
+        sdkLog("info", "fit", "bindFitToLockSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "bindFitToLockFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId },
+            error,
+        });
+        throw error;
+    }
+}
+export async function unbindFitToLockForRuntime(runtime, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "unbindFitToLockStart", {
+        devId: runtime.devId,
+        data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+    });
+    try {
+        const fitBleOnline = await getBLEOnlineState(fit.fittingId);
+        if (fitBleOnline) {
+            await publishFitTransparent(runtime, "unbind", fit);
+            await unbindLockFromFitCloud({
+                fittingId: fit.fittingId,
+                bindingId: fit.bindingId,
+            });
+            sdkLog("info", "fit", "unbindFitToLockStage1Success", {
+                devId: runtime.devId,
+                data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            });
+        }
+        else if (fit.online) {
+            throw getError(1013);
+        }
+        else {
+            sdkLog("info", "fit", "unbindFitToLockSkipFitBle", {
+                devId: runtime.devId,
+                data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            });
+        }
+        await publishLockCheckCode(runtime, "unbind", fit);
+        const result = await unbindFitFromLockCloud({
+            devId: runtime.devId,
+            bindingId: fit.bindingId,
+        });
+        sdkLog("info", "fit", "unbindFitToLockSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "unbindFitToLockFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { fittingId: fit.fittingId, bindingId: fit.bindingId },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/fit/bind-lock-to-fit.d.ts

@@ -0,0 +1,4 @@
+import { BoundFitLockItem, LockFitItemBase } from "../../api/fit";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function bindLockToFitForRuntime(runtime: LockDeviceRuntime, lock: LockFitItemBase): Promise<unknown>;
+export declare function unbindLockToFitForRuntime(runtime: LockDeviceRuntime, lock: BoundFitLockItem): Promise<unknown>;

package/lib/feature/fit/bind-lock-to-fit.js

@@ -0,0 +1,167 @@
+import { bindLockAndFit, unbindFitFromLockCloud, unbindLockFromFitCloud, } from "../../api/fit";
+import { getUsersSyncLockData } from "../../api/user";
+import { offDpDataChange, onDpDataChange, publishDeviceDps, } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { FIT_BIND_TIMEOUT_MS, FIT_OPERATION_CODE, normalizeHex, buildLockCheckCodeTemplate, publishFitTransparentFlow, } from "./shared";
+const CHECK_CODE_SET_DP_ID = "70";
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+async function publishToFitting(runtime, operation, lock) {
+    sdkLog("info", "fit", "publishToFittingStart", {
+        devId: runtime.devId,
+        data: { operation, lockDevId: lock.devId },
+    });
+    await publishFitTransparentFlow(runtime.devId, lock.devId, operation, lock);
+    sdkLog("info", "fit", "publishToFittingSuccess", {
+        devId: runtime.devId,
+        data: { operation, lockDevId: lock.devId },
+    });
+}
+function waitLockCheckCodeResult(params) {
+    const { lockDevId, expectedOperation, timeout = FIT_BIND_TIMEOUT_MS, } = params;
+    return new Promise((resolve, reject) => {
+        const onDp = ({ deviceId, dps, }) => {
+            try {
+                if (deviceId !== lockDevId) {
+                    return;
+                }
+                const raw = dps[CHECK_CODE_SET_DP_ID];
+                if (typeof raw !== "string" || raw.length < 32) {
+                    return;
+                }
+                const hex = normalizeHex(raw).toLowerCase();
+                const operation = hex.slice(24, 26);
+                if (operation !== expectedOperation) {
+                    return;
+                }
+                const targetMasterId = hex.slice(26, 30);
+                const result = hex.slice(30, 32);
+                clearTimeout(timer);
+                offDpDataChange(onDp);
+                if (result === "00" && targetMasterId !== "ffff") {
+                    resolve();
+                    return;
+                }
+                reject(getError(1004));
+            }
+            catch (error) {
+                sdkLog("error", "platform", "dpDataChangeError", { error });
+            }
+        };
+        const timer = setTimeout(() => {
+            offDpDataChange(onDp);
+            reject(getError(1002));
+        }, timeout);
+        onDpDataChange(onDp);
+    });
+}
+async function publishToLock(runtime, operation, lock) {
+    sdkLog("info", "fit", "publishToLockStart", {
+        devId: runtime.devId,
+        data: { operation, lockDevId: lock.devId },
+    });
+    const { lockRandom } = await getUsersSyncLockData(lock.devId);
+    const template = buildLockCheckCodeTemplate(operation, lock);
+    const payload = `${template.slice(0, 8)}${lockRandom.ins}${template.slice(8)}`;
+    const waitResult = waitLockCheckCodeResult({
+        lockDevId: lock.devId,
+        expectedOperation: FIT_OPERATION_CODE[operation],
+    });
+    if (lockRandom.distributed) {
+        await delay(1000);
+        await publishDeviceDps({
+            deviceId: lock.devId,
+            dps: { [CHECK_CODE_SET_DP_ID]: lockRandom.wakeUpIns },
+        });
+        await delay(1000);
+    }
+    await publishDeviceDps({
+        deviceId: lock.devId,
+        dps: { [CHECK_CODE_SET_DP_ID]: payload },
+    });
+    await waitResult;
+    sdkLog("info", "fit", "publishToLockSuccess", {
+        devId: runtime.devId,
+        data: { operation, lockDevId: lock.devId },
+    });
+}
+export async function bindLockToFitForRuntime(runtime, lock) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "bindLockToFitStart", {
+        devId: runtime.devId,
+        data: { lockDevId: lock.devId },
+    });
+    try {
+        await publishToFitting(runtime, "bind", lock);
+        await bindLockAndFit({
+            devId: lock.devId,
+            fittingId: runtime.devId,
+            stage: 1,
+        });
+        sdkLog("info", "fit", "bindLockToFitStage1Success", {
+            devId: runtime.devId,
+            data: { lockDevId: lock.devId },
+        });
+        await publishToLock(runtime, "bind", lock);
+        const result = await bindLockAndFit({
+            devId: lock.devId,
+            fittingId: runtime.devId,
+            stage: 2,
+        });
+        sdkLog("info", "fit", "bindLockToFitSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "bindLockToFitFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId },
+            error,
+        });
+        throw error;
+    }
+}
+export async function unbindLockToFitForRuntime(runtime, lock) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "unbindLockToFitStart", {
+        devId: runtime.devId,
+        data: { lockDevId: lock.devId, bindingId: lock.bindingId },
+    });
+    try {
+        await publishToFitting(runtime, "unbind", lock);
+        await unbindLockFromFitCloud({
+            fittingId: runtime.devId,
+            bindingId: lock.bindingId,
+        });
+        sdkLog("info", "fit", "unbindLockToFitStage1Success", {
+            devId: runtime.devId,
+            data: { lockDevId: lock.devId, bindingId: lock.bindingId },
+        });
+        await publishToLock(runtime, "unbind", lock);
+        const result = await unbindFitFromLockCloud({
+            devId: lock.devId,
+            bindingId: lock.bindingId,
+        });
+        sdkLog("info", "fit", "unbindLockToFitSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId, bindingId: lock.bindingId },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "unbindLockToFitFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId: lock.devId, bindingId: lock.bindingId },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/fit/ble-key.d.ts

@@ -0,0 +1,16 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { EffectiveConfig } from "../../interface";
+export declare function getFitBleKeyListForRuntime(runtime: LockDeviceRuntime): Promise<unknown[]>;
+export declare function addFitBleKeyForRuntime(runtime: LockDeviceRuntime, params: Record<string, unknown>): Promise<unknown>;
+export interface UpdateFitBleKeyParams {
+    id: string;
+    name: string;
+    effective: EffectiveConfig;
+}
+export declare function updateFitBleKeyForRuntime(runtime: LockDeviceRuntime, params: UpdateFitBleKeyParams): Promise<unknown>;
+export declare function removeFitBleKeyForRuntime(runtime: LockDeviceRuntime, unlockBindingId: string): Promise<unknown>;
+export interface RenameFitBleKeyParams {
+    id: string;
+    name: string;
+}
+export declare function renameFitBleKeyForRuntime(runtime: LockDeviceRuntime, params: RenameFitBleKeyParams): Promise<unknown>;