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

package/lib/feature/password/temporary/wifi-online.js

@@ -0,0 +1,153 @@
+import { createOnlineUnlimited, getTempOnlineUnlimitedListAPI, removeTempOnlineUnlimitedAPI, } from "../../../api/temp";
+import { formatWeek, parseWeek, validateEffectiveConfig } from "../../../utils";
+import { LoopTypes } from "../../../utils/constant";
+import { encrypt } from "../../../platform/device";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { PASSWORD_REGEX } from "./internal/password-helpers";
+import { sdkLog } from "../../../utils/sdk-log";
+const onLinePasswordStatusMap = {
+    1: "effective",
+    2: "synchronizing",
+    3: "expired",
+    4: "disabled",
+    5: "invalid",
+};
+export async function saveTempOnlineUnlimitedForRuntime(rt, params) {
+    const { password, name, effective, phone, countryCode } = params;
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "saveOnlineUnlimitedStart", {
+        devId: rt.devId,
+        data: {
+            hasName: typeof name === "string",
+            hasPhone: typeof phone === "string",
+            hasCountryCode: typeof countryCode === "string",
+            repeat: effective?.repeat,
+        },
+    });
+    if (!PASSWORD_REGEX.test(password)) {
+        const error = getError(1030);
+        sdkLog("warn", "tempPassword", "saveOnlineUnlimitedInvalidPassword", {
+            devId: rt.devId,
+            error,
+        });
+        throw error;
+    }
+    if (name && name.length > 20) {
+        const error = getError(1031);
+        sdkLog("warn", "tempPassword", "saveOnlineUnlimitedInvalidName", {
+            devId: rt.devId,
+            data: { nameLength: name.length },
+            error,
+        });
+        throw error;
+    }
+    validateEffectiveConfig(effective);
+    const { effectiveTime = 0, expiredTime = 1439 } = effective;
+    const aesPwd = await encrypt(rt.config.devInfo.devId, password);
+    const loopType = effective?.repeat
+        ?
+            LoopTypes[effective?.repeat?.toUpperCase()]
+        : LoopTypes.NONE;
+    const schedule = [
+        {
+            allDay: loopType === LoopTypes.NONE,
+            effectiveTime,
+            invalidTime: expiredTime,
+            workingDay: formatWeek(effective?.weeks ?? [0]),
+        },
+    ];
+    try {
+        const res = await createOnlineUnlimited({
+            devId: rt.config.devInfo.devId,
+            effectiveTime: effective.effectiveDate,
+            invalidTime: effective.expiredDate,
+            name: name,
+            password: aesPwd,
+            schedule,
+            availTime: 0,
+            phone,
+            countryCode,
+        });
+        sdkLog("info", "tempPassword", "saveOnlineUnlimitedSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+        return {
+            type: "custom",
+            name: res.name,
+            pwdId: res.pwdId,
+            effectiveConfig: effective,
+        };
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "saveOnlineUnlimitedFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function removeTempOnlineUnlimitedForRuntime(rt, id) {
+    const startedAt = Date.now();
+    sdkLog("info", "tempPassword", "removeOnlineUnlimitedStart", {
+        devId: rt.devId,
+        data: { hasId: !!id },
+    });
+    try {
+        await removeTempOnlineUnlimitedAPI({
+            devId: rt.config.devInfo.devId,
+            id,
+        });
+        sdkLog("info", "tempPassword", "removeOnlineUnlimitedSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+        });
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "removeOnlineUnlimitedFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export async function getTempOnlineUnlimitedListForRuntime(rt) {
+    const startedAt = Date.now();
+    try {
+        const pswList = await getTempOnlineUnlimitedListAPI(rt.config.devInfo.devId);
+        const newPswList = pswList?.map(({ effective, effectiveTime, invalidTime, scheduleDetails, ...rest }) => {
+            const status = onLinePasswordStatusMap[effective];
+            const effectiveConfig = {
+                effectiveDate: effectiveTime,
+                expiredDate: invalidTime,
+            };
+            if (scheduleDetails?.length) {
+                const scheduleDetail = scheduleDetails[0];
+                effectiveConfig.repeat =
+                    scheduleDetail.allDay === false ? "week" : "none";
+                if (effectiveConfig.repeat === "week") {
+                    effectiveConfig.weeks = parseWeek(scheduleDetail.workingDay);
+                    effectiveConfig.effectiveTime = scheduleDetail.effectiveTime;
+                    effectiveConfig.expiredTime = scheduleDetail.invalidTime;
+                }
+            }
+            return { ...rest, status, effectiveConfig };
+        });
+        sdkLog("debug", "tempPassword", "getOnlineUnlimitedListSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { count: newPswList?.length ?? 0 },
+        });
+        return newPswList;
+    }
+    catch (error) {
+        sdkLog("error", "tempPassword", "getOnlineUnlimitedListFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}

package/lib/feature/screen/bind-watch.d.ts

@@ -0,0 +1,18 @@
+import { type BindingResult } from "../../api/screen";
+import type { ErrorData } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface BindLockToScreenEvent {
+    lockDevId: string;
+    success: boolean;
+    data?: BindingResult;
+    error?: ErrorData;
+}
+export type BindLockToScreenListener = (event: BindLockToScreenEvent) => void;
+export declare function emitBindResult(runtime: LockDeviceRuntime, event: BindLockToScreenEvent): void;
+export declare function onBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function offBindLockToScreenForRuntime(runtime: LockDeviceRuntime, listener: BindLockToScreenListener): void;
+export declare function watchBindResult(runtime: LockDeviceRuntime, params: {
+    lockDevId: string;
+    sessionId: string;
+}): Promise<void>;
+export declare function isWatchingBind(runtime: LockDeviceRuntime, sessionId: string): boolean;

package/lib/feature/screen/bind-watch.js

@@ -0,0 +1,92 @@
+import { getBindingResultApi } from "../../api/screen";
+import emitter from "../../utils/event";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { handleScreenCloudError } from "./error";
+const POLL_INTERVAL_MS = 2_000;
+const BIND_POLL_TIMEOUT_MS = 30_000;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+function bindResultEventName(runtime) {
+    return `screen_bind_result_${runtime.devId}`;
+}
+export function emitBindResult(runtime, event) {
+    emitter.emit(bindResultEventName(runtime), event);
+}
+const watchKey = (runtime, sessionId) => `${runtime.devId}:${sessionId}`;
+const inflight = new Map();
+export function onBindLockToScreenForRuntime(runtime, listener) {
+    emitter.on(bindResultEventName(runtime), listener);
+}
+export function offBindLockToScreenForRuntime(runtime, listener) {
+    emitter.off(bindResultEventName(runtime), listener);
+}
+async function pollBindResult(runtime, lockDevId, sessionId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    const deadline = startedAt + BIND_POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await delay(POLL_INTERVAL_MS);
+        let result;
+        try {
+            result = await getBindingResultApi({ accessoryDevId, sessionId });
+        }
+        catch (e) {
+            const error = handleScreenCloudError(e);
+            sdkLog("error", "screen", "bindResultPollError", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId },
+                error: e,
+            });
+            emitBindResult(runtime, { lockDevId, success: false, error });
+            return;
+        }
+        if (result.status === "binding") {
+            continue;
+        }
+        if (result.status === "bound") {
+            sdkLog("info", "screen", "bindResultSettled", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+            });
+            emitBindResult(runtime, { lockDevId, success: true, data: result });
+            return;
+        }
+        sdkLog("info", "screen", "bindResultSettled", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId, status: result.status, lanStatus: result.lanStatus },
+        });
+        emitBindResult(runtime, {
+            lockDevId,
+            success: false,
+            data: result,
+            error: getError(1103),
+        });
+        return;
+    }
+    sdkLog("warn", "screen", "bindResultTimeout", {
+        devId: accessoryDevId,
+        duration: Date.now() - startedAt,
+        data: { lockDevId },
+    });
+    emitBindResult(runtime, { lockDevId, success: false, error: getError(1002) });
+}
+export function watchBindResult(runtime, params) {
+    const key = watchKey(runtime, params.sessionId);
+    const existing = inflight.get(key);
+    if (existing) {
+        return existing;
+    }
+    const task = pollBindResult(runtime, params.lockDevId, params.sessionId).finally(() => {
+        inflight.delete(key);
+    });
+    inflight.set(key, task);
+    return task;
+}
+export function isWatchingBind(runtime, sessionId) {
+    return inflight.has(watchKey(runtime, sessionId));
+}

