@ray-js/api 1.4.0-alpha.1 → 1.4.0-alpha.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/@types/P2PKit.d.ts +402 -0
- package/@types/all-kits.d.ts +1 -0
- package/lib/BaseKit-3.3.10.js +85 -83
- package/lib/BizKit-3.2.7.js +48 -47
- package/lib/DeviceKit-3.3.1.js +194 -193
- package/lib/HomeKit-3.1.4.js +2 -1
- package/lib/MapKit-3.0.7.js +4 -2
- package/lib/MiniKit-3.1.0.js +65 -64
- package/lib/P2PKit-2.0.3.d.ts +27 -0
- package/lib/P2PKit-2.0.3.js +79 -0
- package/lib/PlayNetKit-1.1.3.js +2 -1
- package/lib/all-kits.d.ts +1 -0
- package/lib/all-kits.js +1 -0
- package/lib/cloud/alarm.js +4 -7
- package/lib/cloud/core.js +2 -3
- package/lib/cloud/device.js +20 -31
- package/lib/cloud/interface.d.ts +7 -7
- package/lib/cloud/linkage.js +43 -41
- package/lib/cloud/statistic.js +21 -33
- package/lib/cloud/timer.js +31 -48
- package/lib/constants.js +1 -1
- package/lib/core/promisify/index.js +5 -9
- package/lib/getBoundingClientRect/index.js +16 -17
- package/lib/getBoundingClientRect/index.thing.js +16 -17
- package/lib/getBoundingClientRect/index.wechat.js +16 -17
- package/lib/getCdnUrl/index.d.ts +1 -0
- package/lib/getCdnUrl/index.js +4 -0
- package/lib/getCdnUrl/index.thing.d.ts +3 -1
- package/lib/getCdnUrl/index.thing.js +54 -19
- package/lib/getCdnUrl/index.wechat.d.ts +1 -0
- package/lib/getCdnUrl/index.wechat.js +4 -0
- package/lib/getElementById/index.js +1 -3
- package/lib/getElementById/index.thing.js +2 -4
- package/lib/getElementById/index.wechat.js +2 -4
- package/lib/index.d.ts +1 -1
- package/lib/index.js +4 -3
- package/lib/lifecycles/offAppEvent/index.js +2 -2
- package/lib/lifecycles/offAppHide/index.js +2 -2
- package/lib/lifecycles/offAppShow/index.js +2 -2
- package/lib/lifecycles/offError/index.js +2 -2
- package/lib/lifecycles/offThemeChange/index.js +2 -2
- package/lib/lifecycles/offWindowResize/index.js +2 -2
- package/lib/lifecycles/onAppEvent/index.js +2 -2
- package/lib/lifecycles/onAppHide/index.js +2 -2
- package/lib/lifecycles/onAppShow/index.js +2 -2
- package/lib/lifecycles/onError/index.js +2 -2
- package/lib/lifecycles/onPageNotFound/index.js +2 -2
- package/lib/lifecycles/onThemeChange/index.js +2 -2
- package/lib/lifecycles/onWindowResize/index.js +2 -2
- package/lib/navigateBack/index.js +3 -6
- package/lib/navigateTo/index.js +2 -5
- package/lib/onNavigationBarBack/index.js +1 -2
- package/lib/onNavigationBarBack/index.wechat.js +1 -2
- package/lib/panel/devInfo/index.js +84 -121
- package/lib/panel/i18n/index.d.ts +1 -1
- package/lib/panel/i18n/index.js +180 -262
- package/lib/panel/i18n/index.wechat.d.ts +1 -1
- package/lib/panel/i18n/index.wechat.js +184 -267
- package/lib/panel/normalizeNetwork.d.ts +2 -2
- package/lib/panel/normalizeNetwork.js +2 -7
- package/lib/panel/publishDps.d.ts +1 -1
- package/lib/panel/publishDps.js +13 -18
- package/lib/panel/types/devInfo.d.ts +3 -3
- package/lib/panel/types/utilities.d.ts +8 -8
- package/lib/panel/utils.js +1 -3
- package/lib/reLaunch/index.js +2 -5
- package/lib/redirectTo/index.js +2 -6
- package/lib/requestCloud/index.js +2 -2
- package/lib/requestCloud/index.wechat.js +0 -1
- package/lib/setNavigationBarBack/index.js +1 -2
- package/lib/setNavigationBarBack/index.wechat.js +1 -2
- package/lib/setNavigationBarColor/index.js +3 -6
- package/lib/setNavigationBarTitle/index.js +5 -6
- package/lib/switchTab/index.js +2 -5
- package/lib/utils.d.ts +1 -1
- package/lib/utils.js +5 -14
- package/lib/utils.wechat.d.ts +1 -1
- package/lib/utils.wechat.js +9 -21
- package/lib/viewAPI.js +13 -12
- package/package.json +25 -25
- package/LICENSE.md +0 -9
    
        package/lib/DeviceKit-3.3.1.js
    CHANGED
    
    | @@ -1,571 +1,572 @@ | |
| 1 1 | 
             
            /// <reference path="../@types/DeviceKit.d.ts" />
         | 
| 2 | 
            +
             | 
| 2 3 | 
             
            import { factory } from './utils';
         | 
| 3 | 
            -
            export  | 
| 4 | 
            +
            export const unregisterLeaveBeaconFenceEvent = factory('unregisterLeaveBeaconFenceEvent', {
         | 
| 4 5 | 
             
              "namespace": "device"
         | 
| 5 6 | 
             
            });
         | 
| 6 | 
            -
            export  | 
| 7 | 
            +
            export const registerLeaveBeaconFenceEvent = factory('registerLeaveBeaconFenceEvent', {
         | 
| 7 8 | 
             
              "namespace": "device"
         | 
| 8 9 | 
             
            });
         | 
| 9 | 
            -
            export  | 
| 10 | 
            +
            export const writeBeaconFenceConfig = factory('writeBeaconFenceConfig', {
         | 
| 10 11 | 
             
              "namespace": "device"
         | 
| 11 12 | 
             
            });
         | 
| 12 | 
            -
            export  | 
| 13 | 
            +
            export const readBeaconFenceConfig = factory('readBeaconFenceConfig', {
         | 
| 13 14 | 
             
              "namespace": "device"
         | 
| 14 15 | 
             
            });
         | 
| 15 | 
            -
            export  | 
| 16 | 
            +
            export const disconnectBTBond = factory('disconnectBTBond', {
         | 
| 16 17 | 
             
              "namespace": "device"
         | 
| 17 18 | 
             
            });
         | 
| 18 | 
            -
            export  | 
| 19 | 
            +
            export const connectBTBond = factory('connectBTBond', {
         | 
| 19 20 | 
             
              "namespace": "device"
         | 
| 20 21 | 
             
            });
         | 
| 21 | 
            -
            export  | 
