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

package/lib/api/ble.d.ts

@@ -0,0 +1,57 @@
+export type VirtualKeyTimeSetType = 0 | 10 | 20 | 30;
+export interface VirtualKeyAddSchedule {
+    allDay: boolean;
+    effectiveTime?: number;
+    invalidTime?: number;
+    workingDay?: number;
+}
+export interface AddLockVirtualKeyParams {
+    devId: string;
+    timeSetType: VirtualKeyTimeSetType;
+    effectiveTime: number;
+    invalidTime: number;
+    availTime?: number;
+    name: string;
+    schedule?: VirtualKeyAddSchedule[];
+    countryCode: string;
+    account: string;
+    offlineUnlock: boolean;
+}
+export interface AddLockVirtualKeyResult {
+    unlockBindingId: string;
+    name: string;
+    userExist: boolean;
+}
+export declare const addLockVirtualKey: (params: AddLockVirtualKeyParams) => Promise<AddLockVirtualKeyResult>;
+export type VirtualKeyPhase = 2 | 4;
+export interface UpdateLockVirtualKeyParams {
+    devId: string;
+    unlockBindingId: string;
+    offlineUnlock: boolean;
+    timeSetType: VirtualKeyTimeSetType;
+    effectiveTime: number;
+    invalidTime: number;
+    availTime?: number;
+    name?: string;
+    phase?: VirtualKeyPhase;
+    schedule?: {
+        allDay: boolean;
+        effectiveTime?: number;
+        invalidTime?: number;
+        workingDay?: number;
+    }[];
+}
+export declare const updateLockVirtualKey: (params: UpdateLockVirtualKeyParams) => Promise<true>;
+export interface RemoveLockVirtualKeyParams {
+    devId: string;
+    unlockBindingId: string;
+}
+export declare const removeLockVirtualKey: (params: RemoveLockVirtualKeyParams) => Promise<boolean>;
+export declare const removeLockVirtualKeyBinding: (devId: string, unlockBindingId: string) => Promise<boolean>;
+export declare const updateLockVirtualKeyStatus: (devId: string, unlockBindingId: string, phase: number) => Promise<unknown>;
+export interface RenameLockVirtualKeyParams {
+    devId: string;
+    unlockBindingId: string;
+    name: string;
+}
+export declare const renameLockVirtualKey: (params: RenameLockVirtualKeyParams) => Promise<true>;

package/lib/api/ble.js

@@ -0,0 +1,46 @@
+import { THING } from "../utils/constant";
+import { requestApi } from "./request";
+export const addLockVirtualKey = (params) => {
+    return requestApi({
+        logName: "addLockVirtualKey",
+        api: `${THING}.m.device.lock.key.virtual.add`,
+        version: "1.0",
+        data: { ...params },
+    });
+};
+export const updateLockVirtualKey = (params) => {
+    return requestApi({
+        logName: "updateLockVirtualKey",
+        api: `${THING}.m.device.lock.key.virtual.update`,
+        version: "1.0",
+        data: { ...params },
+    });
+};
+export const removeLockVirtualKey = (params) => {
+    return requestApi({
+        logName: "removeLockVirtualKey",
+        api: `${THING}.m.device.lock.key.virtual.remove`,
+        version: "1.0",
+        data: {
+            devId: params.devId,
+            unlockBindingId: params.unlockBindingId,
+        },
+    });
+};
+export const removeLockVirtualKeyBinding = (devId, unlockBindingId) => removeLockVirtualKey({ devId, unlockBindingId });
+export const updateLockVirtualKeyStatus = (devId, unlockBindingId, phase) => {
+    return requestApi({
+        logName: "updateLockVirtualKeyStatus",
+        api: `${THING}.m.device.lock.key.virtual.phase`,
+        version: "1.0",
+        data: { devId, unlockBindingId, phase },
+    });
+};
+export const renameLockVirtualKey = (params) => {
+    return requestApi({
+        logName: "renameLockVirtualKey",
+        api: `${THING}.m.device.lock.key.virtual.name`,
+        version: "1.0",
+        data: { ...params },
+    });
+};

