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

package/lib/feature/fit/method/list.js

@@ -0,0 +1,64 @@
+import { getFitOpenModeList } from "../../../api/fit";
+import { getError } from "../../../utils/errors";
+import { sdkLog } from "../../../utils/sdk-log";
+import { getUnlockMethodTypeByTypeForRuntime } from "../../utils";
+function buildDevices(devIdList, devNameList) {
+    const ids = devIdList ?? [];
+    const names = devNameList ?? [];
+    return ids.map((devId, idx) => ({
+        devId,
+        devName: names[idx] ?? "",
+    }));
+}
+function mapRawToItem(raw, type) {
+    return {
+        id: raw.unlockBindingId,
+        unlockId: parseInt(raw.devUnlockId, 16),
+        unlockName: raw.name,
+        photoUnlock: false,
+        isSpecial: false,
+        type,
+        userName: raw.userName,
+        lockUserId: raw.lockUserId,
+        userType: raw.userType,
+        devices: buildDevices(raw.devIdList, raw.devNameList),
+    };
+}
+export async function getFitUnlockMethodListForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "getListStart", {
+        devId: rt.devId,
+        data: {
+            type: params.type,
+            hasLockDevId: typeof params.lockDevId === "string",
+        },
+    });
+    const cfg = getUnlockMethodTypeByTypeForRuntime(rt, params.type);
+    const dpId = rt.config.idsByCode[cfg.code];
+    if (!dpId) {
+        const error = getError(1014);
+        sdkLog("warn", "fitUnlockMethod", "getListMissingDpId", {
+            devId: rt.devId,
+            data: { type: params.type },
+            error,
+        });
+        throw error;
+    }
+    const raw = await getFitOpenModeList(rt.devId, dpId);
+    const list = (raw ?? []).map((item) => mapRawToItem(item, params.type));
+    if (params.lockDevId) {
+        const filtered = list.filter((item) => item.devices.some((d) => d.devId === params.lockDevId));
+        sdkLog("info", "fitUnlockMethod", "getListSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { type: params.type, count: filtered.length, filtered: true },
+        });
+        return filtered;
+    }
+    sdkLog("info", "fitUnlockMethod", "getListSuccess", {
+        devId: rt.devId,
+        duration: Date.now() - startedAt,
+        data: { type: params.type, count: list.length, filtered: false },
+    });
+    return list;
+}

package/lib/feature/fit/method/types.d.ts

@@ -0,0 +1,68 @@
+import type { ErrorData, UnlockMethodType } from "../../../interface";
+export interface FitUnlockMethodDevice {
+    devId: string;
+    devName: string;
+}
+export interface FitUnlockMethodItem {
+    id: number;
+    unlockId: number;
+    unlockName: string;
+    photoUnlock: boolean;
+    isSpecial: boolean;
+    type: UnlockMethodType;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devices: FitUnlockMethodDevice[];
+}
+export interface GetFitUnlockMethodListParams {
+    type: UnlockMethodType;
+    lockDevId?: string;
+}
+export interface FitAddUnlockMethodBaseParams {
+    lockDevId?: string;
+    userId: string;
+    name: string;
+    hijack?: boolean;
+}
+export interface FitAddPasswordParams extends FitAddUnlockMethodBaseParams {
+    password: string;
+}
+export interface FitStartAddUnlockMethodParams {
+    lockDevId?: string;
+    userId: string;
+    type: UnlockMethodType;
+    timeout?: number;
+}
+export interface FitCancelAddUnlockMethodParams extends FitStartAddUnlockMethodParams {
+}
+export interface FitUpdateUnlockMethodParams {
+    id: number;
+    name: string;
+    hijack?: boolean;
+}
+interface FitStepEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    lockUserId: number;
+    stage: "step";
+    step: number;
+    total: number;
+}
+interface FitSuccessEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    id: number;
+    name: string;
+    stage: "success";
+}
+interface FitErrorEvent {
+    type: UnlockMethodType;
+    lockDevId: string;
+    lockUserId: number;
+    stage: "fail";
+    error: ErrorData;
+}
+export type FitAddUnlockMethodEvent = FitStepEvent | FitSuccessEvent | FitErrorEvent;
+export type FitAddUnlockMethodListener = (event: FitAddUnlockMethodEvent) => void;
+export {};

package/lib/feature/fit/method/types.js

@@ -0,0 +1 @@
+export {};

package/lib/feature/fit/method/update-remove.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
+import type { FitUpdateUnlockMethodParams } from "./types";
+export declare function fitUpdateUnlockMethodForRuntime(rt: LockDeviceRuntime, params: FitUpdateUnlockMethodParams): Promise<void>;
+export declare const fitDeleteUnlockMethodForRuntime: (this: unknown, rt: LockDeviceRuntime, id: number, lockDevId?: string | undefined) => Promise<void>;