| 22 | 
            +
            export const cancelBLEFileTransfer = factory('cancelBLEFileTransfer', {
         | 
| 22 23 | 
             
              "namespace": "device"
         | 
| 23 24 | 
             
            });
         | 
| 24 | 
            -
            export  | 
| 25 | 
            +
            export const postBLEFileTransfer = factory('postBLEFileTransfer', {
         | 
| 25 26 | 
             
              "namespace": "device"
         | 
| 26 27 | 
             
            });
         | 
| 27 | 
            -
            export  | 
| 28 | 
            +
            export const getBLEDeviceRSSI = factory('getBLEDeviceRSSI', {
         | 
| 28 29 | 
             
              "namespace": "device"
         | 
| 29 30 | 
             
            });
         | 
| 30 | 
            -
            export  | 
| 31 | 
            +
            export const subscribeBLEConnectStatus = factory('subscribeBLEConnectStatus', {
         | 
| 31 32 | 
             
              "namespace": "device"
         | 
| 32 33 | 
             
            });
         | 
| 33 | 
            -
            export  | 
| 34 | 
            +
            export const unsubscribeBLEConnectStatus = factory('unsubscribeBLEConnectStatus', {
         | 
| 34 35 | 
             
              "namespace": "device"
         | 
| 35 36 | 
             
            });
         | 
| 36 | 
            -
            export  | 
| 37 | 
            +
            export const connectBLEDevice = factory('connectBLEDevice', {
         | 
| 37 38 | 
             
              "namespace": "device"
         | 
| 38 39 | 
             
            });
         | 
| 39 | 
            -
            export  | 
| 40 | 
            +
            export const directConnectBLEDevice = factory('directConnectBLEDevice', {
         | 
| 40 41 | 
             
              "namespace": "device"
         | 
| 41 42 | 
             
            });
         | 
| 42 | 
            -
            export  | 
| 43 | 
            +
            export const disconnectBLEDevice = factory('disconnectBLEDevice', {
         | 
| 43 44 | 
             
              "namespace": "device"
         | 
| 44 45 | 
             
            });
         | 
| 45 | 
            -
            export  | 
| 46 | 
            +
            export const getBLEOnlineState = factory('getBLEOnlineState', {
         | 
| 46 47 | 
             
              "namespace": "device"
         | 
| 47 48 | 
             
            });
         | 
| 48 | 
            -
            export  | 
| 49 | 
            +
            export const subscribeBLETransparentDataReport = factory('subscribeBLETransparentDataReport', {
         | 
| 49 50 | 
             
              "namespace": "device"
         | 
| 50 51 | 
             
            });
         | 
| 51 | 
            -
            export  | 
| 52 | 
            +
            export const unsubscribeBLETransparentDataReport = factory('unsubscribeBLETransparentDataReport', {
         | 
| 52 53 | 
             
              "namespace": "device"
         | 
| 53 54 | 
             
            });
         | 
| 54 | 
            -
            export  | 
| 55 | 
            +
            export const publishBLETransparentData = factory('publishBLETransparentData', {
         | 
| 55 56 | 
             
              "namespace": "device"
         | 
| 56 57 | 
             
            });
         | 
| 57 | 
            -
            export  | 
| 58 | 
            +
            export const getEncryptLocalKeyWithData = factory('getEncryptLocalKeyWithData', {
         | 
| 58 59 | 
             
              "namespace": "device"
         | 
| 59 60 | 
             
            });
         | 
| 60 | 
            -
            export  | 
| 61 | 
            +
            export const postBLEBigDataChannelWithProgress = factory('postBLEBigDataChannelWithProgress', {
         | 
| 61 62 | 
             
              "namespace": "device"
         | 
| 62 63 | 
             
            });
         | 
| 63 | 
            -
            export  | 
| 64 | 
            +
            export const startBLEMeshLowPowerConnection = factory('startBLEMeshLowPowerConnection', {
         | 
| 64 65 | 
             
              "namespace": "device"
         | 
| 65 66 | 
             
            });
         | 
| 66 | 
            -
            export  | 
| 67 | 
            +
            export const stopBLEMeshLowPowerConnection = factory('stopBLEMeshLowPowerConnection', {
         | 
| 67 68 | 
             
              "namespace": "device"
         | 
| 68 69 | 
             
            });
         | 
| 69 | 
            -
            export  | 
| 70 | 
            +
            export const startBLEScanBeacon = factory('startBLEScanBeacon', {
         | 
| 70 71 | 
             
              "namespace": "device"
         | 
| 71 72 | 
             
            });
         | 
| 72 | 
            -
            export  | 
| 73 | 
            +
            export const stopBLEScanBeacon = factory('stopBLEScanBeacon', {
         | 
| 73 74 | 
             
              "namespace": "device"
         | 
| 74 75 | 
             
            });
         | 
| 75 | 
            -
            export  | 
| 76 | 
            +
            export const bluetoothCapabilityOfBLEBeacon = factory('bluetoothCapabilityOfBLEBeacon', {
         | 
| 76 77 | 
             
              "namespace": "device"
         | 
| 77 78 | 
             
            });
         | 
| 78 | 
            -
            export  | 
| 79 | 
            +
            export const bluetoothIsPowerOn = factory('bluetoothIsPowerOn', {
         | 
| 79 80 | 
             
              "namespace": "device"
         | 
| 80 81 | 
             
            });
         | 
| 81 | 
            -
            export  | 
| 82 | 
            +
            export const startBLEScanBindDevice = factory('startBLEScanBindDevice', {
         | 
| 82 83 | 
             
              "namespace": "device"
         | 
| 83 84 | 
             
            });
         | 
| 84 | 
            -
            export  | 
| 85 | 
            +
            export const startBLEScan = factory('startBLEScan', {
         | 
| 85 86 | 
             
              "namespace": "device"
         | 
| 86 87 | 
             
            });
         | 
| 87 | 
            -
            export  | 
| 88 | 
            +
            export const startBLEScanSync = factory('startBLEScanSync', {
         | 
| 88 89 | 
             
              "namespace": "device"
         | 
| 89 90 | 
             
            });
         | 
| 90 | 
            -
            export  | 
| 91 | 
            +
            export const stopBLEScan = factory('stopBLEScan', {
         | 
| 91 92 | 
             
              "namespace": "device"
         | 
| 92 93 | 
             
            });
         | 
| 93 | 
            -
            export  | 
| 94 | 
            +
            export const stopBLEScanSync = factory('stopBLEScanSync', {
         | 
| 94 95 | 
             
              "namespace": "device"
         | 
| 95 96 | 
             
            });
         | 
| 96 | 
            -
            export  | 
| 97 | 
            +
            export const bluetoothCapabilityIsSupport = factory('bluetoothCapabilityIsSupport', {
         | 
| 97 98 | 
             
              "namespace": "device"
         | 
| 98 99 | 
             
            });
         | 
| 99 | 
            -
            export  | 