package/lib/feature/screen/bind.d.ts

@@ -0,0 +1,4 @@
+import { type AddBindingResult, type UnbindingResult } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function bindLockForRuntime(runtime: LockDeviceRuntime, lockDevId: string): Promise<AddBindingResult>;
+export declare function unbindLockForRuntime(runtime: LockDeviceRuntime, relationId: string): Promise<UnbindingResult>;

package/lib/feature/screen/bind.js

@@ -0,0 +1,151 @@
+import { addBindingApi, deleteBindingApi, getUnbindingResultApi, } from "../../api/screen";
+import { getDeviceInfo } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+import { getDeviceStatusForRuntime } from "../state/device-status";
+import { handleScreenCloudError } from "./error";
+import { watchBindResult } from "./bind-watch";
+const POLL_INTERVAL_MS = 2_000;
+const UNBIND_POLL_TIMEOUT_MS = 20_000;
+const delay = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export async function bindLockForRuntime(runtime, lockDevId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "bindStart", {
+        devId: accessoryDevId,
+        data: { lockDevId },
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(runtime);
+        if (deviceStatus.type !== "online") {
+            sdkLog("warn", "screen", "bindAccessoryOffline", {
+                devId: accessoryDevId,
+                data: { lockDevId },
+            });
+            throw getError(1001);
+        }
+        const lockInfo = await getDeviceInfo(lockDevId);
+        if (!lockInfo?.isOnline) {
+            sdkLog("warn", "screen", "bindLockOffline", {
+                devId: accessoryDevId,
+                data: { lockDevId },
+            });
+            throw getError(1001);
+        }
+        let sessionData;
+        try {
+            sessionData = await addBindingApi({
+                accessoryDevId,
+                lockDevId,
+            });
+            sdkLog("info", "screen", "bindAddSuccess", {
+                devId: accessoryDevId,
+                duration: Date.now() - startedAt,
+                data: { lockDevId, relationId: sessionData.relationId },
+            });
+        }
+        catch (e) {
+            throw handleScreenCloudError(e);
+        }
+        void watchBindResult(runtime, {
+            lockDevId,
+            sessionId: sessionData.sessionId,
+        }).catch(() => { });
+        return sessionData;
+    }
+    catch (error) {
+        sdkLog("error", "screen", "bindFail", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { lockDevId },
+            error,
+        });
+        throw error;
+    }
+}
+export async function unbindLockForRuntime(runtime, relationId) {
+    const accessoryDevId = runtime.devId;
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "unbindStart", {
+        devId: accessoryDevId,
+        data: { relationId },
+    });
+    try {
+        const deviceStatus = getDeviceStatusForRuntime(runtime);
+        if (deviceStatus.type !== "online") {
+            sdkLog("warn", "screen", "unbindAccessoryOffline", {
+                devId: accessoryDevId,
+                data: { relationId },
+            });
+            throw getError(1001);
+        }
+        try {
+            await deleteBindingApi({ accessoryDevId, relationId });
+            sdkLog("info", "screen", "unbindDeleteSuccess", {
+                devId: accessoryDevId,
+                data: { relationId },
+            });
+        }
+        catch (e) {
+            if (e.innerError) {
+                switch (e.innerError.errorCode) {
+                    case "RELATION_NOT_FOUND":
+                    case "RELATION_CONFLICT":
+                        return {
+                            relationId,
+                            status: "unbound",
+                        };
+                    default:
+                }
+            }
+            throw handleScreenCloudError(e);
+        }
+        const deadline = Date.now() + UNBIND_POLL_TIMEOUT_MS;
+        let last;
+        while (Date.now() < deadline) {
+            await delay(POLL_INTERVAL_MS);
+            try {
+                last = await getUnbindingResultApi({ accessoryDevId, relationId });
+            }
+            catch (e) {
+                if (e.innerError) {
+                    switch (e.innerError.errorCode) {
+                        case "RELATION_NOT_FOUND":
+                        case "RELATION_CONFLICT":
+                            return {
+                                relationId,
+                                status: "unbound",
+                            };
+                        default:
+                    }
+                }
+                throw handleScreenCloudError(e);
+            }
+            if (last.status === "unbound") {
+                sdkLog("info", "screen", "unbindSettled", {
+                    devId: accessoryDevId,
+                    duration: Date.now() - startedAt,
+                    data: { relationId, status: last.status },
+                });
+                return last;
+            }
+        }
+        sdkLog("warn", "screen", "unbindTimeout", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { relationId },
+        });
+        throw getError(1002);
+    }
+    catch (error) {
+        sdkLog("error", "screen", "unbindFail", {
+            devId: accessoryDevId,
+            duration: Date.now() - startedAt,
+            data: { relationId },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/screen/error.d.ts

@@ -0,0 +1 @@
+export declare const handleScreenCloudError: (error: any) => any;

package/lib/feature/screen/error.js

@@ -0,0 +1,34 @@
+import { getError } from "../../utils/errors";
+export const handleScreenCloudError = (error) => {
+    if (error.innerError) {
+        switch (error.innerError.errorCode) {
+            case "USER_NOT_ADMIN_IN_GROUP":
+                return getError(1093);
+            case "USER_NOT_IN_GROUP":
+                return getError(1094);
+            case "ACCESSORY_NOT_FOUND":
+                return getError(1086);
+            case "LOCK_NOT_FOUND":
+                return getError(1095);
+            case "DEVICE_NOT_SAME_HOME":
+                return getError(1096);
+            case "ACCESSORY_OFFLINE":
+                return getError(1001);
+            case "LOCK_OFFLINE":
+                return getError(1097);
+            case "LOCK_NOT_SUPPORTED":
+                return getError(1098);
+            case "ACCESSORY_BIND_NOT_SUPPORTED":
+                return getError(1099);
+            case "BIND_LIMIT_REACHED":
+                return getError(1100);
+            case "RELATION_ALREADY_BOUND":
+                return getError(1101);
+            case "BINDING_IN_PROGRESS":
+                return getError(1102);
+            case "SESSION_INVALID":
+                return getError(1103);
+        }
+    }
+    return error;
+};

package/lib/feature/screen/event.d.ts

@@ -0,0 +1,3 @@
+import { type ScreenEventListParams } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getEventListForRuntime(runtime: LockDeviceRuntime, params?: ScreenEventListParams): Promise<import("../../api/screen").ScreenEventListResult>;

package/lib/feature/screen/event.js

@@ -0,0 +1,19 @@
+import { getEventListApi, } from "../../api/screen";
+import { sdkLog } from "../../utils/sdk-log";
+export async function getEventListForRuntime(runtime, params = {}) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getEventListStart", {
+        devId: runtime.devId,
+        data: { offset: params.offset, limit: params.limit },
+    });
+    const result = await getEventListApi({
+        accessoryDevId: runtime.devId,
+        ...params,
+    });
+    sdkLog("info", "screen", "getEventListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: result?.datas?.length ?? 0, totalCount: result?.totalCount },
+    });
+    return result;
+}