package/lib/feature/fit/method/update-remove.js

@@ -0,0 +1,159 @@
+import dpUtils from "@ray-js/tuya-dp-transform";
+import { removeFitOpenMode, updateFitOpenMode } from "../../../api/fit";
+import dpCodes from "../../../config/dp-code";
+import { fitRemove, fitReportRemove, } from "../../../config/dp-map/unlock-method-fit";
+import { isAdmin } from "../../../utils";
+import { getError, handleCloudError } from "../../../utils/errors";
+import { publishDpsForRuntime } from "../../dp/publish-dps";
+import { getUnlockMethodTypeByDpCodeForRuntime, parallelOnlyForRuntime, } from "../../utils";
+import { getUnlockMethodDetailForRuntime } from "../../unlock/method/detail";
+import { resolveSlaveId } from "../resolve-slave-id";
+import { sdkLog } from "../../../utils/sdk-log";
+export async function fitUpdateUnlockMethodForRuntime(rt, params) {
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "updateStart", {
+        devId: rt.devId,
+        data: {
+            id: params.id,
+            hasName: typeof params.name === "string",
+            hijack: !!params.hijack,
+        },
+    });
+    try {
+        await updateFitOpenMode({
+            opModeId: params.id,
+            fittingId: rt.devId,
+            unlockName: params.name,
+            hijack: !!params.hijack,
+        });
+        sdkLog("info", "fitUnlockMethod", "updateSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitUnlockMethod", "updateCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id: params.id },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+}
+export const fitDeleteUnlockMethodForRuntime = parallelOnlyForRuntime(async function fitDeleteUnlockMethodForRuntime(rt, id, lockDevId) {
+    const cfg = rt.config;
+    const startedAt = Date.now();
+    sdkLog("info", "fitUnlockMethod", "deleteStart", {
+        devId: rt.devId,
+        data: { id, hasLockDevId: typeof lockDevId === "string" },
+    });
+    const detail = await getUnlockMethodDetailForRuntime(rt, id);
+    const { lockUserId, unlockId, userType, dpId } = detail;
+    const code = cfg.codesById[dpId];
+    if (!code) {
+        const error = getError(1014);
+        sdkLog("warn", "fitUnlockMethod", "deleteMissingDpCode", {
+            devId: rt.devId,
+            data: { id, dpId },
+            error,
+        });
+        throw error;
+    }
+    const unlockMethodConfig = getUnlockMethodTypeByDpCodeForRuntime(rt, code);
+    const removeDpCode = dpCodes.unlockMethodDel;
+    if (!cfg.dpSchema[removeDpCode]) {
+        const error = getError(1014);
+        sdkLog("warn", "fitUnlockMethod", "deleteUnsupportedDp", {
+            devId: rt.devId,
+            data: { id, dpCode: removeDpCode },
+            error,
+        });
+        throw error;
+    }
+    const slaveId = await resolveSlaveId(rt, lockDevId);
+    const dpData = {
+        slaveId,
+        type: unlockMethodConfig.id,
+        stage: 0,
+        admin: isAdmin(userType),
+        memberId: lockUserId,
+        unlockId,
+        operation: 1,
+    };
+    const res = await publishDpsForRuntime(rt, {
+        [removeDpCode]: dpUtils.format(dpData, fitRemove),
+    }, {
+        checkReport: (dpDataIn) => {
+            if (typeof dpDataIn[removeDpCode] === "undefined") {
+                return false;
+            }
+            const result = dpUtils.parse(dpDataIn[removeDpCode], fitReportRemove);
+            let hasReport = result.type === unlockMethodConfig.id &&
+                result.slaveId === slaveId;
+            if (cfg.strictMode) {
+                hasReport =
+                    hasReport &&
+                        result.stage === 0 &&
+                        result.memberId === lockUserId &&
+                        result.unlockId === unlockId;
+            }
+            if (hasReport) {
+                if (result.unlockId !== unlockId) {
+                    console.warn(`FitDeleteUnlockMethod: unlockId mismatch, expected ${unlockId}, got ${result.unlockId}`);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportUnlockIdMismatch", {
+                        devId: rt.devId,
+                        data: { id, type: unlockMethodConfig.type },
+                    });
+                }
+                return result;
+            }
+            return false;
+        },
+    });
+    if (res.status !== 255 && res.status !== 1) {
+        switch (res.status) {
+            case 2:
+                {
+                    const error = getError(1029);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id, status: res.status },
+                        error,
+                    });
+                    throw error;
+                }
+            case 0:
+            default:
+                {
+                    const error = getError(1028);
+                    sdkLog("warn", "fitUnlockMethod", "deleteReportFail", {
+                        devId: rt.devId,
+                        duration: Date.now() - startedAt,
+                        data: { id, status: res.status },
+                        error,
+                    });
+                    throw error;
+                }
+        }
+    }
+    try {
+        await removeFitOpenMode(rt.devId, String(id));
+        sdkLog("info", "fitUnlockMethod", "deleteSuccess", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id, type: unlockMethodConfig.type },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fitUnlockMethod", "deleteCloudFail", {
+            devId: rt.devId,
+            duration: Date.now() - startedAt,
+            data: { id, type: unlockMethodConfig.type },
+            error,
+        });
+        throw handleCloudError(error);
+    }
+});