| 100 | 
            +
            export const getBTDeviceInfo = factory('getBTDeviceInfo', {
         | 
| 100 101 | 
             
              "namespace": "device"
         | 
| 101 102 | 
             
            });
         | 
| 102 | 
            -
            export  | 
| 103 | 
            +
            export const startGWActivation = factory('startGWActivation', {
         | 
| 103 104 | 
             
              "namespace": "device"
         | 
| 104 105 | 
             
            });
         | 
| 105 | 
            -
            export  | 
| 106 | 
            +
            export const stopGWActivation = factory('stopGWActivation', {
         | 
| 106 107 | 
             
              "namespace": "device"
         | 
| 107 108 | 
             
            });
         | 
| 108 | 
            -
            export  | 
| 109 | 
            +
            export const openReconnectPage = factory('openReconnectPage', {
         | 
| 109 110 | 
             
              "namespace": "device"
         | 
| 110 111 | 
             
            });
         | 
| 111 | 
            -
            export  | 
| 112 | 
            +
            export const startDirectlyConnectedDeviceActivator = factory('startDirectlyConnectedDeviceActivator', {
         | 
| 112 113 | 
             
              "namespace": "device"
         | 
| 113 114 | 
             
            });
         | 
| 114 | 
            -
            export  | 
| 115 | 
            +
            export const stopDirectlyConnectedDeviceActivator = factory('stopDirectlyConnectedDeviceActivator', {
         | 
| 115 116 | 
             
              "namespace": "device"
         | 
| 116 117 | 
             
            });
         | 
| 117 | 
            -
            export  | 
| 118 | 
            +
            export const openCategoryActivatorPage = factory('openCategoryActivatorPage', {
         | 
| 118 119 | 
             
              "namespace": "device"
         | 
| 119 120 | 
             
            });
         | 
| 120 | 
            -
            export  | 
| 121 | 
            +
            export const startDirectlyConnectedSearchDevice = factory('startDirectlyConnectedSearchDevice', {
         | 
| 121 122 | 
             
              "namespace": "device"
         | 
| 122 123 | 
             
            });
         | 
| 123 | 
            -
            export  | 
| 124 | 
            +
            export const stopDirectlyConnectedSearchDevice = factory('stopDirectlyConnectedSearchDevice', {
         | 
| 124 125 | 
             
              "namespace": "device"
         | 
| 125 126 | 
             
            });
         | 
| 126 | 
            -
            export  | 
| 127 | 
            +
            export const getDeviceWifiActivatorStatus = factory('getDeviceWifiActivatorStatus', {
         | 
| 127 128 | 
             
              "namespace": "device"
         | 
| 128 129 | 
             
            });
         | 
| 129 | 
            -
            export  | 
| 130 | 
            +
            export const startDeviceWifiActivator = factory('startDeviceWifiActivator', {
         | 
| 130 131 | 
             
              "namespace": "device"
         | 
| 131 132 | 
             
            });
         | 
| 132 | 
            -
            export  | 
| 133 | 
            +
            export const renameDeviceName = factory('renameDeviceName', {
         | 
| 133 134 | 
             
              "namespace": "device"
         | 
| 134 135 | 
             
            });
         | 
| 135 | 
            -
            export  | 
| 136 | 
            +
            export const resetFactory = factory('resetFactory', {
         | 
| 136 137 | 
             
              "namespace": "device"
         | 
| 137 138 | 
             
            });
         | 
| 138 | 
            -
            export  | 
| 139 | 
            +
            export const removeDevice = factory('removeDevice', {
         | 
| 139 140 | 
             
              "namespace": "device"
         | 
| 140 141 | 
             
            });
         | 
| 141 | 
            -
            export  | 
| 142 | 
            +
            export const registerZigbeeGateWaySubDeviceListener = factory('registerZigbeeGateWaySubDeviceListener', {
         | 
| 142 143 | 
             
              "namespace": "device"
         | 
| 143 144 | 
             
            });
         | 
| 144 | 
            -
            export  | 
| 145 | 
            +
            export const unregisterZigbeeGateWaySubDeviceListener = factory('unregisterZigbeeGateWaySubDeviceListener', {
         | 
| 145 146 | 
             
              "namespace": "device"
         | 
| 146 147 | 
             
            });
         | 
| 147 | 
            -
            export  | 
| 148 | 
            +
            export const getDeviceOnlineType = factory('getDeviceOnlineType', {
         | 
| 148 149 | 
             
              "namespace": "device"
         | 
| 149 150 | 
             
            });
         | 
| 150 | 
            -
            export  | 
| 151 | 
            +
            export const getDeviceInfo = factory('getDeviceInfo', {
         | 
| 151 152 | 
             
              "namespace": "device"
         | 
| 152 153 | 
             
            });
         | 
| 153 | 
            -
            export  | 
| 154 | 
            +
            export const getProductInfo = factory('getProductInfo', {
         | 
| 154 155 | 
             
              "namespace": "device"
         | 
| 155 156 | 
             
            });
         | 
| 156 | 
            -
            export  | 
| 157 | 
            +
            export const getSubDeviceInfoList = factory('getSubDeviceInfoList', {
         | 
| 157 158 | 
             
              "namespace": "device"
         | 
| 158 159 | 
             
            });
         | 
| 159 | 
            -
            export  | 
| 160 | 
            +
            export const validDeviceOnlineType = factory('validDeviceOnlineType', {
         | 
| 160 161 | 
             
              "namespace": "device"
         | 
| 161 162 | 
             
            });
         | 
| 162 | 
            -
            export  | 
| 163 | 
            +
            export const publishDpsBase = factory('publishDps', {
         | 
| 163 164 | 
             
              "namespace": "device"
         | 
| 164 165 | 
             
            });
         | 
| 165 | 
            -
            export  | 
| 166 | 
            +
            export const publishCommands = factory('publishCommands', {
         | 
| 166 167 | 
             
              "namespace": "device"
         | 
| 167 168 | 
             
            });
         | 
| 168 | 
            -
            export  | 
| 169 | 
            +
            export const publishDpsWithPipeType = factory('publishDpsWithPipeType', {
         | 
| 169 170 | 
             
              "namespace": "device"
         | 
| 170 171 | 
             
            });
         | 
| 171 | 
            -
            export  | 
| 172 | 
            +
            export const queryDps = factory('queryDps', {
         | 
| 172 173 | 
             
              "namespace": "device"
         | 
| 173 174 | 
             
            });
         | 
| 174 | 
            -
            export  | 
| 175 | 
            +
            export const publishMqttMessage = factory('publishMqttMessage', {
         | 
| 175 176 | 
             
              "namespace": "device"
         | 
| 176 177 | 
             
            });
         | 
| 177 | 
            -
            export  | 
| 178 | 
            +
            export const publishLanMessage = factory('publishLanMessage', {
         | 
| 178 179 | 
             
              "namespace": "device"
         | 
| 179 180 | 
             
            });
         | 