package/lib/api/fit.d.ts

@@ -0,0 +1,203 @@
+import { UserType } from "../constant";
+export interface LockFitItemBase {
+    devId: string;
+    devUnlockId: string;
+    devUuid: string;
+    fittingId: string;
+    fittingUnlockId: string;
+    icon: string;
+    isSupportScy: boolean;
+    online: boolean;
+    protocolVersion: string;
+    randomStr: string;
+}
+export interface UnbindFitItem extends LockFitItemBase {
+    fittingName: string;
+}
+export interface UnbindLockItem extends LockFitItemBase {
+    devName: string;
+}
+export interface BoundFitLockItem extends LockFitItemBase {
+    bindingId: string;
+    devName: string;
+    fittingName: string;
+}
+export interface BindLockAndFitParams {
+    devId: string;
+    fittingId: string;
+    stage: 1 | 2;
+}
+export interface UnbindFitFromLockCloudParams {
+    devId: string;
+    bindingId: string;
+}
+export interface UnbindLockFromFitCloudParams {
+    fittingId: string;
+    bindingId: string;
+}
+export declare const getBoundFitListApi: (devId: string) => Promise<BoundFitLockItem[]>;
+export declare const getUnbindFitListApi: (devId: string) => Promise<UnbindFitItem[]>;
+export declare const getBoundLockListApi: (fittingId: string) => Promise<BoundFitLockItem[]>;
+export declare const getUnbindLockListApi: (fittingId: string) => Promise<UnbindLockItem[]>;
+export declare const bindLockAndFit: (params: BindLockAndFitParams) => Promise<unknown>;
+export declare const unbindFitFromLockCloud: (params: UnbindFitFromLockCloudParams) => Promise<unknown>;
+export declare const unbindLockFromFitCloud: (params: UnbindLockFromFitCloudParams) => Promise<unknown>;
+export interface SyncFitToLockRiseResult {
+    distributed: boolean;
+    ins: string[];
+}
+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 RawPasswordItem {
+    unlockBindingId: number;
+    effectiveTime: number;
+    invalidTime: number;
+    passWord: string;
+    name: string;
+    mobile: string;
+    scheduleDetails: RawFitOpenModeScheduleItem[];
+    devNameList: string[];
+    devIdList: string[];
+    opModeType: number;
+    opModeSubType: number;
+    sn: number;
+    userType: number;
+    userName: string;
+    lockUserId: number;
+    devUnlockId: string;
+    hijack: boolean;
+    operate: number;
+    msgId: number;
+    pwdId: number;
+    gmtCreate: number;
+}
+export declare const getFitPasswordList: (fittingId: string) => Promise<RawPasswordItem[]>;
+export interface RawFitUserItem {
+    userId: string;
+    uid: string;
+    lockUserId: number;
+    userContact: string;
+    nickName: string;
+    avatarUrl: string;
+    userType: UserType;
+    supportOpenType: number[];
+    allOpenType: number[];
+    status: 0 | 1;
+    userTimeSet: string;
+    shareUser: string;
+    productAttribute: number;
+    phase: number;
+}
+export declare const getFitUserListApi: (fittingId: string) => Promise<RawFitUserItem[]>;
+interface AddFitOpenModeParams {
+    devIdList: string[];
+    fittingId: string;
+    unlockId: string;
+    unlockName: string;
+    userId: string;
+    hijack: boolean;
+}
+export declare const addFitOpenMode: (params: AddFitOpenModeParams) => Promise<unknown>;
+interface UpdateFitOpenModeParams {
+    opModeId: number;
+    fittingId: string;
+    unlockName: string;
+    hijack: boolean;
+}
+export declare const updateFitOpenMode: (params: UpdateFitOpenModeParams) => Promise<unknown>;
+export declare const removeFitOpenMode: (fittingId: string, opModeId: string) => Promise<unknown>;
+export interface RawFitOpenModeScheduleItem {
+    allDay: boolean;
+    effectiveTime: number;
+    invalidTime: number;
+    timeZoneId: string;
+    workingDay: number;
+}
+export interface RawFitOpenModeItem {
+    unlockBindingId: number;
+    effectiveTime: number;
+    passWord?: string;
+    invalidTime: number;
+    name: string;
+    mobile?: string;
+    scheduleDetails?: RawFitOpenModeScheduleItem[];
+    devNameList?: string[];
+    devIdList?: string[];
+    opModeType: number;
+    opModeSubType?: number;
+    sn: number;
+    userType: number;
+    userName: string;
+    lockUserId: number;
+    devUnlockId: string;
+    hijack?: boolean;
+    revokedPwdName?: string;
+    revokedPwdEffectiveTime?: number;
+    revokedPwdInvalidTime?: number;
+    mayExpired?: boolean;
+    admin?: boolean;
+    operate?: number;
+    msgId?: number;
+    pwdId: number;
+    gmtCreate: number;
+}
+export declare const getFitOpenModeList: (fittingId: string, dpId?: number) => Promise<RawFitOpenModeItem[]>;
+export declare const getFitBleKeyListApi: (fittingId: string) => Promise<unknown[]>;
+export declare const addFitBleKeyApi: (fittingId: string, params: Record<string, unknown>) => Promise<unknown>;
+interface UpdateFitBleKeyParams {
+    unlockBindingId: string;
+    name: string;
+    effectiveTime: number;
+    invalidTime: number;
+    schedule: {
+        allDay: boolean;
+        effectiveTime: number;
+        invalidTime: number;
+        workingDay: number;
+    }[];
+    timeSetType: 20 | 30;
+}
+export declare const updateFitBleKeyApi: (fittingId: string, params: UpdateFitBleKeyParams) => Promise<unknown>;
+export declare const removeFitBleKeyApi: (fittingId: string, unlockBindingId: string) => Promise<unknown>;
+export declare const renameFitBleKeyApi: (fittingId: string, params: {
+    unlockBindingId: string;
+    name: string;
+}) => Promise<unknown>;
+export interface AddFitOnlineTempPwdSchedule {
+    allDay?: boolean;
+    workingDay?: number;
+    invalidTime?: number;
+    effectiveTime?: number;
+}
+export interface AddFitOnlineTempPwdParams {
+    fittingId: string;
+    phone?: string;
+    password: string;
+    devIdList: string[];
+    countryCode: string;
+    invalidTime: number;
+    effectiveTime: number;
+    availTime: number;
+    name?: string;
+    sn: number;
+    schedule?: {
+        allDay: boolean;
+        workingDay: number;
+        invalidTime: number;
+        effectiveTime: number;
+    }[];
+}
+export declare const addFitOnlineTempPwd: (params: AddFitOnlineTempPwdParams) => Promise<{
+    pwdId: number;
+}>;
+export interface FetchFitOnlineTempPwdMessageParams extends AddFitOnlineTempPwdParams {
+}
+export declare const addFitOnlineTempPwdCloud: (params: FetchFitOnlineTempPwdMessageParams) => Promise<{
+    msgId: number;
+    pwdId: number;
+}>;
+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 {};