package/lib/feature/screen/list.d.ts

@@ -0,0 +1,13 @@
+import { type ScreenLockDeviceInfo } from "../../api/screen";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getBoundLockListForRuntime(runtime: LockDeviceRuntime): Promise<{
+    items: (import("../../api/screen").BoundLockItem & ScreenLockDeviceInfo)[];
+    bindLimit: number;
+    boundCount: number;
+}>;
+export declare function getBindableLockListForRuntime(runtime: LockDeviceRuntime): Promise<{
+    items: (import("../../api/screen").BindableLockItem & ScreenLockDeviceInfo)[];
+    bindLimit: number;
+    boundCount: number;
+    canBindMore: boolean;
+}>;

package/lib/feature/screen/list.js

@@ -0,0 +1,69 @@
+import { getBoundLockListApi, getBindableLockListApi, } from "../../api/screen";
+import { getDeviceInfo } from "../../platform/device";
+import { sdkLog } from "../../utils/sdk-log";
+import { isWatchingBind, watchBindResult } from "./bind-watch";
+async function resolveLockDeviceInfo(accessoryDevId, lockDevId) {
+    try {
+        const info = await getDeviceInfo(lockDevId);
+        return {
+            isOnline: info.isOnline,
+            dpSchema: info.schema,
+            dps: info.dps,
+        };
+    }
+    catch (error) {
+        sdkLog("warn", "screen", "resolveLockDeviceInfoFail", {
+            devId: accessoryDevId,
+            data: { lockDevId },
+            error,
+        });
+        return {};
+    }
+}
+async function enrichItemsWithDeviceInfo(accessoryDevId, items) {
+    if (!Array.isArray(items) || items.length === 0) {
+        return [];
+    }
+    return Promise.all(items.map(async (item) => ({
+        ...item,
+        ...(await resolveLockDeviceInfo(accessoryDevId, item.lockDevId)),
+    })));
+}
+export async function getBoundLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getBoundListStart", { devId: runtime.devId });
+    const result = await getBoundLockListApi({ accessoryDevId: runtime.devId });
+    const items = await enrichItemsWithDeviceInfo(runtime.devId, result?.items ?? []);
+    sdkLog("info", "screen", "getBoundListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: items.length, boundCount: result?.boundCount },
+    });
+    return { ...result, items };
+}
+export async function getBindableLockListForRuntime(runtime) {
+    const startedAt = Date.now();
+    sdkLog("info", "screen", "getBindableListStart", { devId: runtime.devId });
+    const result = await getBindableLockListApi({
+        accessoryDevId: runtime.devId,
+    });
+    const items = await enrichItemsWithDeviceInfo(runtime.devId, result?.items ?? []);
+    sdkLog("info", "screen", "getBindableListSuccess", {
+        devId: runtime.devId,
+        duration: Date.now() - startedAt,
+        data: { count: items.length, canBindMore: result?.canBindMore },
+    });
+    for (const item of items) {
+        if (item.bindStatus !== "binding" || !item.sessionId) {
+            continue;
+        }
+        if (isWatchingBind(runtime, item.sessionId)) {
+            continue;
+        }
+        void watchBindResult(runtime, {
+            lockDevId: item.lockDevId,
+            sessionId: item.sessionId,
+        }).catch(() => { });
+    }
+    return { ...result, items };
+}