| 180 | 
            -
            export  | 
| 181 | 
            +
            export const publishSocketMessage = factory('publishSocketMessage', {
         | 
| 181 182 | 
             
              "namespace": "device"
         | 
| 182 183 | 
             
            });
         | 
| 183 | 
            -
            export  | 
| 184 | 
            +
            export const getDeviceProperty = factory('getDeviceProperty', {
         | 
| 184 185 | 
             
              "namespace": "device"
         | 
| 185 186 | 
             
            });
         | 
| 186 | 
            -
            export  | 
| 187 | 
            +
            export const setDeviceProperty = factory('setDeviceProperty', {
         | 
| 187 188 | 
             
              "namespace": "device"
         | 
| 188 189 | 
             
            });
         | 
| 189 | 
            -
            export  | 
| 190 | 
            +
            export const syncDeviceInfo = factory('syncDeviceInfo', {
         | 
| 190 191 | 
             
              "namespace": "device"
         | 
| 191 192 | 
             
            });
         | 
| 192 | 
            -
            export  | 
| 193 | 
            +
            export const subscribeDeviceRemoved = factory('subscribeDeviceRemoved', {
         | 
| 193 194 | 
             
              "namespace": "device"
         | 
| 194 195 | 
             
            });
         | 
| 195 | 
            -
            export  | 
| 196 | 
            +
            export const unSubscribeDeviceRemoved = factory('unSubscribeDeviceRemoved', {
         | 
| 196 197 | 
             
              "namespace": "device"
         | 
| 197 198 | 
             
            });
         | 
| 198 | 
            -
            export  | 
| 199 | 
            +
            export const registerMQTTDeviceListener = factory('registerMQTTDeviceListener', {
         | 
| 199 200 | 
             
              "namespace": "device"
         | 
| 200 201 | 
             
            });
         | 
| 201 | 
            -
            export  | 
| 202 | 
            +
            export const unregisterMQTTDeviceListener = factory('unregisterMQTTDeviceListener', {
         | 
| 202 203 | 
             
              "namespace": "device"
         | 
| 203 204 | 
             
            });
         | 
| 204 | 
            -
            export  | 
| 205 | 
            +
            export const registerMQTTProtocolListener = factory('registerMQTTProtocolListener', {
         | 
| 205 206 | 
             
              "namespace": "device"
         | 
| 206 207 | 
             
            });
         | 
| 207 | 
            -
            export  | 
| 208 | 
            +
            export const unregisterMQTTProtocolListener = factory('unregisterMQTTProtocolListener', {
         | 
| 208 209 | 
             
              "namespace": "device"
         | 
| 209 210 | 
             
            });
         | 
| 210 | 
            -
            export  | 
| 211 | 
            +
            export const registerDeviceListListener = factory('registerDeviceListListener', {
         | 
| 211 212 | 
             
              "namespace": "device"
         | 
| 212 213 | 
             
            });
         | 
| 213 | 
            -
            export  | 
| 214 | 
            +
            export const unregisterDeviceListListener = factory('unregisterDeviceListListener', {
         | 
| 214 215 | 
             
              "namespace": "device"
         | 
| 215 216 | 
             
            });
         | 
| 216 | 
            -
            export  | 
| 217 | 
            +
            export const registerTopicListListener = factory('registerTopicListListener', {
         | 
| 217 218 | 
             
              "namespace": "device"
         | 
| 218 219 | 
             
            });
         | 
| 219 | 
            -
            export  | 
| 220 | 
            +
            export const unregisterTopicListListener = factory('unregisterTopicListListener', {
         | 
| 220 221 | 
             
              "namespace": "device"
         | 
| 221 222 | 
             
            });
         | 
| 222 | 
            -
            export  | 
| 223 | 
            +
            export const getMqttConnectState = factory('getMqttConnectState', {
         | 
| 223 224 | 
             
              "namespace": "device"
         | 
| 224 225 | 
             
            });
         | 
| 225 | 
            -
            export  | 
| 226 | 
            +
            export const checkOTAUpdateInfo = factory('checkOTAUpdateInfo', {
         | 
| 226 227 | 
             
              "namespace": "device"
         | 
| 227 228 | 
             
            });
         | 
| 228 | 
            -
            export  | 
| 229 | 
            +
            export const openDeviceDetailPage = factory('openDeviceDetailPage', {
         | 
| 229 230 | 
             
              "namespace": "device"
         | 
| 230 231 | 
             
            });
         | 
| 231 | 
            -
            export  | 
| 232 | 
            +
            export const openGroupDetailPage = factory('openGroupDetailPage', {
         | 
| 232 233 | 
             
              "namespace": "device"
         | 
| 233 234 | 
             
            });
         | 
| 234 | 
            -
            export  | 
| 235 | 
            +
            export const openTimerPage = factory('openTimerPage', {
         | 
| 235 236 | 
             
              "namespace": "device"
         | 
| 236 237 | 
             
            });
         | 
| 237 | 
            -
            export  | 
| 238 | 
            +
            export const openGroupTimerPage = factory('openGroupTimerPage', {
         | 
| 238 239 | 
             
              "namespace": "device"
         | 
| 239 240 | 
             
            });
         | 
| 240 | 
            -
            export  | 
| 241 | 
            +
            export const openDeviceWifiNetworkMonitorPage = factory('openDeviceWifiNetworkMonitorPage', {
         | 
| 241 242 | 
             
              "namespace": "device"
         | 
| 242 243 | 
             
            });
         | 
| 243 | 
            -
            export  | 
| 244 | 
            +
            export const syncTimerTask = factory('syncTimerTask', {
         | 
| 244 245 | 
             
              "namespace": "device"
         | 
| 245 246 | 
             
            });
         | 
| 246 | 
            -
            export  | 
| 247 | 
            +
            export const addTimer = factory('addTimer', {
         | 
| 247 248 | 
             
              "namespace": "device"
         | 
| 248 249 | 
             
            });
         | 
| 249 | 
            -
            export  | 
| 250 | 
            +
            export const updateTimer = factory('updateTimer', {
         | 
| 250 251 | 
             
              "namespace": "device"
         | 
| 251 252 | 
             
            });
         | 
| 252 | 
            -
            export  | 
| 253 | 
            +
            export const updateTimerStatus = factory('updateTimerStatus', {
         | 
| 253 254 | 
             
              "namespace": "device"
         | 
| 254 255 | 
             
            });
         | 
| 255 | 
            -
            export  | 
| 256 | 
            +
            export const removeTimer = factory('removeTimer', {
         | 
| 256 257 | 
             
              "namespace": "device"
         | 
| 257 258 | 
             
            });
         | 
| 258 | 
            -
            export  | 
| 259 | 
            +
            export const getShareDeviceInfo = factory('getShareDeviceInfo', {
         | 
| 259 260 | 
             
              "namespace": "device"
         | 
| 260 261 | 
             
            });
         | 
