@ray-js/lock-sdk 1.2.0-beta.24 → 1.2.0-beta.25

package/lib/api/fit.d.ts

@@ -48,7 +48,11 @@ export interface SyncFitToLockRiseResult {
 }
 export declare const syncFitToLockRise: (fittingId: string) => Promise<SyncFitToLockRiseResult>;
 export declare const syncFitReport: (fittingId: string, ins: string) => Promise<unknown>;
-export declare const syncOpenModeRise: (devId: string, dpIds: string) => Promise<unknown>;
+export interface SyncOpenModeRiseResult {
+    ins: string;
+    distributed: boolean;
+}
+export declare const syncOpenModeRise: (devId: string, dpIds: string[]) => Promise<SyncOpenModeRiseResult>;
 export interface RawPasswordItem {
     unlockBindingId: number;
     effectiveTime: number;
@@ -73,6 +77,30 @@ export interface RawPasswordItem {
     gmtCreate: number;
 }
 export declare const getFitPasswordList: (fittingId: string) => Promise<RawPasswordItem[]>;
+export interface RawOfflinePasswordItem {
+    unlockBindingId?: number | string;
+    pwdId: number;
+    sn: number;
+    gmtCreate: number;
+    opModeType: number;
+    opModeSubType: number;
+    pwdName: string;
+    gmtStart: number;
+    gmtExpired: number;
+    mayExpired: boolean;
+    devNameList: string[];
+    scheduleDetails: RawFitOpenModeScheduleItem[];
+    revokedPwdName: string;
+    revokedPwdEffectiveTime: number;
+    revokedPwdInvalidTime: number;
+}
+export interface FitOfflinePwdQuery {
+    limit?: number;
+    offset?: number;
+}
+export declare const getFitOfflinePasswordList: (fittingId: string, query?: FitOfflinePwdQuery) => Promise<RawOfflinePasswordItem[] | {
+    datas: RawOfflinePasswordItem[];
+}>;
 export interface RawFitUserItem {
     userId: string;
     uid: string;
@@ -143,7 +171,19 @@ export interface RawFitOpenModeItem {
     gmtCreate: number;
 }
 export declare const getFitOpenModeList: (fittingId: string, dpId?: number) => Promise<RawFitOpenModeItem[]>;
-export declare const getFitBleKeyListApi: (fittingId: string) => Promise<unknown[]>;
+export interface RawFitBleKeyItem {
+    id: string;
+    unlockBindingId: string;
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+    scheduleDetails?: RawFitOpenModeScheduleItem[];
+    opModeSubType?: number;
+    sn?: number;
+    userName?: string;
+    devNameList?: string[];
+}
+export declare const getFitBleKeyListApi: (fittingId: string) => Promise<RawFitBleKeyItem[]>;
 export declare const addFitBleKeyApi: (fittingId: string, params: Record<string, unknown>) => Promise<unknown>;
 interface UpdateFitBleKeyParams {
     unlockBindingId: string;
@@ -200,4 +240,17 @@ export declare const addFitOnlineTempPwdCloud: (params: FetchFitOnlineTempPwdMes
 export declare const removeFitOnlineTempPwd: (fittingId: string, pwdId: number) => Promise<unknown>;
 export declare const updateFitOnlineTempPwd: (fittingId: string, params: Record<string, unknown>) => Promise<unknown>;
 export declare const renameFitOnlineTempPwd: (fittingId: string, pwdId: number, name: string) => Promise<true>;
+export declare const resendFitOnlineTempPwd: (fittingId: string, pwdId: number) => Promise<boolean>;
+export interface FitInvalidPwdQuery {
+    opMode?: number | string;
+    limit?: number;
+    offset?: number;
+}
+export interface FitInvalidPwdListResult {
+    datas: RawPasswordItem[];
+    totalCount: number;
+}
+export declare const getFitInvalidPwdListApi: (fittingId: string, query?: FitInvalidPwdQuery) => Promise<FitInvalidPwdListResult>;
+export declare const clearFitInvalidPwdApi: (fittingId: string, opMode?: number | string) => Promise<boolean>;
+export declare const getFitDeviceBVApi: (fittingId: string) => Promise<number>;
 export {};

package/lib/api/fit.js

@@ -46,7 +46,7 @@ export const syncFitToLockRise = (fittingId) => requestApi({
     logName: "syncFitToLockRise",
     api: `${THING}.m.device.lock.fittings.sync.rise`,
     version: "1.0",
-    data: { fittingId },
+    data: { devId: fittingId, fittingId },
 });
 export const syncFitReport = (fittingId, ins) => requestApi({
     logName: "syncFitReport",
@@ -66,6 +66,12 @@ export const getFitPasswordList = (fittingId) => requestApi({
     version: "1.0",
     data: { fittingId },
 });
+export const getFitOfflinePasswordList = (fittingId, query = {}) => requestApi({
+    logName: "getFitOfflinePasswordList",
+    api: `${THING}.m.device.lock.offlinepwd.list.valid`,
+    version: "1.0",
+    data: { devId: fittingId, limit: 200, ...query },
+});
 export const getFitUserListApi = (fittingId) => requestApi({
     logName: "getFitUserListApi",
     api: `${THING}.m.device.member.list`,
@@ -156,3 +162,39 @@ export const renameFitOnlineTempPwd = (fittingId, pwdId, name) => requestApi({
     version: "1.0",
     data: { fittingId, pwdId, name },
 });
+export const resendFitOnlineTempPwd = (fittingId, pwdId) => requestApi({
+    logName: "resendFitOnlineTempPwd",
+    api: `${THING}.m.device.fittings.password.temp.resend`,
+    version: "1.0",
+    data: { fittingId, pwdId },
+});
+export const getFitInvalidPwdListApi = (fittingId, query = {}) => requestApi({
+    logName: "getFitInvalidPwdListApi",
+    api: `${THING}.m.device.fittings.unlock.bindings.list.garbage`,
+    version: "2.0",
+    data: { fittingId, ...query },
+});
+export const clearFitInvalidPwdApi = (fittingId, opMode) => requestApi({
+    logName: "clearFitInvalidPwdApi",
+    api: `${THING}.m.device.fittings.unlock.bindings.clear`,
+    version: "2.0",
+    data: { fittingId, opMode },
+});
+const FIT_BV_EXT_CONFIG_KEY = "5de69aaa812cd52c9a14dcfe";
+export const getFitDeviceBVApi = (fittingId) => requestApi({
+    logName: "getFitDeviceBVApi",
+    api: `${THING}.app.buyer.high.power.get`,
+    version: "1.0",
+    data: { input: { deviceId: fittingId, code: "tyabi3trvg" } },
+}).then((res) => {
+    if (res?.extConfig) {
+        try {
+            const extra = JSON.parse(res.extConfig);
+            return Number(extra[FIT_BV_EXT_CONFIG_KEY]) || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+});

package/lib/api/log.d.ts

@@ -74,6 +74,35 @@ export interface LogsResult {
     totalCount: number;
 }
 export declare const getRecordList: (params: GetRecordListParams) => Promise<LogsResult>;
+export interface FitRecordInfo {
+    id?: string | number;
+    historyId?: string | number;
+    time?: string | number;
+    gmtCreate?: number;
+    dpId: string | number;
+    dpValue: any;
+    userId: string;
+    userName?: string;
+    unlockName?: string;
+    memberBindableFlag?: 0 | 1;
+    avatarUrl?: string;
+    relateDevName?: string;
+    dps?: Record<number, any>[];
+    mediaInfoList?: MediaInfoRecord[];
+    unionUnlockInfo?: UnionUnlockInfo[];
+    localOperateRecordInfo?: LocalOperateRecordInfo;
+    matterRecordInfo?: {
+        matterSn: number;
+        matterSource: number;
+        matterType: number;
+    };
+}
+export interface FitRecordListResult {
+    datas: FitRecordInfo[];
+    hasNext: boolean;
+    totalCount: number;
+}
+export declare const getFitRecordListApi: (params: GetRecordListParams) => Promise<FitRecordListResult>;
 export interface LockLogListItem {
     logId: string;
     logCategory: LockLogCategory;
@@ -135,6 +164,8 @@ interface GetAlarmListResult {
     totalCount: number;
 }
 export declare const getAlarmList: (params: GetRecordListParams) => Promise<GetAlarmListResult>;
+export declare const getAlarmUnreadCountApi: (devId: string) => Promise<number>;
+export declare const getActivePeriodApi: (devId: string) => Promise<number>;
 interface GetAlbumMessagesParams {
     devId: string;
     limit: number;

package/lib/api/log.js

@@ -18,6 +18,12 @@ export const getRecordList = (params) => {
         data: params,
     });
 };
+export const getFitRecordListApi = (params) => requestApi({
+    logName: "getFitRecordListApi",
+    api: `${THING}.m.device.lock.history.list`,
+    version: "2.0",
+    data: params,
+});
 export const getLockLogList = (params) => {
     return requestApi({
         logName: "getLockLogList",
@@ -42,6 +48,22 @@ export const getAlarmList = (params) => {
         data: params,
     });
 };
+export const getAlarmUnreadCountApi = (devId) => {
+    return requestApi({
+        logName: "getAlarmUnreadCountApi",
+        api: `${THING}.m.device.lock.alarm.unread`,
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const getActivePeriodApi = (devId) => {
+    return requestApi({
+        logName: "getActivePeriodApi",
+        api: `${THING}.m.device.lock.active.period`,
+        version: "1.0",
+        data: { devId },
+    });
+};
 export const getAlbumMessages = (params) => {
     return requestApi({
         logName: "getAlbumMessages",

package/lib/api/product.d.ts

@@ -0,0 +1,8 @@
+export interface ProductSpecResult {
+    productManual?: boolean;
+    productInstVideo?: boolean;
+    urlType?: number;
+    url?: string;
+    [key: string]: unknown;
+}
+export declare const configCheck: (devId: string, productId: string, configItem: string) => Promise<ProductSpecResult>;

package/lib/api/product.js

@@ -0,0 +1,10 @@
+import { THING } from "../utils/constant";
+import { requestApi } from "./request";
+export const configCheck = (devId, productId, configItem) => {
+    return requestApi({
+        logName: "productConfigCheck",
+        api: `${THING}.m.product.config.check`,
+        version: "1.0",
+        data: { devId, productId, configItem },
+    });
+};

package/lib/api/temp.d.ts

@@ -129,6 +129,15 @@ interface CreateOfflineOnceParams {
     gmtExpired: string;
 }
 export declare const createOfflineOnceAPI: (params: CreateOfflineOnceParams) => Promise<OfflinePwdResult>;
+interface GetOfflinePwdAvailableParams {
+    devId: string;
+    pwdType: string;
+}
+export interface OfflinePwdAvailableResult {
+    available: boolean;
+    nextAvailableTime?: number;
+}
+export declare const getOfflinePwdAvailable: (params: GetOfflinePwdAvailableParams) => Promise<OfflinePwdAvailableResult>;
 interface GetDynapwdParams {
     devId: string;
     adminPwd?: string;
@@ -142,6 +151,12 @@ interface RevokeOfflinePasswordParams {
     name?: string;
 }
 export declare const revokeOfflinePassword: (params: RevokeOfflinePasswordParams) => Promise<OfflinePwdResult>;
+interface RevokeOfflinePasswordByPwdIdParams {
+    devId: string;
+    pwdId: number;
+    name?: string;
+}
+export declare const revokeOfflinePasswordByPwdId: (params: RevokeOfflinePasswordByPwdIdParams) => Promise<OfflinePwdResult>;
 interface EffectiveListParams {
     devId: string;
     authTypes: string[];
@@ -208,6 +223,12 @@ interface ReNameOfflineParams {
     unlockBindingId: string;
 }
 export declare const reNameOffline: (params: ReNameOfflineParams) => Promise<unknown>;
+interface ReNameOfflineByPwdIdParams {
+    devId: string;
+    pwdName: string;
+    pwdId: number;
+}
+export declare const reNameOfflineByPwdId: (params: ReNameOfflineByPwdIdParams) => Promise<unknown>;
 export interface SyncTempPwdScheduleItem {
     allDay: boolean;
     effectiveTime: number;

package/lib/api/temp.js

@@ -90,6 +90,14 @@ export const createOfflineOnceAPI = (params) => {
         data: params,
     });
 };
+export const getOfflinePwdAvailable = (params) => {
+    return requestApi({
+        logName: "getOfflinePwdAvailable",
+        api: `${THING}.m.device.lock.offlinepwd.available`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const getDynamicPassword = (params) => {
     return requestApi({
         logName: "getDynamicPassword",
@@ -106,6 +114,14 @@ export const revokeOfflinePassword = (params) => {
         data: params,
     });
 };
+export const revokeOfflinePasswordByPwdId = (params) => {
+    return requestApi({
+        logName: "revokeOfflinePasswordByPwdId",
+        api: `${THING}.m.device.lock.offlinepwd.revoke`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const fetchEffectiveList = (params) => {
     return requestApi({
         logName: "fetchEffectiveList",
@@ -146,6 +162,14 @@ export const reNameOffline = (params) => {
         data: params,
     });
 };
+export const reNameOfflineByPwdId = (params) => {
+    return requestApi({
+        logName: "reNameOfflineByPwdId",
+        api: `${THING}.m.device.lock.offlinepwd.name.update`,
+        version: "1.0",
+        data: params,
+    });
+};
 export const getSyncTempPasswords = (params) => {
     return requestApi({
         logName: "getSyncTempPasswords",

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

@@ -4,12 +4,14 @@ import { clearStateForRuntime } from "../../../feature/state/clear";
 import { registerRuntime, unregisterRuntime, getRegisteredRuntimeCount, } from "../../../runtime/registry";
 import { buildFitSDKInstance } from "../build-instance";
 import { createBootstrappedRuntime } from "./bootstrap";
+import { startFitSyncReportForRuntime } from "../../../feature/fit/sync";
 export async function bootstrapRegisteredFitInstance(options) {
     const runtime = await createBootstrappedRuntime(options);
     registerRuntime(runtime);
     try {
         addEvents(runtime);
         await initState(runtime);
+        startFitSyncReportForRuntime(runtime);
         return { runtime, instance: buildFitSDKInstance(runtime) };
     }
     catch (error) {

package/lib/entries/fit/bootstrap/bootstrap.js

@@ -36,6 +36,7 @@ export async function applyFitOptionsToRuntime(runtime, options) {
             idsByCode[item.code] = item.id;
         });
     }
+    config.isFitting = true;
     config.strictMode = options?.strictMode ?? true;
     config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
     config.passwordSupportZero = options?.passwordSupportZero ?? true;

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

@@ -3,6 +3,7 @@ import { registerFitSDKInstanceRuntime } from "./bootstrap/lock-instance-runtime
 import { getRegisteredRuntimeCount, unregisterRuntime, } from "../../runtime/registry";
 import { clearStateForRuntime } from "../../feature/state/clear";
 import { removeEvents } from "../../feature/state/platform-routing";
+import { stopFitSyncReportForRuntime } from "../../feature/fit/sync";
 import { updateConfigForRuntime, } from "../../feature/misc/update-config";
 import { sdkLog } from "../../utils/sdk-log";
 import * as FitExports from "./exports";
@@ -27,6 +28,7 @@ export function buildFitSDKInstance(runtime) {
             sdkLog("info", "fit-lifecycle", "destroy", { devId: runtime.devId });
             unregisterRuntime(runtime.devId);
             clearPrimaryFitSDKInstanceIfDevId(runtime.devId);
+            stopFitSyncReportForRuntime(runtime);
             clearStateForRuntime(runtime);
             if (getRegisteredRuntimeCount() === 0) {
                 removeEvents();

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

@@ -1,7 +1,8 @@
+import { type BoundLockListItem, type FitLockUnbindableReason, type UnbindLockListItem } from "../../../feature/fit/list";
 import { BoundFitLockItem, UnbindLockItem } from "../../../api/fit";
-export type { BoundFitLockItem, UnbindLockItem };
-export declare function getBoundLockList(): Promise<BoundFitLockItem[]>;
-export declare function getUnbindLockList(): Promise<UnbindLockItem[]>;
+export type { BoundFitLockItem, BoundLockListItem, UnbindLockItem, UnbindLockListItem, FitLockUnbindableReason, };
+export declare function getBoundLockList(): Promise<BoundLockListItem[]>;
+export declare function getUnbindLockList(): Promise<UnbindLockListItem[]>;
 export declare function bindLockToFit(lock: UnbindLockItem): Promise<unknown>;
 export declare function unbindLockToFit(lock: BoundFitLockItem & {
     bindingId: string;

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

@@ -1,8 +1,9 @@
 import { type FitStartAddUnlockMethodResult } from "../../../feature/fit/method/add-flow";
 import type { FitAddPasswordParams, FitAddUnlockMethodEvent, FitAddUnlockMethodListener, FitCancelAddUnlockMethodParams, FitStartAddUnlockMethodParams, FitUnlockMethodDevice, FitUnlockMethodItem, FitUpdateUnlockMethodParams, GetFitUnlockMethodListParams } from "../../../feature/fit/method/types";
-import { UpdateFitBleKeyParams, RenameFitBleKeyParams } from "../../../feature/fit/ble-key";
+import { CreateTemporaryBleKeyParams, UpdateTemporaryBleKeyParams, RenameFitBleKeyParams } from "../../../feature/fit/ble-key";
 import { type FitUserItem } from "../../../feature/fit/users";
-export type { FitAddPasswordParams, FitStartAddUnlockMethodParams, FitCancelAddUnlockMethodParams, FitUpdateUnlockMethodParams, FitAddUnlockMethodEvent, FitAddUnlockMethodListener, FitStartAddUnlockMethodResult, FitUserItem, FitUnlockMethodDevice, FitUnlockMethodItem, GetFitUnlockMethodListParams, };
+import type { FitBleKeyItem } from "../../../interface";
+export type { FitAddPasswordParams, FitStartAddUnlockMethodParams, FitCancelAddUnlockMethodParams, FitUpdateUnlockMethodParams, FitAddUnlockMethodEvent, FitAddUnlockMethodListener, FitStartAddUnlockMethodResult, FitUserItem, FitUnlockMethodDevice, FitUnlockMethodItem, GetFitUnlockMethodListParams, FitBleKeyItem, CreateTemporaryBleKeyParams, };
 export declare function fitAddPassword(params: FitAddPasswordParams): Promise<void>;
 export declare function fitStartAddUnlockMethod(params: FitStartAddUnlockMethodParams): Promise<FitStartAddUnlockMethodResult>;
 export declare function fitCancelAddUnlockMethod(params: FitCancelAddUnlockMethodParams): Promise<void>;
@@ -11,12 +12,12 @@ export declare function offFitAddUnlockMethod(listener: FitAddUnlockMethodListen
 export declare function fitUpdateUnlockMethod(params: FitUpdateUnlockMethodParams): Promise<void>;
 export declare function fitDeleteUnlockMethod(id: number, lockDevId?: string): Promise<void>;
 export declare function getFitUnlockMethodList(params: GetFitUnlockMethodListParams): Promise<FitUnlockMethodItem[]>;
-export declare function syncFitBindings(): Promise<void>;
-export declare function syncFitReport(ins: string): Promise<unknown>;
-export declare function syncOpenModeRise(dpIds: string): Promise<unknown>;
-export declare function getFitBleKeyList(): Promise<unknown[]>;
+export declare function syncOpenModeRise(dpCodes?: string[]): Promise<import("../../../api/fit").SyncOpenModeRiseResult>;
+export declare function getFitBleKeyList(): Promise<FitBleKeyItem[]>;
 export declare function addFitBleKey(params: Record<string, unknown>): Promise<unknown>;
-export declare function updateFitBleKey(params: UpdateFitBleKeyParams): Promise<unknown>;
+export declare function createFitPermanentBleKey(userId: string): Promise<unknown>;
+export declare function createFitTemporaryBleKey(params: CreateTemporaryBleKeyParams): Promise<unknown>;
+export declare function updateFitTemporaryBleKey(params: UpdateTemporaryBleKeyParams): Promise<unknown>;
 interface RemoveFitBleKeyParams {
     id: string;
 }

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

@@ -4,8 +4,8 @@ import { fitCancelAddUnlockMethodForRuntime, fitStartAddUnlockMethodForRuntime,
 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 { syncOpenModeRiseForRuntime } from "../../../feature/fit/sync";
+import { getFitBleKeyListForRuntime, addFitBleKeyForRuntime, createFitPermanentBleKeyForRuntime, createFitTemporaryBleKeyForRuntime, updateFitTemporaryBleKeyForRuntime, removeFitBleKeyForRuntime, renameFitBleKeyForRuntime, } from "../../../feature/fit/ble-key";
 import { setFitSettingForRuntime } from "../../../feature/fit/setting";
 import { getFitUsersForRuntime, } from "../../../feature/fit/users";
 export function fitAddPassword(params) {
@@ -32,14 +32,8 @@ export function fitDeleteUnlockMethod(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 syncOpenModeRise(dpCodes) {
+    return syncOpenModeRiseForRuntime(resolveRuntimeFromExportThis(this), dpCodes);
 }
 export function getFitBleKeyList() {
     return getFitBleKeyListForRuntime(resolveRuntimeFromExportThis(this));
@@ -47,8 +41,14 @@ export function getFitBleKeyList() {
 export function addFitBleKey(params) {
     return addFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
 }
-export function updateFitBleKey(params) {
-    return updateFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
+export function createFitPermanentBleKey(userId) {
+    return createFitPermanentBleKeyForRuntime(resolveRuntimeFromExportThis(this), userId);
+}
+export function createFitTemporaryBleKey(params) {
+    return createFitTemporaryBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export function updateFitTemporaryBleKey(params) {
+    return updateFitTemporaryBleKeyForRuntime(resolveRuntimeFromExportThis(this), params);
 }
 export function removeFitBleKey(params) {
     return removeFitBleKeyForRuntime(resolveRuntimeFromExportThis(this), params.id);

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

@@ -1,3 +1,6 @@
 export * from "./binding";
 export * from "./device";
+export * from "./log";
+export * from "./misc";
+export * from "./state";
 export * from "./temp";

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

@@ -1,3 +1,6 @@
 export * from "./binding";
 export * from "./device";
+export * from "./log";
+export * from "./misc";
+export * from "./state";
 export * from "./temp";

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

@@ -0,0 +1,7 @@
+import { GetAlarmsParams } from "../../../feature/log/log";
+import { type GetFitLogsParams } from "../../../feature/fit/log";
+export type { GetFitLogsParams };
+export declare function getActivePeriod(): Promise<number>;
+export declare function getLogs(params?: GetFitLogsParams): Promise<import("../../../feature/log/log").GetLogsResult>;
+export declare function getAlarms(params?: GetAlarmsParams): Promise<import("../../../feature/log/log").GetAlarmsResult>;
+export declare function getAlarmUnreadCount(): Promise<number>;

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

@@ -0,0 +1,15 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getActivePeriodForRuntime, getAlarmsForRuntime, getAlarmUnreadCountForRuntime, } from "../../../feature/log/log";
+import { getFitLogsForRuntime, } from "../../../feature/fit/log";
+export async function getActivePeriod() {
+    return getActivePeriodForRuntime(resolveRuntimeFromExportThis(this));
+}
+export async function getLogs(params) {
+    return getFitLogsForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getAlarms(params) {
+    return getAlarmsForRuntime(resolveRuntimeFromExportThis(this), params);
+}
+export async function getAlarmUnreadCount() {
+    return getAlarmUnreadCountForRuntime(resolveRuntimeFromExportThis(this));
+}

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

@@ -0,0 +1,5 @@
+import type { OpenSceneOptions } from "../../../feature/misc/types";
+export declare function connectDevice(options?: {
+    timeout?: number;
+}): Promise<true>;
+export declare function openScene(options?: OpenSceneOptions): Promise<void>;

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

@@ -0,0 +1,9 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { connectDeviceForRuntime } from "../../../feature/misc/connect-device";
+import { openSceneForRuntime } from "../../../feature/misc/open-scene";
+export async function connectDevice(options) {
+    return connectDeviceForRuntime(resolveRuntimeFromExportThis(this), options?.timeout);
+}
+export async function openScene(options) {
+    return openSceneForRuntime(resolveRuntimeFromExportThis(this), options);
+}

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

@@ -0,0 +1,4 @@
+import type { ProductSpecResult } from "../../../api/product";
+export type { ProductSpecResult };
+export declare function getProductInstVideo(): Promise<ProductSpecResult>;
+export declare function getProductEBook(): Promise<ProductSpecResult>;

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

@@ -0,0 +1,8 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getProductInstVideoForRuntime, getProductEBookForRuntime, } from "../../../feature/fit/product";
+export function getProductInstVideo() {
+    return getProductInstVideoForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getProductEBook() {
+    return getProductEBookForRuntime(resolveRuntimeFromExportThis(this));
+}

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

@@ -0,0 +1,4 @@
+import { type DeviceStatus } from "../../../interface";
+export declare function getDeviceStatus(): DeviceStatus;
+export declare function onDeviceStatusChange(callback: (status: DeviceStatus) => void): void;
+export declare function offDeviceStatusChange(callback: (status: DeviceStatus) => void): void;

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

@@ -0,0 +1,12 @@
+import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
+import { getDeviceStatusForRuntime } from "../../../feature/state/device-status";
+import { onDeviceStatusChangeForRuntime, offDeviceStatusChangeForRuntime, } from "../../../feature/state/device-status-events";
+export function getDeviceStatus() {
+    return getDeviceStatusForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function onDeviceStatusChange(callback) {
+    onDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}
+export function offDeviceStatusChange(callback) {
+    offDeviceStatusChangeForRuntime(resolveRuntimeFromExportThis(this), callback);
+}

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

@@ -1,4 +1,9 @@
-import { type AddFitTempPwdParams, type RemoveFitTempPwdParams, type RenameFitTempPwdParams, type UpdateFitTempPwdParams } from "../../../feature/fit/temp-password";
+import { type FitOnlinePasswordItem, type FitOfflinePasswordItem } from "../../../feature/fit/password-list";
+import { type AddFitTempPwdParams, type RemoveFitTempPwdParams, type RenameFitTempPwdParams, type RenameFitOfflineTempPwdParams, type RevokeFitOfflineTempPwdParams, type FitOfflineClearCodeResult, type ResendFitTempPwdParams, type UpdateFitTempPwdParams } from "../../../feature/fit/temp-password";
+import { type ClearFitInvalidPwdParams, type GetFitInvalidPwdListParams } from "../../../feature/fit/invalid-password";
+import { type FitOfflineOnceResult } from "../../../feature/password/temporary/offline-create";
+import type { LimitOfflinePwdItem, OfflinePwdAvailableResult } from "../../../api/temp";
+import type { TempPasswordResult } from "../../../interface";
 export declare function getFitPasswordList(): Promise<{
     id: number;
     unlockId: string;
@@ -8,12 +13,28 @@ export declare function getFitPasswordList(): Promise<{
     lockUserId: number;
     userType: number;
     devLockId: string;
-    effective: import("../../..").EffectiveConfig;
+    effective: import("../../../interface").EffectiveConfig;
 }[]>;
+export declare function getFitOnlinePasswordList(): Promise<FitOnlinePasswordItem[]>;
+export declare function getFitOfflinePasswordList(): Promise<FitOfflinePasswordItem[]>;
 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, };
+export declare function renameFitOfflineTempPwd(params: RenameFitOfflineTempPwdParams): Promise<void>;
+export declare function revokeFitOfflineTempPwd(params: RevokeFitOfflineTempPwdParams): Promise<FitOfflineClearCodeResult>;
+export declare function resendFitTempPwd(params: ResendFitTempPwdParams): Promise<boolean>;
+export declare function getFitInvalidPwdList(params?: GetFitInvalidPwdListParams): Promise<import("../../../api/fit").FitInvalidPwdListResult>;
+export declare function clearFitInvalidPwd(params?: ClearFitInvalidPwdParams): Promise<boolean>;
+export declare function getFitDynamicPassword(): Promise<TempPasswordResult>;
+export declare function getFitOfflineOncePassword(): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineLimitPassword(params: {
+    effectiveTime: number;
+    invalidTime: number;
+}): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineClearAllCode(): Promise<FitOfflineOnceResult>;
+export declare function getFitOfflineRevocableList(): Promise<LimitOfflinePwdItem[]>;
+export declare function getFitOfflinePwdAvailable(pwdType: string): Promise<OfflinePwdAvailableResult>;
+export type { AddFitTempPwdParams, RemoveFitTempPwdParams, UpdateFitTempPwdParams, RenameFitTempPwdParams, RenameFitOfflineTempPwdParams, RevokeFitOfflineTempPwdParams, FitOfflineClearCodeResult, ResendFitTempPwdParams, GetFitInvalidPwdListParams, ClearFitInvalidPwdParams, FitOnlinePasswordItem, FitOfflinePasswordItem, FitOfflineOnceResult, OfflinePwdAvailableResult, LimitOfflinePwdItem, };