package/lib/feature/fit/password-list.d.ts

@@ -0,0 +1,24 @@
+import { EffectiveConfig, UnlockMethodType } from "../../interface";
+import { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export interface FitPasswordItem {
+    id: number;
+    unlockId: number;
+    unlockName: string;
+    type: UnlockMethodType;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devLockId: string;
+    effective: EffectiveConfig;
+}
+export declare const getFitPasswordListForRuntime: (runtime: LockDeviceRuntime) => Promise<{
+    id: number;
+    unlockId: string;
+    unlockName: string;
+    photoUnlock: boolean;
+    userName: string;
+    lockUserId: number;
+    userType: number;
+    devLockId: string;
+    effective: EffectiveConfig;
+}[]>;

package/lib/feature/fit/password-list.js

@@ -0,0 +1,31 @@
+import { getFitPasswordList } from "../../api/fit";
+import { parseWeek } from "../../utils";
+export const getFitPasswordListForRuntime = async (runtime) => {
+    const list = await getFitPasswordList(runtime.devId);
+    return list.map((item) => {
+        const effective = {
+            effectiveDate: item.effectiveTime,
+            expiredDate: item.invalidTime,
+        };
+        if (item.scheduleDetails?.length) {
+            const scheduleDetail = item.scheduleDetails[0];
+            effective.repeat = scheduleDetail.allDay === false ? "week" : "none";
+            if (effective.repeat === "week") {
+                effective.weeks = parseWeek(scheduleDetail.workingDay);
+                effective.effectiveTime = scheduleDetail.effectiveTime;
+                effective.expiredTime = scheduleDetail.invalidTime;
+            }
+        }
+        return {
+            id: item.unlockBindingId,
+            unlockId: item.devUnlockId,
+            unlockName: item.name,
+            photoUnlock: false,
+            userName: item.userName,
+            lockUserId: item.lockUserId,
+            userType: item.userType,
+            devLockId: item.devUnlockId,
+            effective,
+        };
+    });
+};

package/lib/feature/fit/resolve-slave-id.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function resolveSlaveId(runtime: LockDeviceRuntime, lockDevId?: string): Promise<number>;

package/lib/feature/fit/resolve-slave-id.js

@@ -0,0 +1,38 @@
+import { getBoundLockListForRuntime } from "./list";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export async function resolveSlaveId(runtime, lockDevId) {
+    const list = await getBoundLockListForRuntime(runtime);
+    if (list.length === 0) {
+        const error = getError(1088);
+        sdkLog("warn", "fit", "resolveSlaveIdEmpty", {
+            devId: runtime.devId,
+            error,
+        });
+        throw error;
+    }
+    if (lockDevId) {
+        const target = list.find((item) => item.devId === lockDevId);
+        if (!target) {
+            const error = getError(1089);
+            sdkLog("warn", "fit", "resolveSlaveIdNotBound", {
+                devId: runtime.devId,
+                data: { lockDevId },
+                error,
+            });
+            throw error;
+        }
+        const slaveId = parseInt(target.devUnlockId, 16);
+        sdkLog("info", "fit", "resolveSlaveIdSuccess", {
+            devId: runtime.devId,
+            data: { lockDevId },
+        });
+        return slaveId;
+    }
+    const slaveId = parseInt(list[0].devUnlockId, 16);
+    sdkLog("info", "fit", "resolveSlaveIdDefaultSuccess", {
+        devId: runtime.devId,
+        data: { count: list.length },
+    });
+    return slaveId;
+}

package/lib/feature/fit/setting.d.ts

@@ -0,0 +1,2 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function setFitSettingForRuntime(runtime: LockDeviceRuntime, dpCode: string, value: string | number | boolean): Promise<void>;

package/lib/feature/fit/setting.js

@@ -0,0 +1,27 @@
+import { sdkLog } from "../../utils/sdk-log";
+import { publishDpsOnlyWithRuntime } from "../dp/publish-dps";
+export async function setFitSettingForRuntime(runtime, dpCode, value) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "setSettingStart", {
+        devId: runtime.devId,
+        data: { dpCode, valueType: typeof value },
+    });
+    try {
+        const result = await publishDpsOnlyWithRuntime(runtime, { [dpCode]: value });
+        sdkLog("info", "fit", "setSettingSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { dpCode },
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "setSettingFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { dpCode },
+            error,
+        });
+        throw error;
+    }
+}