| 261 | 
            -
            export  | 
| 262 | 
            +
            export const openDeviceEdit = factory('openDeviceEdit', {
         | 
| 262 263 | 
             
              "namespace": "device"
         | 
| 263 264 | 
             
            });
         | 
| 264 | 
            -
            export  | 
| 265 | 
            +
            export const openGroupEdit = factory('openGroupEdit', {
         | 
| 265 266 | 
             
              "namespace": "device"
         | 
| 266 267 | 
             
            });
         | 
| 267 | 
            -
            export  | 
| 268 | 
            +
            export const openDeviceInfo = factory('openDeviceInfo', {
         | 
| 268 269 | 
             
              "namespace": "device"
         | 
| 269 270 | 
             
            });
         | 
| 270 | 
            -
            export  | 
| 271 | 
            +
            export const isDeviceSupportOfflineReminder = factory('isDeviceSupportOfflineReminder', {
         | 
| 271 272 | 
             
              "namespace": "device"
         | 
| 272 273 | 
             
            });
         | 
| 273 | 
            -
            export  | 
| 274 | 
            +
            export const getDeviceOfflineReminderState = factory('getDeviceOfflineReminderState', {
         | 
| 274 275 | 
             
              "namespace": "device"
         | 
| 275 276 | 
             
            });
         | 
| 276 | 
            -
            export  | 
| 277 | 
            +
            export const toggleDeviceOfflineReminder = factory('toggleDeviceOfflineReminder', {
         | 
| 277 278 | 
             
              "namespace": "device"
         | 
| 278 279 | 
             
            });
         | 
| 279 | 
            -
            export  | 
| 280 | 
            +
            export const getDeviceOfflineReminderWarningText = factory('getDeviceOfflineReminderWarningText', {
         | 
| 280 281 | 
             
              "namespace": "device"
         | 
| 281 282 | 
             
            });
         | 
| 282 | 
            -
            export  | 
| 283 | 
            +
            export const openDeviceQuestionsAndFeedback = factory('openDeviceQuestionsAndFeedback', {
         | 
| 283 284 | 
             
              "namespace": "device"
         | 
| 284 285 | 
             
            });
         | 
| 285 | 
            -
            export  | 
| 286 | 
            +
            export const openShareDevice = factory('openShareDevice', {
         | 
| 286 287 | 
             
              "namespace": "device"
         | 
| 287 288 | 
             
            });
         | 
| 288 | 
            -
            export  | 
| 289 | 
            +
            export const addDeviceToDesk = factory('addDeviceToDesk', {
         | 
| 289 290 | 
             
              "namespace": "device"
         | 
| 290 291 | 
             
            });
         | 
| 291 | 
            -
            export  | 
| 292 | 
            +
            export const removeShareDevice = factory('removeShareDevice', {
         | 
| 292 293 | 
             
              "namespace": "device"
         | 
| 293 294 | 
             
            });
         | 
| 294 | 
            -
            export  | 
| 295 | 
            +
            export const getSupportedThirdPartyServices = factory('getSupportedThirdPartyServices', {
         | 
| 295 296 | 
             
              "namespace": "device"
         | 
| 296 297 | 
             
            });
         | 
| 297 | 
            -
            export  | 
| 298 | 
            +
            export const openRecommendSceneDetail = factory('openRecommendSceneDetail', {
         | 
| 298 299 | 
             
              "namespace": "device"
         | 
| 299 300 | 
             
            });
         | 
| 300 | 
            -
            export  | 
| 301 | 
            +
            export const openDeviceExecutionAndAnutomation = factory('openDeviceExecutionAndAnutomation', {
         | 
| 301 302 | 
             
              "namespace": "device"
         | 
| 302 303 | 
             
            });
         | 
| 303 | 
            -
            export  | 
| 304 | 
            +
            export const saveSceneAction = factory('saveSceneAction', {
         | 
| 304 305 | 
             
              "namespace": "device"
         | 
| 305 306 | 
             
            });
         | 
| 306 | 
            -
            export  | 
| 307 | 
            +
            export const createAction = factory('createAction', {
         | 
| 307 308 | 
             
              "namespace": "device"
         | 
| 308 309 | 
             
            });
         | 
| 309 | 
            -
            export  | 
| 310 | 
            +
            export const editAction = factory('editAction', {
         | 
| 310 311 | 
             
              "namespace": "device"
         | 
| 311 312 | 
             
            });
         | 
| 312 | 
            -
            export  | 
| 313 | 
            +
            export const showSceneDialog = factory('showSceneDialog', {
         | 
| 313 314 | 
             
              "namespace": "device"
         | 
| 314 315 | 
             
            });
         | 
| 315 | 
            -
            export  | 
| 316 | 
            +
            export const openPreConditionPage = factory('openPreConditionPage', {
         | 
| 316 317 | 
             
              "namespace": "device"
         | 
| 317 318 | 
             
            });
         | 
| 318 | 
            -
            export  | 
| 319 | 
            +
            export const createCondition = factory('createCondition', {
         | 
| 319 320 | 
             
              "namespace": "device"
         | 
| 320 321 | 
             
            });
         | 
| 321 | 
            -
            export  | 
| 322 | 
            +
            export const editCondition = factory('editCondition', {
         | 
| 322 323 | 
             
              "namespace": "device"
         | 
| 323 324 | 
             
            });
         | 
| 324 | 
            -
            export  | 
| 325 | 
            +
            export const getGroupDeviceList = factory('getGroupDeviceList', {
         | 
| 325 326 | 
             
              "namespace": "device"
         | 
| 326 327 | 
             
            });
         | 
| 327 | 
            -
            export  | 
| 328 | 
            +
            export const getGroupDeviceNum = factory('getGroupDeviceNum', {
         | 
| 328 329 | 
             
              "namespace": "device"
         | 
| 329 330 | 
             
            });
         | 
| 330 | 
            -
            export  | 
| 331 | 
            +
            export const getDeviceNumWithDpCode = factory('getDeviceNumWithDpCode', {
         | 
| 331 332 | 
             
              "namespace": "device"
         | 
| 332 333 | 
             
            });
         | 
| 333 | 
            -
            export  | 
| 334 | 
            +
            export const publishGroupDpCodes = factory('publishGroupDpCodes', {
         | 
| 334 335 | 
             
              "namespace": "device"
         | 
| 335 336 | 
             
            });
         | 
| 336 | 
            -
            export  | 
| 337 | 
            +
            export const publishSigMeshMultiDps = factory('publishSigMeshMultiDps', {
         | 
| 337 338 | 
             
              "namespace": "device"
         | 
| 338 339 | 
             
            });
         | 
| 339 | 
            -
            export  | 
| 340 | 
            +
            export const openMeshLocalGroup = factory('openMeshLocalGroup', {
         | 
| 340 341 | 
             
              "namespace": "device"
         | 
| 341 342 | 
             
            });
         | 