package/lib/api/fit.js

@@ -0,0 +1,158 @@
+import { THING } from "../utils/constant";
+import { requestApi } from "./request";
+export const getBoundFitListApi = (devId) => requestApi({
+    logName: "getBoundFitListApi",
+    api: `${THING}.m.device.lock.fittings.list`,
+    version: "1.0",
+    data: { devId },
+});
+export const getUnbindFitListApi = (devId) => requestApi({
+    logName: "getUnbindFitListApi",
+    api: `${THING}.m.device.lock.bindings.available`,
+    version: "1.0",
+    data: { devId },
+});
+export const getBoundLockListApi = (fittingId) => requestApi({
+    logName: "getBoundLockListApi",
+    api: `${THING}.m.device.fittings.lock.list`,
+    version: "1.0",
+    data: { fittingId },
+});
+export const getUnbindLockListApi = (fittingId) => requestApi({
+    logName: "getUnbindLockListApi",
+    api: `${THING}.m.device.fittings.bindings.available`,
+    version: "1.0",
+    data: { fittingId },
+});
+export const bindLockAndFit = (params) => requestApi({
+    logName: "bindLockAndFit",
+    api: `${THING}.m.device.lock.fittings.bind`,
+    version: "1.0",
+    data: { ...params },
+});
+export const unbindFitFromLockCloud = (params) => requestApi({
+    logName: "unbindFitFromLockCloud",
+    api: `${THING}.m.device.lock.bindings.remove`,
+    version: "1.0",
+    data: { ...params },
+});
+export const unbindLockFromFitCloud = (params) => requestApi({
+    logName: "unbindLockFromFitCloud",
+    api: `${THING}.m.device.fittings.bindings.remove`,
+    version: "1.0",
+    data: { ...params },
+});
+export const syncFitToLockRise = (fittingId) => requestApi({
+    logName: "syncFitToLockRise",
+    api: `${THING}.m.device.lock.fittings.sync.rise`,
+    version: "1.0",
+    data: { fittingId },
+});
+export const syncFitReport = (fittingId, ins) => requestApi({
+    logName: "syncFitReport",
+    api: `${THING}.m.device.fitting.sync.report`,
+    version: "1.0",
+    data: { fittingId, ins },
+});
+export const syncOpenModeRise = (devId, dpIds) => requestApi({
+    logName: "syncOpenModeRise",
+    api: `${THING}.m.device.opmode.sync.rise`,
+    version: "2.0",
+    data: { devId, dpIds },
+});
+export const getFitPasswordList = (fittingId) => requestApi({
+    logName: "getFitPasswordList",
+    api: `${THING}.m.device.fittings.pwd.list`,
+    version: "1.0",
+    data: { fittingId },
+});
+export const getFitUserListApi = (fittingId) => requestApi({
+    logName: "getFitUserListApi",
+    api: `${THING}.m.device.member.list`,
+    version: "1.0",
+    data: { devId: fittingId },
+});
+export const addFitOpenMode = (params) => requestApi({
+    logName: "addFitOpenMode",
+    api: `${THING}.m.device.fittings.opmode.add`,
+    version: "1.0",
+    data: { ...params },
+});
+export const updateFitOpenMode = (params) => requestApi({
+    logName: "updateFitOpenMode",
+    api: `${THING}.m.device.fittings.opmode.update`,
+    version: "1.0",
+    data: { ...params },
+});
+export const removeFitOpenMode = (fittingId, opModeId) => requestApi({
+    logName: "removeFitOpenMode",
+    api: `${THING}.m.device.fittings.opmode.remove`,
+    version: "1.0",
+    data: { fittingId, opModeId },
+});
+export const getFitOpenModeList = (fittingId, dpId) => requestApi({
+    logName: "getFitOpenModeList",
+    api: `${THING}.m.device.member.opmode.list`,
+    version: "4.0",
+    data: { fittingId, dpId },
+});
+export const getFitBleKeyListApi = (fittingId) => requestApi({
+    logName: "getFitBleKeyListApi",
+    api: `${THING}.m.device.fittings.key.virtual.list`,
+    version: "1.0",
+    data: { fittingId },
+});
+export const addFitBleKeyApi = (fittingId, params) => requestApi({
+    logName: "addFitBleKeyApi",
+    api: `${THING}.m.device.fittings.key.virtual.add`,
+    version: "1.0",
+    data: { fittingId, ...params },
+});
+export const updateFitBleKeyApi = (fittingId, params) => requestApi({
+    logName: "updateFitBleKeyApi",
+    api: `${THING}.m.device.fittings.key.virtual.update`,
+    version: "1.0",
+    data: { fittingId, ...params },
+});
+export const removeFitBleKeyApi = (fittingId, unlockBindingId) => requestApi({
+    logName: "removeFitBleKeyApi",
+    api: `${THING}.m.device.fittings.key.virtual.remove`,
+    version: "1.0",
+    data: { fittingId, unlockBindingId },
+});
+export const renameFitBleKeyApi = (fittingId, params) => requestApi({
+    logName: "renameFitBleKeyApi",
+    api: `${THING}.m.device.fittings.key.virtual.name`,
+    version: "1.0",
+    data: { fittingId, ...params },
+});
+export const addFitOnlineTempPwd = (params) => requestApi({
+    logName: "addFitOnlineTempPwd",
+    api: `${THING}.m.device.fittings.password.temp.add`,
+    version: "1.0",
+    data: { ...params },
+});
+export const addFitOnlineTempPwdCloud = (params) => requestApi({
+    logName: "fetchFitOnlineTempPwdMessage",
+    api: `${THING}.m.device.fittings.password.temp.add`,
+    version: "2.0",
+    data: { ...params },
+});
+export const removeFitOnlineTempPwd = (fittingId, pwdId) => requestApi({
+    logName: "removeFitOnlineTempPwd",
+    api: `${THING}.m.device.fittings.password.temp.remove`,
+    version: "1.0",
+    data: { fittingId, pwdId },
+});
+export const updateFitOnlineTempPwd = (fittingId, params) => requestApi({
+    logName: "updateFitOnlineTempPwd",
+    api: `${THING}.m.device.fittings.password.temp.update`,
+    version: "1.0",
+    data: { fittingId, ...params },
+});
+export const renameFitOnlineTempPwd = (fittingId, pwdId, name) => requestApi({
+    logName: "renameFitOnlineTempPwd",
+    api: `${THING}.m.device.fittings.password.temp.name`,
+    version: "1.0",
+    data: { fittingId, pwdId, name },
+});