package/lib/feature/service/goto-service.d.ts

@@ -0,0 +1,5 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface GotoServiceParams {
+    tab?: "cloudStorage" | "AI";
+}
+export declare function gotoServiceForRuntime(rt: LockDeviceRuntime, params?: GotoServiceParams): Promise<unknown>;

package/lib/feature/service/goto-service.js

@@ -0,0 +1,16 @@
+import { navigateToMiniProgram } from "../../platform/device";
+export function gotoServiceForRuntime(rt, params) {
+    let type = 0;
+    if (params?.tab === "AI") {
+        type = 3;
+    }
+    return new Promise((resolve, reject) => {
+        const url = `godzilla://tyawqoyej4wi3pqebb?deviceId=${rt.config.devInfo.devId}&commodityType=${type}`;
+        navigateToMiniProgram({
+            position: "bottom",
+            shortLink: url,
+            success: resolve,
+            fail: reject,
+        });
+    });
+}

package/lib/feature/state/clear.d.ts

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

package/lib/feature/state/clear.js

@@ -0,0 +1,17 @@
+import { createDefaultDeviceStatus } from "../../runtime/lock-config";
+export function clearStateForRuntime(runtime) {
+    if (runtime.infra.logRefreshTimer) {
+        clearTimeout(runtime.infra.logRefreshTimer);
+        runtime.infra.logRefreshTimer = 0;
+    }
+    runtime.cache.dpState = {};
+    runtime.cache.currentUser = null;
+    runtime.cache.offlineDpCache = undefined;
+    runtime.cache.deviceAdvanceAbilityCache = undefined;
+    runtime.cache.isActiveThreadCache = false;
+    runtime.sync.hasSyncedT0 = false;
+    runtime.sync.syncDeleteUsersBusy = false;
+    runtime.sync.unlockMethodAutoSyncEnabled = true;
+    runtime.sync.tempAutoSyncEnabled = true;
+    runtime.deviceStatus = createDefaultDeviceStatus();
+}