| 342 | 
            -
            export  | 
| 343 | 
            +
            export const getGroupInfo = factory('getGroupInfo', {
         | 
| 343 344 | 
             
              "namespace": "device"
         | 
| 344 345 | 
             
            });
         | 
| 345 | 
            -
            export  | 
| 346 | 
            +
            export const publishGroupDps = factory('publishGroupDps', {
         | 
| 346 347 | 
             
              "namespace": "device"
         | 
| 347 348 | 
             
            });
         | 
| 348 | 
            -
            export  | 
| 349 | 
            +
            export const getGroupProperty = factory('getGroupProperty', {
         | 
| 349 350 | 
             
              "namespace": "device"
         | 
| 350 351 | 
             
            });
         | 
| 351 | 
            -
            export  | 
| 352 | 
            +
            export const setGroupProperty = factory('setGroupProperty', {
         | 
| 352 353 | 
             
              "namespace": "device"
         | 
| 353 354 | 
             
            });
         | 
| 354 | 
            -
            export  | 
| 355 | 
            +
            export const registerGroupChange = factory('registerGroupChange', {
         | 
| 355 356 | 
             
              "namespace": "device"
         | 
| 356 357 | 
             
            });
         | 
| 357 | 
            -
            export  | 
| 358 | 
            +
            export const unRegisterGroupChange = factory('unRegisterGroupChange', {
         | 
| 358 359 | 
             
              "namespace": "device"
         | 
| 359 360 | 
             
            });
         | 
| 360 | 
            -
            export  | 
| 361 | 
            +
            export const getMeshDeviceId = factory('getMeshDeviceId', {
         | 
| 361 362 | 
             
              "namespace": "device"
         | 
| 362 363 | 
             
            });
         | 
| 363 | 
            -
            export  | 
| 364 | 
            +
            export const getDpDataByMesh = factory('getDpDataByMesh', {
         | 
| 364 365 | 
             
              "namespace": "device"
         | 
| 365 366 | 
             
            });
         | 
| 366 | 
            -
            export  | 
| 367 | 
            +
            export const checkOTAUpgradeStatus = factory('checkOTAUpgradeStatus', {
         | 
| 367 368 | 
             
              "namespace": "device"
         | 
| 368 369 | 
             
            });
         | 
| 369 | 
            -
            export  | 
| 370 | 
            +
            export const openOTAUpgrade = factory('openOTAUpgrade', {
         | 
| 370 371 | 
             
              "namespace": "device"
         | 
| 371 372 | 
             
            });
         | 
| 372 | 
            -
            export  | 
| 373 | 
            +
            export const deviceIsSupportThingModel = factory('deviceIsSupportThingModel', {
         | 
| 373 374 | 
             
              "namespace": "device"
         | 
| 374 375 | 
             
            });
         | 
| 375 | 
            -
            export  | 
| 376 | 
            +
            export const updateDeviceThingModelInfo = factory('updateDeviceThingModelInfo', {
         | 
| 376 377 | 
             
              "namespace": "device"
         | 
| 377 378 | 
             
            });
         | 
| 378 | 
            -
            export  | 
| 379 | 
            +
            export const getDeviceThingModelInfo = factory('getDeviceThingModelInfo', {
         | 
| 379 380 | 
             
              "namespace": "device"
         | 
| 380 381 | 
             
            });
         | 
| 381 | 
            -
            export  | 
| 382 | 
            +
            export const publishThingModelMessage = factory('publishThingModelMessage', {
         | 
| 382 383 | 
             
              "namespace": "device"
         | 
| 383 384 | 
             
            });
         | 
| 384 | 
            -
            export  | 
| 385 | 
            +
            export const subscribeReceivedThingModelMessage = factory('subscribeReceivedThingModelMessage', {
         | 
| 385 386 | 
             
              "namespace": "device"
         | 
| 386 387 | 
             
            });
         | 
| 387 | 
            -
            export  | 
| 388 | 
            +
            export const unSubscribeReceivedThingModelMessage = factory('unSubscribeReceivedThingModelMessage', {
         | 
| 388 389 | 
             
              "namespace": "device"
         | 
| 389 390 | 
             
            });
         | 
| 390 | 
            -
            export  | 
| 391 | 
            +
            export const onLeaveBeaconFence = factory('onLeaveBeaconFence', {
         | 
| 391 392 | 
             
              "namespace": "device"
         | 
| 392 393 | 
             
            });
         | 
| 393 | 
            -
            export  | 
| 394 | 
            +
            export const offLeaveBeaconFence = factory('offLeaveBeaconFence', {
         | 
| 394 395 | 
             
              "namespace": "device"
         | 
| 395 396 | 
             
            });
         | 
| 396 | 
            -
            export  | 
| 397 | 
            +
            export const onFileTransferProgress = factory('onFileTransferProgress', {
         | 
| 397 398 | 
             
              "namespace": "device"
         | 
| 398 399 | 
             
            });
         | 
| 399 | 
            -
            export  | 
| 400 | 
            +
            export const offFileTransferProgress = factory('offFileTransferProgress', {
         | 
| 400 401 | 
             
              "namespace": "device"
         | 
| 401 402 | 
             
            });
         | 
| 402 | 
            -
            export  | 
| 403 | 
            +
            export const onBLEConnectStatusChange = factory('onBLEConnectStatusChange', {
         | 
| 403 404 | 
             
              "namespace": "device"
         | 
| 404 405 | 
             
            });
         | 
| 405 | 
            -
            export  | 
| 406 | 
            +
            export const offBLEConnectStatusChange = factory('offBLEConnectStatusChange', {
         | 
| 406 407 | 
             
              "namespace": "device"
         | 
| 407 408 | 
             
            });
         | 
| 408 | 
            -
            export  | 
| 409 | 
            +
            export const onBLETransparentDataReport = factory('onBLETransparentDataReport', {
         | 
| 409 410 | 
             
              "namespace": "device"
         | 
| 410 411 | 
             
            });
         | 
| 411 | 
            -
            export  | 
| 412 | 
            +
            export const offBLETransparentDataReport = factory('offBLETransparentDataReport', {
         | 
| 412 413 | 
             
              "namespace": "device"
         | 
| 413 414 | 
             
            });
         | 
| 414 | 
            -
            export  | 
| 415 | 
            +
            export const onBLEBigDataChannelProgressEvent = factory('onBLEBigDataChannelProgressEvent', {
         | 
| 415 416 | 
             
              "namespace": "device"
         | 
| 416 417 | 
             
            });
         | 
| 417 | 
            -
            export  | 
| 418 | 
            +
            export const offBLEBigDataChannelProgressEvent = factory('offBLEBigDataChannelProgressEvent', {
         | 
| 418 419 | 
             
              "namespace": "device"
         | 
| 419 420 | 
             
            });
         | 
| 420 | 
            -
            export  | 