package/lib/api/index.d.ts

@@ -2,7 +2,7 @@ import { DpValue } from "../interface";
 export declare const sendPhoneVerifyCode: (params: {
     account: string;
     devId: string;
-}) => Promise<unknown>;
+}) => Promise<void>;
 export declare const getActiveTime: (devId: string) => Promise<string>;
 interface ProductAbility {
     abilityCode: string;

package/lib/api/index.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const sendPhoneVerifyCode = (params) => {
     return requestApi({
+        logName: "sendPhoneVerifyCode",
         api: `${THING}.m.device.user.verifycode.send`,
         version: "1.0",
         data: params,
@@ -9,6 +10,7 @@ export const sendPhoneVerifyCode = (params) => {
 };
 export const getActiveTime = (devId) => {
     return requestApi({
+        logName: "getActiveTime",
         api: `${THING}.m.device.active.date`,
         version: "1.0",
         data: { devId },
@@ -16,6 +18,7 @@ export const getActiveTime = (devId) => {
 };
 export const getProductAbilities = (devId, codes) => {
     return requestApi({
+        logName: "getProductAbilities",
         api: "m.life.app.device.product.abilities",
         version: "1.0",
         data: { deviceId: devId, abilityCodes: codes },
@@ -23,6 +26,7 @@ export const getProductAbilities = (devId, codes) => {
 };
 export const getDeviceAdvancedAbility = (devId) => {
     return requestApi({
+        logName: "getDeviceAdvancedAbility",
         api: "m.lock.add.value.device.info",
         version: "1.0",
         data: { devId },
@@ -30,6 +34,7 @@ export const getDeviceAdvancedAbility = (devId) => {
 };
 export const getVoicePwdEnabled = (devId) => {
     return requestApi({
+        logName: "getVoicePwdEnabled",
         api: `${THING}.m.device.lock.voice.pwd.flag`,
         version: "1.0",
         data: { devId },
@@ -37,6 +42,7 @@ export const getVoicePwdEnabled = (devId) => {
 };
 export const setVoicePwd = (params) => {
     return requestApi({
+        logName: "setVoicePwd",
         api: `${THING}.m.device.lock.voice.pwd.setting`,
         version: "1.0",
         data: params,
@@ -44,6 +50,7 @@ export const setVoicePwd = (params) => {
 };
 export const fetchOfflineDpData = async (deviceId) => {
     return await requestApi({
+        logName: "fetchOfflineDpData",
         api: `${THING}.m.device.cache.dp.get`,
         data: { devId: deviceId, dpCacheType: 0 },
         version: "2.0",
@@ -51,6 +58,7 @@ export const fetchOfflineDpData = async (deviceId) => {
 };
 export const publishOfflineDpData = (deviceId, dpData) => {
     return requestApi({
+        logName: "publishOfflineDpData",
         api: `${THING}.m.device.dp.publish`,
         data: {
             devId: deviceId,
@@ -65,6 +73,7 @@ export const publishOfflineDpData = (deviceId, dpData) => {
 };
 export const clearOfflineDpData = async (deviceId) => {
     return requestApi({
+        logName: "clearOfflineDpData",
         api: "m.thing.cancel.device.shadow.desired.properties",
         data: { devId: deviceId },
         version: "1.0",
@@ -72,6 +81,7 @@ export const clearOfflineDpData = async (deviceId) => {
 };
 export const getFileRemoteUrl = ({ biz, resources, }) => {
     return requestApi({
+        logName: "getFileRemoteUrl",
         api: `${THING}.web.fastroute.download.sign`,
         version: "2.0",
         data: {

package/lib/api/linkage.js

@@ -2,6 +2,7 @@ import { THING } from "../utils/constant";
 import { requestApi } from "./request";
 export const getLinkageList = (deviceId, homeId) => {
     return requestApi({
+        logName: "getLinkageList",
         api: `${THING}.m.linkage.doorlock.rule.query`,
         version: "2.0",
         data: {
@@ -14,6 +15,7 @@ export const getLinkageList = (deviceId, homeId) => {
 };
 export const saveLinkage = (data, homeId) => {
     return requestApi({
+        logName: "saveLinkage",
         api: `${THING}.m.linkage.device.shell.save`,
         version: "2.0",
         data: {
@@ -26,6 +28,7 @@ export const saveLinkage = (data, homeId) => {
 };
 export const enableLinkage = (ruleId, homeId) => {
     return requestApi({
+        logName: "enableLinkage",
         api: `${THING}.m.linkage.rule.enable`,
         version: "1.0",
         data: {
@@ -38,6 +41,7 @@ export const enableLinkage = (ruleId, homeId) => {
 };
 export const disableLinkage = (ruleId, homeId) => {
     return requestApi({
+        logName: "disableLinkage",
         api: `${THING}.m.linkage.rule.disable`,
         version: "1.0",
         data: {
@@ -50,6 +54,7 @@ export const disableLinkage = (ruleId, homeId) => {
 };
 export const getRemainingMessage = (homeId) => {
     return requestApi({
+        logName: "getRemainingMessage",
         api: `${THING}.m.notification.subscribe.info`,
         version: "1.0",
         data: {
@@ -62,6 +67,7 @@ export const getRemainingMessage = (homeId) => {
 };
 export const getRemainingPhone = (homeId) => {
     return requestApi({
+        logName: "getRemainingPhone",
         api: `${THING}.m.mobile.voice.times.count`,
         version: "1.0",
         data: {},

package/lib/api/lock.d.ts

@@ -1,5 +1,6 @@
 export declare const openDoorByCloud: (deviceId: string, isOpen: boolean) => Promise<unknown>;
 export declare const isConfirmOpenDoorByWifiPro: (deviceId: string, confirm: boolean) => Promise<unknown>;
+export declare const checkUserValidForUnlock: (devId: string) => Promise<boolean>;
 export declare const checkRemoteKey: (deviceId: string) => Promise<{
     effectiveTime: number;
     invalidTime: number;
@@ -56,10 +57,11 @@ interface CreateUnlockMethodParams {
         msgPhoneVerifyCode?: string;
     };
 }
-export declare const createUnlockMethod: (params: CreateUnlockMethodParams) => Promise<{
+export interface CreateUnlockMethodResult {
     opModeId: number;
     unlockName: string;
-}>;
+}
+export declare const createUnlockMethod: (params: CreateUnlockMethodParams) => Promise<CreateUnlockMethodResult>;
 interface EditUnlockMethodParams {
     devId: string;
     opModeId: number;