@ray-js/lock-sdk 1.2.0-beta.8 → 1.2.0

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/gesture.d.ts

@@ -0,0 +1,11 @@
+export interface GestureStatus {
+    status: boolean;
+    password: string;
+    [k: string]: any;
+}
+export declare const getGestureStatusApi: (devId: string) => Promise<GestureStatus>;
+export declare const setGestureStatusApi: (params: {
+    devId: string;
+    password: string;
+    open: boolean;
+}) => Promise<boolean>;

package/lib/api/gesture.js

@@ -0,0 +1,18 @@
+import { THING } from "../utils/constant";
+import { requestApi } from "./request";
+export const getGestureStatusApi = (devId) => {
+    return requestApi({
+        logName: "getGestureStatus",
+        api: `${THING}.m.device.lock.gesturepwd.check`,
+        version: "1.0",
+        data: { devId },
+    });
+};
+export const setGestureStatusApi = (params) => {
+    return requestApi({
+        logName: "setGestureStatus",
+        api: `${THING}.m.device.lock.gesturepwd.set`,
+        version: "1.0",
+        data: params,
+    });
+};

package/lib/api/log.d.ts

@@ -1,4 +1,16 @@
-import { DpValue, LocalOperateRecordInfo, MediaInfo } from "../interface";
+import { DpValue, LocalOperateRecordInfo } from "../interface";
+interface MediaInfoRecord {
+    mediaPath: string;
+    fileKey: string;
+    fileUrl: string;
+    mediaBucket: string;
+    mediaKey: string;
+    positionWidth: number;
+    positionHeight: number;
+    positionAngle: number;
+    positionVr: 0 | 1;
+    position: number;
+}
 interface UnionUnlockInfo {
     userId: string;
     userName: string;
@@ -37,7 +49,7 @@ interface LogInfo {
     dps: Record<number, any>[];
     gmtCreate: number;
     historyId: number;
-    mediaInfoList?: MediaInfo[];
+    mediaInfoList?: MediaInfoRecord[];
     memberBindableFlag: 0 | 1;
     recordId: string;
     recordType: string;
@@ -62,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;
@@ -77,7 +118,7 @@ export interface LockLogListItem {
     relateDevName?: string;
     relateOpMode?: string;
     unionUnlockInfo?: UnionUnlockInfo[];
-    mediaInfoList?: MediaInfo[];
+    mediaInfoList?: MediaInfoRecord[];
     localOperateRecordInfo?: LocalOperateRecordInfo;
     data?: boolean | number | string;
     dpId: number;
@@ -115,7 +156,7 @@ interface AlarmData {
     unlockName: string;
     userId: string;
     userName: string;
-    mediaInfoList?: MediaInfo[];
+    mediaInfoList?: MediaInfoRecord[];
 }
 interface GetAlarmListResult {
     datas: AlarmData[];
@@ -123,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;
@@ -151,6 +194,11 @@ interface AlbumItem {
     fileUrl: string;
     mediaBucket: string;
     mediaKey: string;
+    width: number;
+    height: number;
+    angle: number;
+    position: number;
+    vr: 0 | 1;
 }
 export declare const getAlbumMessages: (params: GetAlbumMessagesParams) => Promise<{
     hasNext: boolean;

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/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/api/video.d.ts

@@ -33,4 +33,8 @@ export interface MediaViewTimesResult {
 }
 export declare const getMediaViewTimes: (devId: string) => Promise<MediaViewTimesResult>;
 export declare const setMediaViewTimes: (devId: string) => Promise<MediaViewTimesResult>;
+export interface getAlbumDateListResult {
+    dateList: string[];
+}
+export declare const getAlbumDateList: (devId: string) => Promise<getAlbumDateListResult>;
 export {};

package/lib/api/video.js

@@ -50,3 +50,13 @@ export const setMediaViewTimes = (devId) => {
         },
     });
 };
+export const getAlbumDateList = (devId) => {
+    return requestApi({
+        logName: "getAlbumDateList",
+        api: "m.lock.album.media.date.list",
+        version: "1.0",
+        data: {
+            devId,
+        },
+    });
+};

package/lib/config/dp-code/index.d.ts

@@ -100,5 +100,5 @@ declare const dpCodes: {
     readonly blePswUpdate: "ble_password_update";
 };
 export type DpCodeValue = (typeof dpCodes)[keyof typeof dpCodes];
-export declare const latLogDpCodes: ("unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_offline_clear" | "unlock_offline_clear_single" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "alarm_lock" | "doorbell" | "hijack" | "family_call")[];
+export declare const latLogDpCodes: ("unlock_matter_kw" | "unlock_password" | "unlock_fingerprint" | "unlock_finger_vein" | "unlock_hand" | "unlock_dynamic" | "unlock_key" | "unlock_card" | "unlock_face" | "unlock_temporary" | "unlock_offline_pd" | "unlock_offline_clear" | "unlock_offline_clear_single" | "unlock_phone_remote" | "unlock_voice_remote" | "lock_record" | "unlock_ble" | "unlock_eye" | "unlock_double_kit" | "unlock_double_kit_w" | "alarm_lock" | "doorbell" | "hijack" | "family_call")[];
 export default dpCodes;

package/lib/config/dp-code/index.js

@@ -123,5 +123,6 @@ export const latLogDpCodes = [
     dpCodes.unlockOfflineClear,
     dpCodes.unlockOfflineClearSingle,
     dpCodes.familyCall,
+    dpCodes.unlockMatterKw,
 ];
 export default dpCodes;

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

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

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

@@ -1,12 +1,27 @@
-import { addEvents } from "../../../feature/state/platform-routing";
+import { addEvents, removeEvents, } from "../../../feature/state/platform-routing";
 import { initState } from "../../../feature/state/init-state";
-import { registerRuntime } from "../../../runtime/registry";
-import { buildLockSDKInstance, } from "../build-instance";
+import { clearStateForRuntime } from "../../../feature/state/clear";
+import { registerRuntime, unregisterRuntime, getRegisteredRuntimeCount, } from "../../../runtime/registry";
+import { buildSDKInstance } from "../build-instance";
 import { createBootstrappedRuntime } from "./bootstrap";
-export async function bootstrapRegisteredLockInstance(options) {
-    const runtime = await createBootstrappedRuntime(options);
+import { startFitSyncReportForRuntime } from "../../../feature/fit/sync";
+export async function bootstrapRegisteredInstance(kind, options) {
+    const runtime = await createBootstrappedRuntime(kind, options);
     registerRuntime(runtime);
-    addEvents(runtime);
-    await initState(runtime);
-    return { runtime, instance: buildLockSDKInstance(runtime) };
+    try {
+        addEvents(runtime);
+        await initState(runtime);
+        if (kind === "fit") {
+            startFitSyncReportForRuntime(runtime);
+        }
+        return { runtime, instance: buildSDKInstance(runtime) };
+    }
+    catch (error) {
+        unregisterRuntime(runtime.devId);
+        clearStateForRuntime(runtime);
+        if (getRegisteredRuntimeCount() === 0) {
+            removeEvents();
+        }
+        throw error;
+    }
 }

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

@@ -1,4 +1,5 @@
 import type { LockSDKOption } from "../../../interface";
 import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
-export declare function applyLockOptionsToRuntime(runtime: LockDeviceRuntime, options?: LockSDKOption): Promise<void>;
-export declare function createBootstrappedRuntime(options?: LockSDKOption): Promise<LockDeviceRuntime>;
+export type SDKKind = "lock" | "fit" | "screen";
+export declare function applyOptionsToRuntime(runtime: LockDeviceRuntime, kind: SDKKind, options?: LockSDKOption): Promise<void>;
+export declare function createBootstrappedRuntime(kind: SDKKind, options?: LockSDKOption): Promise<LockDeviceRuntime>;

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

@@ -1,9 +1,10 @@
 import dpCodes from "../../../config/dp-code";
 import { getCapabilities } from "../../../utils";
-import { getDeviceInfo, trackEvent, } from "../../../platform/device";
+import { getDeviceInfo, trackEvent } from "../../../platform/device";
 import { LockDeviceRuntime } from "../../../runtime/LockDeviceRuntime";
 import { sdkLog, setSDKLogConfig } from "../../../utils/sdk-log";
-export async function applyLockOptionsToRuntime(runtime, options) {
+export async function applyOptionsToRuntime(runtime, kind, options) {
+    const isFit = kind === "fit";
     setSDKLogConfig({
         level: options?.logLevel ?? "warn",
         sink: options?.logger,
@@ -12,7 +13,7 @@ export async function applyLockOptionsToRuntime(runtime, options) {
     const { config } = runtime;
     let { devInfo, deviceId } = options || {};
     if (!devInfo && !deviceId) {
-        throw new Error("deviceId is required in lock sdk");
+        throw new Error(`deviceId is required in ${isFit ? "fit" : "lock"} sdk`);
     }
     if (deviceId && (!devInfo || devInfo.devId !== deviceId)) {
         devInfo = await getDeviceInfo(deviceId);
@@ -36,6 +37,7 @@ export async function applyLockOptionsToRuntime(runtime, options) {
             idsByCode[item.code] = item.id;
         });
     }
+    config.isFitting = isFit;
     config.strictMode = options?.strictMode ?? true;
     config.passwordDigitalBase = options?.passwordDigitalBase ?? 10;
     config.passwordSupportZero = options?.passwordSupportZero ?? true;
@@ -47,8 +49,10 @@ export async function applyLockOptionsToRuntime(runtime, options) {
     config.idsByCode = idsByCode;
     config.supportBigData = !!dpSchema[dpCodes.synchMethodW];
     config.preFetch = options?.preFetch ?? false;
+    config.localCache = options?.localCache ?? true;
+    config.notSupportWake = options?.notSupportWake ?? false;
     config.communication = getCapabilities(devInfo.capability).map((item) => item.id);
-    sdkLog("info", "bootstrap", "applyOptions", {
+    sdkLog("info", isFit ? "fit-bootstrap" : "bootstrap", "applyOptions", {
         devId: config.devInfo.devId,
         data: {
             productId: config.devInfo.productId,
@@ -62,8 +66,8 @@ export async function applyLockOptionsToRuntime(runtime, options) {
         pid: devInfo.productId,
     });
 }
-export async function createBootstrappedRuntime(options) {
+export async function createBootstrappedRuntime(kind, options) {
     const runtime = new LockDeviceRuntime();
-    await applyLockOptionsToRuntime(runtime, options);
+    await applyOptionsToRuntime(runtime, kind, options);
     return runtime;
 }

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

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

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

@@ -4,7 +4,7 @@ let primaryRuntime = null;
 export function setPrimaryLockSDKInstance(instance) {
     const runtime = getRuntimeForLockSDKInstance(instance);
     if (!runtime) {
-        throw new Error("setPrimaryLockSDKInstance: instance must be returned by createLockSDK or init");
+        throw new Error("setPrimaryLockSDKInstance: instance must be returned by createSDK or init");
     }
     primaryDevId = runtime.devId;
     primaryRuntime = runtime;

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

@@ -21,7 +21,7 @@ export function resolveRuntimeFromExportThis(thisArg) {
         }
         const rt = getRuntimeByDevId(devId);
         if (!rt) {
-            throw new Error(`Lock SDK: no registered runtime for devId "${devId}"; use createLockSDK or init first`);
+            throw new Error(`Lock SDK: no registered runtime for devId "${devId}"; use createSDK or init first`);
         }
         return rt;
     }

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

@@ -1,7 +1,10 @@
 import type { LockDeviceRuntime } from "../../runtime/LockDeviceRuntime";
+import { type UpdateConfigParams } from "../../feature/misc/update-config";
 import * as DeviceExports from "./exports";
-export interface LockSDKInstance extends Omit<typeof DeviceExports, ""> {
+export type LockSDKInstance = {
     destroy(): void;
-}
+    updateConfig(options: UpdateConfigParams): void;
+} & Omit<typeof DeviceExports, "updateConfig">;
+export type FitSDKInstance = LockSDKInstance;
 export declare function getFlatInstanceMethodKeysForTests(): string[];
-export declare function buildLockSDKInstance(runtime: LockDeviceRuntime): LockSDKInstance;
+export declare function buildSDKInstance(runtime: LockDeviceRuntime): LockSDKInstance;

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

@@ -4,6 +4,8 @@ import { unregisterRuntime, getRegisteredRuntimeCount, } from "../../runtime/reg
 import { clearStateForRuntime } from "../../feature/state/clear";
 import { removeEvents } from "../../feature/state/platform-routing";
 import { sdkLog } from "../../utils/sdk-log";
+import { stopFitSyncReportForRuntime } from "../../feature/fit/sync";
+import { updateConfigForRuntime, } from "../../feature/misc/update-config";
 import * as DeviceExports from "./exports";
 const RESERVED_INSTANCE_METHOD_KEYS = new Set(["destroy", "updateConfig"]);
 let cachedFlatExportKeys = null;
@@ -20,17 +22,27 @@ function collectFlatInstanceExportKeys() {
 export function getFlatInstanceMethodKeysForTests() {
     return collectFlatInstanceExportKeys();
 }
-export function buildLockSDKInstance(runtime) {
+export function buildSDKInstance(runtime) {
     const instance = {
         destroy() {
             sdkLog("info", "lifecycle", "destroy", { devId: runtime.devId });
             unregisterRuntime(runtime.devId);
             clearPrimaryLockSDKInstanceIfDevId(runtime.devId);
+            if (runtime.config.isFitting) {
+                stopFitSyncReportForRuntime(runtime);
+            }
             clearStateForRuntime(runtime);
             if (getRegisteredRuntimeCount() === 0) {
                 removeEvents();
             }
         },
+        updateConfig(options) {
+            sdkLog("info", "lifecycle", "updateConfig", {
+                devId: runtime.devId,
+                data: { keys: Object.keys(options) },
+            });
+            updateConfigForRuntime(runtime, options);
+        },
     };
     registerLockSDKInstanceRuntime(instance, runtime);
     sdkLog("info", "lifecycle", "createInstance", { devId: runtime.devId });

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

@@ -4,3 +4,5 @@ export declare function isBlePureDevice(): boolean;
 export declare function isShareThead(): boolean;
 export declare function isActiveThread(): Promise<boolean>;
 export declare function getDeviceAdvancedAbilities(): Promise<import("../../..").DeviceAdvancedAbility>;
+export declare function getDeviceAdvancedAbilitiesSync(): import("../../..").DeviceAdvancedAbility | undefined;
+export declare function getDeviceCapabilities(): import("../../..").CapabilityInfo | null;

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

@@ -1,5 +1,5 @@
 import { resolveRuntimeFromExportThis } from "../bootstrap/resolve-runtime-from-export-this";
-import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, isShareTheadForRuntime, isActiveThreadForRuntime, getDeviceAdvancedAbilitiesForRuntime, } from "../../../feature/misc/capability";
+import { hasCapabilityForRuntime, isBlePureDeviceForRuntime, isShareTheadForRuntime, isActiveThreadForRuntime, getDeviceAdvancedAbilitiesForRuntime, getDeviceAdvancedAbilitiesSyncForRuntime, getDeviceCapabilitiesForRuntime, } from "../../../feature/misc/capability";
 export function hasCapability(capability) {
     return hasCapabilityForRuntime(resolveRuntimeFromExportThis(this), capability);
 }
@@ -15,3 +15,9 @@ export async function isActiveThread() {
 export async function getDeviceAdvancedAbilities() {
     return getDeviceAdvancedAbilitiesForRuntime(resolveRuntimeFromExportThis(this));
 }
+export function getDeviceAdvancedAbilitiesSync() {
+    return getDeviceAdvancedAbilitiesSyncForRuntime(resolveRuntimeFromExportThis(this));
+}
+export function getDeviceCapabilities() {
+    return getDeviceCapabilitiesForRuntime(resolveRuntimeFromExportThis(this));
+}