| 421 | 
            +
            export const onBLEScanBindDevice = factory('onBLEScanBindDevice', {
         | 
| 421 422 | 
             
              "namespace": "device"
         | 
| 422 423 | 
             
            });
         | 
| 423 | 
            -
            export  | 
| 424 | 
            +
            export const offBLEScanBindDevice = factory('offBLEScanBindDevice', {
         | 
| 424 425 | 
             
              "namespace": "device"
         | 
| 425 426 | 
             
            });
         | 
| 426 | 
            -
            export  | 
| 427 | 
            +
            export const onBLEBigDataChannelDeviceToAppSuccess = factory('onBLEBigDataChannelDeviceToAppSuccess', {
         | 
| 427 428 | 
             
              "namespace": "device"
         | 
| 428 429 | 
             
            });
         | 
| 429 | 
            -
            export  | 
| 430 | 
            +
            export const offBLEBigDataChannelDeviceToAppSuccess = factory('offBLEBigDataChannelDeviceToAppSuccess', {
         | 
| 430 431 | 
             
              "namespace": "device"
         | 
| 431 432 | 
             
            });
         | 
| 432 | 
            -
            export  | 
| 433 | 
            +
            export const onBLEBigDataChannelUploadCloudProgress = factory('onBLEBigDataChannelUploadCloudProgress', {
         | 
| 433 434 | 
             
              "namespace": "device"
         | 
| 434 435 | 
             
            });
         | 
| 435 | 
            -
            export  | 
| 436 | 
            +
            export const offBLEBigDataChannelUploadCloudProgress = factory('offBLEBigDataChannelUploadCloudProgress', {
         | 
| 436 437 | 
             
              "namespace": "device"
         | 
| 437 438 | 
             
            });
         | 
| 438 | 
            -
            export  | 
| 439 | 
            +
            export const onSubDeviceInfoUpdateEvent = factory('onSubDeviceInfoUpdateEvent', {
         | 
| 439 440 | 
             
              "namespace": "device"
         | 
| 440 441 | 
             
            });
         | 
| 441 | 
            -
            export  | 
| 442 | 
            +
            export const offSubDeviceInfoUpdateEvent = factory('offSubDeviceInfoUpdateEvent', {
         | 
| 442 443 | 
             
              "namespace": "device"
         | 
| 443 444 | 
             
            });
         | 
| 444 | 
            -
            export  | 
| 445 | 
            +
            export const onDirectlyConnectedSearchDeviceEvent = factory('onDirectlyConnectedSearchDeviceEvent', {
         | 
| 445 446 | 
             
              "namespace": "device"
         | 
| 446 447 | 
             
            });
         | 
| 447 | 
            -
            export  | 
| 448 | 
            +
            export const offDirectlyConnectedSearchDeviceEvent = factory('offDirectlyConnectedSearchDeviceEvent', {
         | 
| 448 449 | 
             
              "namespace": "device"
         | 
| 449 450 | 
             
            });
         | 
| 450 | 
            -
            export  | 
| 451 | 
            +
            export const onDpDataChange = factory('onDpDataChange', {
         | 
| 451 452 | 
             
              "namespace": "device"
         | 
| 452 453 | 
             
            });
         | 
| 453 | 
            -
            export  | 
| 454 | 
            +
            export const offDpDataChange = factory('offDpDataChange', {
         | 
| 454 455 | 
             
              "namespace": "device"
         | 
| 455 456 | 
             
            });
         | 
| 456 | 
            -
            export  | 
| 457 | 
            +
            export const onMqttMessageReceived = factory('onMqttMessageReceived', {
         | 
| 457 458 | 
             
              "namespace": "device"
         | 
| 458 459 | 
             
            });
         | 
| 459 | 
            -
            export  | 
| 460 | 
            +
            export const offMqttMessageReceived = factory('offMqttMessageReceived', {
         | 
| 460 461 | 
             
              "namespace": "device"
         | 
| 461 462 | 
             
            });
         | 
| 462 | 
            -
            export  | 
| 463 | 
            +
            export const onSocketMessageReceived = factory('onSocketMessageReceived', {
         | 
| 463 464 | 
             
              "namespace": "device"
         | 
| 464 465 | 
             
            });
         | 
| 465 | 
            -
            export  | 
| 466 | 
            +
            export const offSocketMessageReceived = factory('offSocketMessageReceived', {
         | 
| 466 467 | 
             
              "namespace": "device"
         | 
| 467 468 | 
             
            });
         | 
| 468 | 
            -
            export  | 
| 469 | 
            +
            export const onDeviceOnlineStatusUpdate = factory('onDeviceOnlineStatusUpdate', {
         | 
| 469 470 | 
             
              "namespace": "device"
         | 
| 470 471 | 
             
            });
         | 
| 471 | 
            -
            export  | 
| 472 | 
            +
            export const offDeviceOnlineStatusUpdate = factory('offDeviceOnlineStatusUpdate', {
         | 
| 472 473 | 
             
              "namespace": "device"
         | 
| 473 474 | 
             
            });
         | 
| 474 | 
            -
            export  | 
| 475 | 
            +
            export const onDeviceInfoUpdated = factory('onDeviceInfoUpdated', {
         | 
| 475 476 | 
             
              "namespace": "device"
         | 
| 476 477 | 
             
            });
         | 
| 477 | 
            -
            export  | 
| 478 | 
            +
            export const offDeviceInfoUpdated = factory('offDeviceInfoUpdated', {
         | 
| 478 479 | 
             
              "namespace": "device"
         | 
| 479 480 | 
             
            });
         | 
| 480 | 
            -
            export  | 
| 481 | 
            +
            export const onDeviceRemoved = factory('onDeviceRemoved', {
         | 
| 481 482 | 
             
              "namespace": "device"
         | 
| 482 483 | 
             
            });
         | 
| 483 | 
            -
            export  | 
| 484 | 
            +
            export const offDeviceRemoved = factory('offDeviceRemoved', {
         | 
| 484 485 | 
             
              "namespace": "device"
         | 
| 485 486 | 
             
            });
         | 
| 486 | 
            -
            export  | 
| 487 | 
            +
            export const onMqttConnectState = factory('onMqttConnectState', {
         | 
| 487 488 | 
             
              "namespace": "device"
         | 
| 488 489 | 
             
            });
         | 
| 489 | 
            -
            export  | 
| 490 | 
            +
            export const offMqttConnectState = factory('offMqttConnectState', {
         | 
| 490 491 | 
             
              "namespace": "device"
         | 
| 491 492 | 
             
            });
         | 
| 492 | 
            -
            export  | 
| 493 | 
            +
            export const onTimerUpdate = factory('onTimerUpdate', {
         | 
| 493 494 | 
             
              "namespace": "device"
         | 
| 494 495 | 
             
            });
         | 
| 495 | 
            -
            export  | 