package/lib/feature/state/device-status-events.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceStatus } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function getDeviceStatusChangeEvent(runtime: LockDeviceRuntime): string;
+export declare const onDeviceStatusChangeForRuntime: (runtime: LockDeviceRuntime, callback: (status: DeviceStatus) => void) => void;
+export declare const offDeviceStatusChangeForRuntime: (runtime: LockDeviceRuntime, callback: (status: DeviceStatus) => void) => void;

package/lib/feature/state/device-status-events.js

@@ -0,0 +1,11 @@
+import { DEVICE_STATUS_CHANGE_EVENT } from "../../utils/constant";
+import emitter from "../../utils/event";
+export function getDeviceStatusChangeEvent(runtime) {
+    return `${DEVICE_STATUS_CHANGE_EVENT}_${runtime.devId}`;
+}
+export const onDeviceStatusChangeForRuntime = (runtime, callback) => {
+    emitter.on(getDeviceStatusChangeEvent(runtime), callback);
+};
+export const offDeviceStatusChangeForRuntime = (runtime, callback) => {
+    emitter.off(getDeviceStatusChangeEvent(runtime), callback);
+};

package/lib/feature/state/device-status.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceStatus } from "../../interface";
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare const updateOnlineType: (runtime: LockDeviceRuntime) => Promise<void>;
+export declare const getDeviceStatusForRuntime: (runtime: LockDeviceRuntime) => DeviceStatus;
+export declare const updateDeviceStatus: (runtime: LockDeviceRuntime) => void;