package/lib/feature/fit/shared.d.ts

@@ -0,0 +1,27 @@
+export type FitBindOperation = "bind" | "unbind";
+export declare const FIT_BIND_TIMEOUT_MS = 12000;
+export declare const FIT_OPERATION_CODE: Record<FitBindOperation, "00" | "01">;
+export declare const normalizeHex: (value: string) => string;
+export declare function buildTransparentData(operation: FitBindOperation, fit: {
+    fittingUnlockId: string;
+    randomStr: string;
+    devUnlockId: string;
+    devUuid: string;
+}, loginKey: string): string;
+export declare function buildLockCheckCodeTemplate(operation: FitBindOperation, fit: {
+    devUnlockId: string;
+    fittingUnlockId: string;
+    randomStr: string;
+}): string;
+export declare function waitTransparentResult(params: {
+    fittingId: string;
+    expectedOperation: "00" | "01";
+    timeout?: number;
+}): Promise<void>;
+export declare function ensureFitBleOnline(fittingId: string): Promise<boolean>;
+export declare function publishFitTransparentFlow(fittingId: string, keyDeviceId: string, operation: FitBindOperation, fit: {
+    fittingUnlockId: string;
+    randomStr: string;
+    devUnlockId: string;
+    devUuid: string;
+}): Promise<void>;

package/lib/feature/fit/shared.js

@@ -0,0 +1,118 @@
+import { connectBLEDevice, getBLEOnlineState, getEncryptLocalKeyWithData, offBLETransparentDataReport, onBLETransparentDataReport, publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
+import { getError } from "../../utils/errors";
+import { sdkLog } from "../../utils/sdk-log";
+export const FIT_BIND_TIMEOUT_MS = 12_000;
+export const FIT_OPERATION_CODE = {
+    bind: "00",
+    unbind: "01",
+};
+export const normalizeHex = (value) => value.replace(/\s/g, "");
+export function buildTransparentData(operation, fit, loginKey) {
+    return `${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}${fit.devUnlockId}${fit.devUuid}${loginKey}`;
+}
+export function buildLockCheckCodeTemplate(operation, fit) {
+    return `ffff${fit.devUnlockId}${FIT_OPERATION_CODE[operation]}${fit.fittingUnlockId}${fit.randomStr}`;
+}
+export function waitTransparentResult(params) {
+    const { fittingId, expectedOperation, timeout = FIT_BIND_TIMEOUT_MS, } = params;
+    return new Promise((resolve, reject) => {
+        const onReport = ({ deviceId, data }) => {
+            if (deviceId !== fittingId) {
+                return;
+            }
+            if (!data) {
+                return;
+            }
+            const hex = normalizeHex(data).toLowerCase();
+            const operation = hex.slice(0, 2);
+            const result = hex.slice(26, 28);
+            if (operation !== expectedOperation) {
+                return;
+            }
+            clearTimeout(timer);
+            offBLETransparentDataReport(onReport);
+            if (result === "00" || result === "07") {
+                resolve();
+                return;
+            }
+            reject(getError(1004));
+        };
+        const timer = setTimeout(() => {
+            offBLETransparentDataReport(onReport);
+            reject(getError(1002));
+        }, timeout);
+        onBLETransparentDataReport(onReport);
+    });
+}
+export async function ensureFitBleOnline(fittingId) {
+    const isOnline = await getBLEOnlineState(fittingId);
+    if (isOnline) {
+        return true;
+    }
+    sdkLog("info", "fit", "ensureFitBleConnectStart", {
+        devId: fittingId,
+    });
+    try {
+        await connectBLEDevice(fittingId);
+        const nextOnline = await getBLEOnlineState(fittingId);
+        sdkLog(nextOnline ? "info" : "warn", "fit", "ensureFitBleConnectResult", {
+            devId: fittingId,
+            data: { online: nextOnline },
+        });
+        return nextOnline;
+    }
+    catch (error) {
+        sdkLog("warn", "fit", "ensureFitBleConnectFail", {
+            devId: fittingId,
+            error,
+        });
+        return false;
+    }
+}
+export async function publishFitTransparentFlow(fittingId, keyDeviceId, operation, fit) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "transparentFlowStart", {
+        devId: fittingId,
+        data: { operation, lockDevId: keyDeviceId },
+    });
+    const fitBleOnline = await ensureFitBleOnline(fittingId);
+    if (!fitBleOnline) {
+        const error = getError(1001);
+        sdkLog("warn", "fit", "transparentFlowOffline", {
+            devId: fittingId,
+            duration: Date.now() - startedAt,
+            data: { operation, lockDevId: keyDeviceId },
+            error,
+        });
+        throw error;
+    }
+    subscribeBLETransparentDataReport(fittingId);
+    const loginKey = await getEncryptLocalKeyWithData({
+        deviceId: fittingId,
+        keyDeviceId,
+    });
+    if (!loginKey) {
+        const error = getError(1051);
+        sdkLog("warn", "fit", "transparentFlowMissingLoginKey", {
+            devId: fittingId,
+            duration: Date.now() - startedAt,
+            data: { operation, lockDevId: keyDeviceId },
+            error,
+        });
+        throw error;
+    }
+    const waitResult = waitTransparentResult({
+        fittingId,
+        expectedOperation: FIT_OPERATION_CODE[operation],
+    });
+    if (operation === "bind") {
+        await publishBLETransparentData(fittingId, buildTransparentData("unbind", fit, loginKey));
+    }
+    await publishBLETransparentData(fittingId, buildTransparentData(operation, fit, loginKey));
+    await waitResult;
+    sdkLog("info", "fit", "transparentFlowSuccess", {
+        devId: fittingId,
+        duration: Date.now() - startedAt,
+        data: { operation, lockDevId: keyDeviceId },
+    });
+}