| 496 | 
            +
            export const offTimerUpdate = factory('offTimerUpdate', {
         | 
| 496 497 | 
             
              "namespace": "device"
         | 
| 497 498 | 
             
            });
         | 
| 498 | 
            -
            export  | 
| 499 | 
            +
            export const onGroupInfoChange = factory('onGroupInfoChange', {
         | 
| 499 500 | 
             
              "namespace": "device"
         | 
| 500 501 | 
             
            });
         | 
| 501 | 
            -
            export  | 
| 502 | 
            +
            export const offGroupInfoChange = factory('offGroupInfoChange', {
         | 
| 502 503 | 
             
              "namespace": "device"
         | 
| 503 504 | 
             
            });
         | 
| 504 | 
            -
            export  | 
| 505 | 
            +
            export const onGroupDpCodeChange = factory('onGroupDpCodeChange', {
         | 
| 505 506 | 
             
              "namespace": "device"
         | 
| 506 507 | 
             
            });
         | 
| 507 | 
            -
            export  | 
| 508 | 
            +
            export const offGroupDpCodeChange = factory('offGroupDpCodeChange', {
         | 
| 508 509 | 
             
              "namespace": "device"
         | 
| 509 510 | 
             
            });
         | 
| 510 | 
            -
            export  | 
| 511 | 
            +
            export const onGroupRemovedEvent = factory('onGroupRemovedEvent', {
         | 
| 511 512 | 
             
              "namespace": "device"
         | 
| 512 513 | 
             
            });
         | 
| 513 | 
            -
            export  | 
| 514 | 
            +
            export const offGroupRemovedEvent = factory('offGroupRemovedEvent', {
         | 
| 514 515 | 
             
              "namespace": "device"
         | 
| 515 516 | 
             
            });
         | 
| 516 | 
            -
            export  | 
| 517 | 
            +
            export const onGroupDpDataChangeEvent = factory('onGroupDpDataChangeEvent', {
         | 
| 517 518 | 
             
              "namespace": "device"
         | 
| 518 519 | 
             
            });
         | 
| 519 | 
            -
            export  | 
| 520 | 
            +
            export const offGroupDpDataChangeEvent = factory('offGroupDpDataChangeEvent', {
         | 
| 520 521 | 
             
              "namespace": "device"
         | 
| 521 522 | 
             
            });
         | 
| 522 | 
            -
            export  | 
| 523 | 
            +
            export const onReceivedThingModelMessage = factory('onReceivedThingModelMessage', {
         | 
| 523 524 | 
             
              "namespace": "device"
         | 
| 524 525 | 
             
            });
         | 
| 525 | 
            -
            export  | 
| 526 | 
            +
            export const offReceivedThingModelMessage = factory('offReceivedThingModelMessage', {
         | 
| 526 527 | 
             
              "namespace": "device"
         | 
| 527 | 
            -
            }); | 
| 528 | 
            -
             | 
| 529 | 
            -
            export  | 
| 528 | 
            +
            });
         | 
| 529 | 
            +
            // 3.2.0 新增 - 4.7.0 容器
         | 
| 530 | 
            +
            export const connectBluetoothDevice = factory('connectBluetoothDevice', {
         | 
| 530 531 | 
             
              "namespace": "device"
         | 
| 531 532 | 
             
            });
         | 
| 532 | 
            -
            export  | 
| 533 | 
            +
            export const disconnectBluetoothDevice = factory('disconnectBluetoothDevice', {
         | 
| 533 534 | 
             
              "namespace": "device"
         | 
| 534 535 | 
             
            });
         | 
| 535 | 
            -
            export  | 
| 536 | 
            +
            export const onSubDeviceAdded = factory('onSubDeviceAdded', {
         | 
| 536 537 | 
             
              "namespace": "device"
         | 
| 537 538 | 
             
            });
         | 
| 538 | 
            -
            export  | 
| 539 | 
            +
            export const offSubDeviceAdded = factory('offSubDeviceAdded', {
         | 
| 539 540 | 
             
              "namespace": "device"
         | 
| 540 541 | 
             
            });
         | 
| 541 | 
            -
            export  | 
| 542 | 
            +
            export const onSubDeviceDpUpdate = factory('onSubDeviceDpUpdate', {
         | 
| 542 543 | 
             
              "namespace": "device"
         | 
| 543 544 | 
             
            });
         | 
| 544 | 
            -
            export  | 
| 545 | 
            +
            export const offSubDeviceDpUpdate = factory('offSubDeviceDpUpdate', {
         | 
| 545 546 | 
             
              "namespace": "device"
         | 
| 546 547 | 
             
            });
         | 
| 547 | 
            -
            export  | 
| 548 | 
            +
            export const onSubDeviceInfoUpdate = factory('onSubDeviceInfoUpdate', {
         | 
| 548 549 | 
             
              "namespace": "device"
         | 
| 549 550 | 
             
            });
         | 
| 550 | 
            -
            export  | 
| 551 | 
            +
            export const offSubDeviceInfoUpdate = factory('offSubDeviceInfoUpdate', {
         | 
| 551 552 | 
             
              "namespace": "device"
         | 
| 552 553 | 
             
            });
         | 
| 553 | 
            -
            export  | 
| 554 | 
            +
            export const onSubDeviceRemoved = factory('onSubDeviceRemoved', {
         | 
| 554 555 | 
             
              "namespace": "device"
         | 
| 555 556 | 
             
            });
         | 
| 556 | 
            -
            export  | 
| 557 | 
            +
            export const offSubDeviceRemoved = factory('offSubDeviceRemoved', {
         | 
| 557 558 | 
             
              "namespace": "device"
         | 
| 558 559 | 
             
            });
         | 
| 559 | 
            -
            export  | 
| 560 | 
            +
            export const registerGateWaySubDeviceListener = factory('registerGateWaySubDeviceListener', {
         | 
| 560 561 | 
             
              "namespace": "device"
         | 
| 561 562 | 
             
            });
         | 
| 562 | 
            -
            export  | 
| 563 | 
            +
            export const unregisterGateWaySubDeviceListener = factory('unregisterGateWaySubDeviceListener', {
         | 
| 563 564 | 
             
              "namespace": "device"
         | 
| 564 | 
            -
            }); | 
| 565 | 
            -
             | 
| 566 | 
            -
            export  | 
| 565 | 
            +
            });
         | 
| 566 | 
            +
            // 3.3.1 新增 - 4.8.0 容器
         | 
| 567 | 
            +
            export const getDeviceListByDevIds = factory('getDeviceListByDevIds', {
         | 
| 567 568 | 
             
              "namespace": "device"
         | 
| 568 569 | 
             
            });
         | 
| 569 | 
            -
            export  | 
| 570 | 
            +
            export const sendMqttMessage = factory('sendMqttMessage', {
         | 
| 570 571 | 
             
              "namespace": "device"
         | 
| 571 572 | 
             
            });
         |