package/lib/feature/fit/sync.d.ts

@@ -0,0 +1,4 @@
+import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+export declare function syncFitBindingsForRuntime(runtime: LockDeviceRuntime): Promise<void>;
+export declare function syncFitReportForRuntime(runtime: LockDeviceRuntime, ins: string): Promise<unknown>;
+export declare function syncOpenModeRiseForRuntime(runtime: LockDeviceRuntime, dpIds: string): Promise<unknown>;

package/lib/feature/fit/sync.js

@@ -0,0 +1,85 @@
+import { syncFitToLockRise, syncFitReport as syncFitReportApi, syncOpenModeRise as syncOpenModeRiseApi, } from "../../api/fit";
+import { publishBLETransparentData, subscribeBLETransparentDataReport, } from "../../platform/device";
+import { sdkLog } from "../../utils/sdk-log";
+export async function syncFitBindingsForRuntime(runtime) {
+    const startedAt = Date.now();
+    const fittingId = runtime.devId;
+    sdkLog("info", "fit", "syncBindingsStart", {
+        devId: runtime.devId,
+    });
+    try {
+        const result = await syncFitToLockRise(fittingId);
+        const instructions = Array.isArray(result.ins) ? result.ins : [];
+        if (!result.distributed || instructions.length === 0) {
+            sdkLog("info", "fit", "syncBindingsSkip", {
+                devId: runtime.devId,
+                duration: Date.now() - startedAt,
+                data: { distributed: result.distributed, count: instructions.length },
+            });
+            return;
+        }
+        subscribeBLETransparentDataReport(fittingId);
+        for (const ins of instructions) {
+            await publishBLETransparentData(fittingId, ins);
+        }
+        sdkLog("info", "fit", "syncBindingsSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            data: { count: instructions.length },
+        });
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncBindingsFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}
+export async function syncFitReportForRuntime(runtime, ins) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "syncReportStart", {
+        devId: runtime.devId,
+        data: { hasInstruction: !!ins },
+    });
+    try {
+        const result = await syncFitReportApi(runtime.devId, ins);
+        sdkLog("info", "fit", "syncReportSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncReportFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}
+export async function syncOpenModeRiseForRuntime(runtime, dpIds) {
+    const startedAt = Date.now();
+    sdkLog("info", "fit", "syncOpenModeRiseStart", {
+        devId: runtime.devId,
+        data: { hasDpIds: !!dpIds },
+    });
+    try {
+        const result = await syncOpenModeRiseApi(runtime.devId, dpIds);
+        sdkLog("info", "fit", "syncOpenModeRiseSuccess", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+        });
+        return result;
+    }
+    catch (error) {
+        sdkLog("error", "fit", "syncOpenModeRiseFail", {
+            devId: runtime.devId,
+            duration: Date.now() - startedAt,
+            error,
+        });
+        throw error;
+    }
+}