@ray-js/api 1.7.79 → 1.7.80

package/lib/DeviceKit-4.13.1.d.ts

@@ -2,1245 +2,4911 @@
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterLeaveBeaconFenceEvent } = device;
+ *
+ * unregisterLeaveBeaconFenceEvent({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unregisterLeaveBeaconFenceEvent success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterLeaveBeaconFenceEvent fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterLeaveBeaconFenceEvent: typeof ty.device.unregisterLeaveBeaconFenceEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerLeaveBeaconFenceEvent } = device;
+ *
+ * registerLeaveBeaconFenceEvent({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('registerLeaveBeaconFenceEvent success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerLeaveBeaconFenceEvent fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerLeaveBeaconFenceEvent: typeof ty.device.registerLeaveBeaconFenceEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { writeBeaconFenceConfig } = device;
+ *
+ * writeBeaconFenceConfig({
+ *   deviceId: 'device_001',
+ *   beaconFenceRssi: 0,
+ *   isOpenEventWhenApproachingBeaconFence: true,
+ *   isOpenEventWhenLeaveBeaconFence: true,
+ *   isOpenNotifyWhenLeaveBeaconFence: true,
+ *   success: () => {
+ *     console.log('writeBeaconFenceConfig success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('writeBeaconFenceConfig fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const writeBeaconFenceConfig: typeof ty.device.writeBeaconFenceConfig;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { readBeaconFenceConfig } = device;
+ *
+ * readBeaconFenceConfig({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('readBeaconFenceConfig success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('readBeaconFenceConfig fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const readBeaconFenceConfig: typeof ty.device.readBeaconFenceConfig;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { disconnectBTBond } = device;
+ *
+ * disconnectBTBond({
+ *   mac: 'example',
+ *   success: () => {
+ *     console.log('disconnectBTBond success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('disconnectBTBond fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const disconnectBTBond: typeof ty.device.disconnectBTBond;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { connectBTBond } = device;
+ *
+ * connectBTBond({
+ *   mac: 'example',
+ *   success: () => {
+ *     console.log('connectBTBond success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('connectBTBond fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const connectBTBond: typeof ty.device.connectBTBond;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { cancelBLEFileTransfer } = device;
+ *
+ * cancelBLEFileTransfer({
+ *   deviceId: 'device_001',
+ *   fileId: 0,
+ *   fileIdentifier: 'example',
+ *   fileVersion: 0,
+ *   filePath: 'example',
+ *   success: () => {
+ *     console.log('cancelBLEFileTransfer success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('cancelBLEFileTransfer fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const cancelBLEFileTransfer: typeof ty.device.cancelBLEFileTransfer;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { postBLEFileTransfer } = device;
+ *
+ * postBLEFileTransfer({
+ *   deviceId: 'device_001',
+ *   fileId: 0,
+ *   fileIdentifier: 'example',
+ *   fileVersion: 0,
+ *   filePath: 'example',
+ *   success: (result) => {
+ *     console.log('postBLEFileTransfer success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('postBLEFileTransfer fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const postBLEFileTransfer: typeof ty.device.postBLEFileTransfer;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getBLEDeviceRSSI } = device;
+ *
+ * getBLEDeviceRSSI({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getBLEDeviceRSSI success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getBLEDeviceRSSI fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getBLEDeviceRSSI: typeof ty.device.getBLEDeviceRSSI;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { subscribeBLEConnectStatus } = device;
+ *
+ * subscribeBLEConnectStatus({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('subscribeBLEConnectStatus success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('subscribeBLEConnectStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const subscribeBLEConnectStatus: typeof ty.device.subscribeBLEConnectStatus;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unsubscribeBLEConnectStatus } = device;
+ *
+ * unsubscribeBLEConnectStatus({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unsubscribeBLEConnectStatus success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unsubscribeBLEConnectStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unsubscribeBLEConnectStatus: typeof ty.device.unsubscribeBLEConnectStatus;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { connectBLEDevice } = device;
+ *
+ * connectBLEDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('connectBLEDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('connectBLEDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const connectBLEDevice: typeof ty.device.connectBLEDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { directConnectBLEDevice } = device;
+ *
+ * directConnectBLEDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('directConnectBLEDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('directConnectBLEDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const directConnectBLEDevice: typeof ty.device.directConnectBLEDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { disconnectBLEDevice } = device;
+ *
+ * disconnectBLEDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('disconnectBLEDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('disconnectBLEDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const disconnectBLEDevice: typeof ty.device.disconnectBLEDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getBLEOnlineState } = device;
+ *
+ * getBLEOnlineState({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getBLEOnlineState success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getBLEOnlineState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getBLEOnlineState: typeof ty.device.getBLEOnlineState;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { subscribeBLETransparentDataReport } = device;
+ *
+ * subscribeBLETransparentDataReport({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('subscribeBLETransparentDataReport success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('subscribeBLETransparentDataReport fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const subscribeBLETransparentDataReport: typeof ty.device.subscribeBLETransparentDataReport;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unsubscribeBLETransparentDataReport } = device;
+ *
+ * unsubscribeBLETransparentDataReport({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unsubscribeBLETransparentDataReport success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unsubscribeBLETransparentDataReport fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unsubscribeBLETransparentDataReport: typeof ty.device.unsubscribeBLETransparentDataReport;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishBLETransparentData } = device;
+ *
+ * publishBLETransparentData({
+ *   deviceId: 'device_001',
+ *   data: 'example',
+ *   success: () => {
+ *     console.log('publishBLETransparentData success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishBLETransparentData fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishBLETransparentData: typeof ty.device.publishBLETransparentData;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getEncryptLocalKeyWithData } = device;
+ *
+ * getEncryptLocalKeyWithData({
+ *   deviceId: 'device_001',
+ *   keyDeviceId: 'example',
+ *   success: (result) => {
+ *     console.log('getEncryptLocalKeyWithData success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getEncryptLocalKeyWithData fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getEncryptLocalKeyWithData: typeof ty.device.getEncryptLocalKeyWithData;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { postBLEBigDataChannelWithProgress } = device;
+ *
+ * postBLEBigDataChannelWithProgress({
+ *   deviceId: 'device_001',
+ *   requestParams: {},
+ *   success: (result) => {
+ *     console.log('postBLEBigDataChannelWithProgress success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('postBLEBigDataChannelWithProgress fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const postBLEBigDataChannelWithProgress: typeof ty.device.postBLEBigDataChannelWithProgress;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLEMeshLowPowerConnection } = device;
+ *
+ * startBLEMeshLowPowerConnection({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('startBLEMeshLowPowerConnection success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startBLEMeshLowPowerConnection fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startBLEMeshLowPowerConnection: typeof ty.device.startBLEMeshLowPowerConnection;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopBLEMeshLowPowerConnection } = device;
+ *
+ * stopBLEMeshLowPowerConnection({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('stopBLEMeshLowPowerConnection success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopBLEMeshLowPowerConnection fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopBLEMeshLowPowerConnection: typeof ty.device.stopBLEMeshLowPowerConnection;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLEScanBeacon } = device;
+ *
+ * startBLEScanBeacon({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('startBLEScanBeacon success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startBLEScanBeacon fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startBLEScanBeacon: typeof ty.device.startBLEScanBeacon;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopBLEScanBeacon } = device;
+ *
+ * stopBLEScanBeacon({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('stopBLEScanBeacon success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopBLEScanBeacon fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopBLEScanBeacon: typeof ty.device.stopBLEScanBeacon;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { bluetoothCapabilityOfBLEBeacon } = device;
+ *
+ * bluetoothCapabilityOfBLEBeacon({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('bluetoothCapabilityOfBLEBeacon success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('bluetoothCapabilityOfBLEBeacon fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const bluetoothCapabilityOfBLEBeacon: typeof ty.device.bluetoothCapabilityOfBLEBeacon;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { bluetoothIsPowerOn } = device;
+ *
+ * bluetoothIsPowerOn({
+ *   success: (result) => {
+ *     console.log('bluetoothIsPowerOn success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('bluetoothIsPowerOn fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const bluetoothIsPowerOn: typeof ty.device.bluetoothIsPowerOn;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLEScanBindDevice } = device;
+ *
+ * startBLEScanBindDevice({
+ *   interval: 0,
+ *   scanType: 'example',
+ *   success: () => {
+ *     console.log('startBLEScanBindDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startBLEScanBindDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startBLEScanBindDevice: typeof ty.device.startBLEScanBindDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLEScan } = device;
+ *
+ * startBLEScan({
+ *   success: () => {
+ *     console.log('startBLEScan success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startBLEScan fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startBLEScan: typeof ty.device.startBLEScan;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLEScanSync } = device;
+ *
+ * const result = startBLEScanSync();
+ * console.log('startBLEScanSync result', result);
+ * ```
  */
 export declare const startBLEScanSync: typeof ty.device.startBLEScanSync;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopBLEScan } = device;
+ *
+ * stopBLEScan({
+ *   success: () => {
+ *     console.log('stopBLEScan success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopBLEScan fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopBLEScan: typeof ty.device.stopBLEScan;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopBLEScanSync } = device;
+ *
+ * const result = stopBLEScanSync();
+ * console.log('stopBLEScanSync result', result);
+ * ```
  */
 export declare const stopBLEScanSync: typeof ty.device.stopBLEScanSync;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { bluetoothCapabilityIsSupport } = device;
+ *
+ * bluetoothCapabilityIsSupport({
+ *   deviceId: 'device_001',
+ *   capability: 0,
+ *   success: (result) => {
+ *     console.log('bluetoothCapabilityIsSupport success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('bluetoothCapabilityIsSupport fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const bluetoothCapabilityIsSupport: typeof ty.device.bluetoothCapabilityIsSupport;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getBTDeviceInfo } = device;
+ *
+ * getBTDeviceInfo({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getBTDeviceInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getBTDeviceInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getBTDeviceInfo: typeof ty.device.getBTDeviceInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startGWActivation } = device;
+ *
+ * startGWActivation({
+ *   gateway: { gwId: 'example' },
+ *   timeout: 0,
+ *   success: () => {
+ *     console.log('startGWActivation success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startGWActivation fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startGWActivation: typeof ty.device.startGWActivation;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopGWActivation } = device;
+ *
+ * stopGWActivation({
+ *   gwId: 'example',
+ *   success: () => {
+ *     console.log('stopGWActivation success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopGWActivation fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopGWActivation: typeof ty.device.stopGWActivation;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openReconnectPage } = device;
+ *
+ * openReconnectPage({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openReconnectPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openReconnectPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openReconnectPage: typeof ty.device.openReconnectPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startDirectlyConnectedDeviceActivator } = device;
+ *
+ * startDirectlyConnectedDeviceActivator({
+ *   device: { deviceId: 'device_001' },
+ *   timeout: 0,
+ *   success: () => {
+ *     console.log('startDirectlyConnectedDeviceActivator success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startDirectlyConnectedDeviceActivator fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startDirectlyConnectedDeviceActivator: typeof ty.device.startDirectlyConnectedDeviceActivator;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopDirectlyConnectedDeviceActivator } = device;
+ *
+ * stopDirectlyConnectedDeviceActivator({
+ *   device: { deviceId: 'device_001' },
+ *   timeout: 0,
+ *   success: () => {
+ *     console.log('stopDirectlyConnectedDeviceActivator success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopDirectlyConnectedDeviceActivator fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopDirectlyConnectedDeviceActivator: typeof ty.device.stopDirectlyConnectedDeviceActivator;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openCategoryActivatorPage } = device;
+ *
+ * openCategoryActivatorPage({
+ *   success: () => {
+ *     console.log('openCategoryActivatorPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openCategoryActivatorPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openCategoryActivatorPage: typeof ty.device.openCategoryActivatorPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startDirectlyConnectedSearchDevice } = device;
+ *
+ * startDirectlyConnectedSearchDevice({
+ *   device: { deviceId: 'device_001' },
+ *   timeout: 0,
+ *   success: () => {
+ *     console.log('startDirectlyConnectedSearchDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startDirectlyConnectedSearchDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startDirectlyConnectedSearchDevice: typeof ty.device.startDirectlyConnectedSearchDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopDirectlyConnectedSearchDevice } = device;
+ *
+ * stopDirectlyConnectedSearchDevice({
+ *   device: { deviceId: 'device_001' },
+ *   timeout: 0,
+ *   success: () => {
+ *     console.log('stopDirectlyConnectedSearchDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopDirectlyConnectedSearchDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopDirectlyConnectedSearchDevice: typeof ty.device.stopDirectlyConnectedSearchDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceWifiActivatorStatus } = device;
+ *
+ * getDeviceWifiActivatorStatus({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceWifiActivatorStatus success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceWifiActivatorStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceWifiActivatorStatus: typeof ty.device.getDeviceWifiActivatorStatus;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startDeviceWifiActivator } = device;
+ *
+ * startDeviceWifiActivator({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('startDeviceWifiActivator success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('startDeviceWifiActivator fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startDeviceWifiActivator: typeof ty.device.startDeviceWifiActivator;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { renameDeviceName } = device;
+ *
+ * renameDeviceName({
+ *   deviceId: 'device_001',
+ *   name: 'example',
+ *   success: () => {
+ *     console.log('renameDeviceName success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('renameDeviceName fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const renameDeviceName: typeof ty.device.renameDeviceName;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { resetFactory } = device;
+ *
+ * resetFactory({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('resetFactory success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('resetFactory fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const resetFactory: typeof ty.device.resetFactory;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { removeDevice } = device;
+ *
+ * removeDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('removeDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('removeDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const removeDevice: typeof ty.device.removeDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerZigbeeGateWaySubDeviceListener } = device;
+ *
+ * registerZigbeeGateWaySubDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('registerZigbeeGateWaySubDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerZigbeeGateWaySubDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerZigbeeGateWaySubDeviceListener: typeof ty.device.registerZigbeeGateWaySubDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterZigbeeGateWaySubDeviceListener } = device;
+ *
+ * unregisterZigbeeGateWaySubDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unregisterZigbeeGateWaySubDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterZigbeeGateWaySubDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterZigbeeGateWaySubDeviceListener: typeof ty.device.unregisterZigbeeGateWaySubDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceOnlineType } = device;
+ *
+ * getDeviceOnlineType({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceOnlineType success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceOnlineType fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceOnlineType: typeof ty.device.getDeviceOnlineType;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceInfo } = device;
+ *
+ * getDeviceInfo({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceInfo: typeof ty.device.getDeviceInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getProductInfo } = device;
+ *
+ * getProductInfo({
+ *   productId: 'example',
+ *   success: (result) => {
+ *     console.log('getProductInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getProductInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getProductInfo: typeof ty.device.getProductInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getSubDeviceInfoList } = device;
+ *
+ * getSubDeviceInfoList({
+ *   meshId: 'example',
+ *   success: (result) => {
+ *     console.log('getSubDeviceInfoList success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getSubDeviceInfoList fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getSubDeviceInfoList: typeof ty.device.getSubDeviceInfoList;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { validDeviceOnlineType } = device;
+ *
+ * validDeviceOnlineType({
+ *   deviceId: 'device_001',
+ *   onlineType: 0,
+ *   success: (result) => {
+ *     console.log('validDeviceOnlineType success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('validDeviceOnlineType fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const validDeviceOnlineType: typeof ty.device.validDeviceOnlineType;
 /**
  * @public
  * @since @ray-js/ray 0.10.4
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishDpsBase } = device;
+ *
+ * publishDpsBase({
+ *   deviceId: 'device_001',
+ *   dps: {},
+ *   mode: 0,
+ *   pipelines: [],
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishDpsBase success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishDpsBase fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishDpsBase: typeof ty.device.publishDps;
 /**
  * @public
  * @since @ray-js/ray 0.10.4
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishDps } = device;
+ *
+ * publishDps({
+ *   deviceId: 'device_001',
+ *   dps: {},
+ *   mode: 0,
+ *   pipelines: [],
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishDpsBase success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishDpsBase fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishDps: typeof ty.device.publishDps;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishCommands } = device;
+ *
+ * publishCommands({
+ *   deviceId: 'device_001',
+ *   dps: {},
+ *   mode: 0,
+ *   pipelines: [],
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishCommands success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishCommands fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishCommands: typeof ty.device.publishCommands;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishDpsWithPipeType } = device;
+ *
+ * publishDpsWithPipeType({
+ *   deviceId: 'device_001',
+ *   dps: {},
+ *   mode: 0,
+ *   pipelines: [],
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishDpsWithPipeType success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishDpsWithPipeType fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishDpsWithPipeType: typeof ty.device.publishDpsWithPipeType;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { queryDps } = device;
+ *
+ * queryDps({
+ *   deviceId: 'device_001',
+ *   dpIds: [],
+ *   success: (result) => {
+ *     console.log('queryDps success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('queryDps fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const queryDps: typeof ty.device.queryDps;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishMqttMessage } = device;
+ *
+ * publishMqttMessage({
+ *   message: {},
+ *   deviceId: 'device_001',
+ *   protocol: 0,
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishMqttMessage success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishMqttMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishMqttMessage: typeof ty.device.publishMqttMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishLanMessage } = device;
+ *
+ * publishLanMessage({
+ *   message: 'example',
+ *   deviceId: 'device_001',
+ *   protocol: 0,
+ *   success: (result) => {
+ *     console.log('publishLanMessage success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishLanMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishLanMessage: typeof ty.device.publishLanMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishSocketMessage } = device;
+ *
+ * publishSocketMessage({
+ *   message: {},
+ *   deviceId: 'device_001',
+ *   type: 0,
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('publishSocketMessage success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishSocketMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishSocketMessage: typeof ty.device.publishSocketMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceProperty } = device;
+ *
+ * getDeviceProperty({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceProperty success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceProperty fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceProperty: typeof ty.device.getDeviceProperty;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { setDeviceProperty } = device;
+ *
+ * setDeviceProperty({
+ *   deviceId: 'device_001',
+ *   code: 'example',
+ *   value: 'example',
+ *   success: (result) => {
+ *     console.log('setDeviceProperty success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('setDeviceProperty fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const setDeviceProperty: typeof ty.device.setDeviceProperty;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { syncDeviceInfo } = device;
+ *
+ * syncDeviceInfo({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('syncDeviceInfo success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('syncDeviceInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const syncDeviceInfo: typeof ty.device.syncDeviceInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { subscribeDeviceRemoved } = device;
+ *
+ * subscribeDeviceRemoved({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('subscribeDeviceRemoved success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('subscribeDeviceRemoved fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const subscribeDeviceRemoved: typeof ty.device.subscribeDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unSubscribeDeviceRemoved } = device;
+ *
+ * unSubscribeDeviceRemoved({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unSubscribeDeviceRemoved success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unSubscribeDeviceRemoved fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unSubscribeDeviceRemoved: typeof ty.device.unSubscribeDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerMQTTDeviceListener } = device;
+ *
+ * registerMQTTDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('registerMQTTDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerMQTTDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerMQTTDeviceListener: typeof ty.device.registerMQTTDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterMQTTDeviceListener } = device;
+ *
+ * unregisterMQTTDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unregisterMQTTDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterMQTTDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterMQTTDeviceListener: typeof ty.device.unregisterMQTTDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerMQTTProtocolListener } = device;
+ *
+ * registerMQTTProtocolListener({
+ *   protocol: 0,
+ *   success: () => {
+ *     console.log('registerMQTTProtocolListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerMQTTProtocolListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerMQTTProtocolListener: typeof ty.device.registerMQTTProtocolListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterMQTTProtocolListener } = device;
+ *
+ * unregisterMQTTProtocolListener({
+ *   protocol: 0,
+ *   success: () => {
+ *     console.log('unregisterMQTTProtocolListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterMQTTProtocolListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterMQTTProtocolListener: typeof ty.device.unregisterMQTTProtocolListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerDeviceListListener } = device;
+ *
+ * registerDeviceListListener({
+ *   deviceIdList: ['example'],
+ *   success: () => {
+ *     console.log('registerDeviceListListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerDeviceListListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerDeviceListListener: typeof ty.device.registerDeviceListListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterDeviceListListener } = device;
+ *
+ * unregisterDeviceListListener({
+ *   success: () => {
+ *     console.log('unregisterDeviceListListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterDeviceListListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterDeviceListListener: typeof ty.device.unregisterDeviceListListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerTopicListListener } = device;
+ *
+ * registerTopicListListener({
+ *   topicList: ['example'],
+ *   success: () => {
+ *     console.log('registerTopicListListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerTopicListListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerTopicListListener: typeof ty.device.registerTopicListListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterTopicListListener } = device;
+ *
+ * unregisterTopicListListener({
+ *   success: () => {
+ *     console.log('unregisterTopicListListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterTopicListListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterTopicListListener: typeof ty.device.unregisterTopicListListener;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getMqttConnectState } = device;
+ *
+ * getMqttConnectState({
+ *   success: (result) => {
+ *     console.log('getMqttConnectState success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getMqttConnectState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getMqttConnectState: typeof ty.device.getMqttConnectState;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { checkOTAUpdateInfo } = device;
+ *
+ * checkOTAUpdateInfo({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('checkOTAUpdateInfo success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('checkOTAUpdateInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const checkOTAUpdateInfo: typeof ty.device.checkOTAUpdateInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceDetailPage } = device;
+ *
+ * openDeviceDetailPage({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceDetailPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceDetailPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceDetailPage: typeof ty.device.openDeviceDetailPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openGroupDetailPage } = device;
+ *
+ * openGroupDetailPage({
+ *   groupId: 'example',
+ *   success: () => {
+ *     console.log('openGroupDetailPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openGroupDetailPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openGroupDetailPage: typeof ty.device.openGroupDetailPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openTimerPage } = device;
+ *
+ * openTimerPage({
+ *   deviceId: 'device_001',
+ *   category: 'example',
+ *   data: [],
+ *   success: () => {
+ *     console.log('openTimerPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openTimerPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openTimerPage: typeof ty.device.openTimerPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openGroupTimerPage } = device;
+ *
+ * openGroupTimerPage({
+ *   groupId: 'example',
+ *   category: 'example',
+ *   data: [],
+ *   success: () => {
+ *     console.log('openGroupTimerPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openGroupTimerPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openGroupTimerPage: typeof ty.device.openGroupTimerPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceWifiNetworkMonitorPage } = device;
+ *
+ * openDeviceWifiNetworkMonitorPage({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceWifiNetworkMonitorPage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceWifiNetworkMonitorPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceWifiNetworkMonitorPage: typeof ty.device.openDeviceWifiNetworkMonitorPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { syncTimerTask } = device;
+ *
+ * syncTimerTask({
+ *   category: 'example',
+ *   success: (result) => {
+ *     console.log('syncTimerTask success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('syncTimerTask fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const syncTimerTask: typeof ty.device.syncTimerTask;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { addTimer } = device;
+ *
+ * addTimer({
+ *   category: 'example',
+ *   timer: { time: 'example', loops: 'example', dps: {} },
+ *   success: (result) => {
+ *     console.log('addTimer success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('addTimer fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const addTimer: typeof ty.device.addTimer;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { updateTimer } = device;
+ *
+ * updateTimer({
+ *   timer: { timerId: 'example', time: 'example', loops: 'example', dps: {} },
+ *   success: () => {
+ *     console.log('updateTimer success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('updateTimer fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const updateTimer: typeof ty.device.updateTimer;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { updateTimerStatus } = device;
+ *
+ * updateTimerStatus({
+ *   timerId: 'example',
+ *   status: true,
+ *   success: () => {
+ *     console.log('updateTimerStatus success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('updateTimerStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const updateTimerStatus: typeof ty.device.updateTimerStatus;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { removeTimer } = device;
+ *
+ * removeTimer({
+ *   timerId: 'example',
+ *   success: () => {
+ *     console.log('removeTimer success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('removeTimer fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const removeTimer: typeof ty.device.removeTimer;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getShareDeviceInfo } = device;
+ *
+ * getShareDeviceInfo({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getShareDeviceInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getShareDeviceInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getShareDeviceInfo: typeof ty.device.getShareDeviceInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceEdit } = device;
+ *
+ * openDeviceEdit({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceEdit success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceEdit fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceEdit: typeof ty.device.openDeviceEdit;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openGroupEdit } = device;
+ *
+ * openGroupEdit({
+ *   groupId: 'example',
+ *   success: () => {
+ *     console.log('openGroupEdit success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openGroupEdit fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openGroupEdit: typeof ty.device.openGroupEdit;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceInfo } = device;
+ *
+ * openDeviceInfo({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceInfo success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceInfo: typeof ty.device.openDeviceInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { isDeviceSupportOfflineReminder } = device;
+ *
+ * isDeviceSupportOfflineReminder({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('isDeviceSupportOfflineReminder success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('isDeviceSupportOfflineReminder fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const isDeviceSupportOfflineReminder: typeof ty.device.isDeviceSupportOfflineReminder;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceOfflineReminderState } = device;
+ *
+ * getDeviceOfflineReminderState({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceOfflineReminderState success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceOfflineReminderState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceOfflineReminderState: typeof ty.device.getDeviceOfflineReminderState;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { toggleDeviceOfflineReminder } = device;
+ *
+ * toggleDeviceOfflineReminder({
+ *   deviceId: 'device_001',
+ *   state: 0,
+ *   success: () => {
+ *     console.log('toggleDeviceOfflineReminder success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('toggleDeviceOfflineReminder fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const toggleDeviceOfflineReminder: typeof ty.device.toggleDeviceOfflineReminder;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceOfflineReminderWarningText } = device;
+ *
+ * getDeviceOfflineReminderWarningText({
+ *   success: (result) => {
+ *     console.log('getDeviceOfflineReminderWarningText success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceOfflineReminderWarningText fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceOfflineReminderWarningText: typeof ty.device.getDeviceOfflineReminderWarningText;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceQuestionsAndFeedback } = device;
+ *
+ * openDeviceQuestionsAndFeedback({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceQuestionsAndFeedback success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceQuestionsAndFeedback fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceQuestionsAndFeedback: typeof ty.device.openDeviceQuestionsAndFeedback;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openShareDevice } = device;
+ *
+ * openShareDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openShareDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openShareDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openShareDevice: typeof ty.device.openShareDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { addDeviceToDesk } = device;
+ *
+ * addDeviceToDesk({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('addDeviceToDesk success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('addDeviceToDesk fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const addDeviceToDesk: typeof ty.device.addDeviceToDesk;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { removeShareDevice } = device;
+ *
+ * removeShareDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('removeShareDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('removeShareDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const removeShareDevice: typeof ty.device.removeShareDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getSupportedThirdPartyServices } = device;
+ *
+ * getSupportedThirdPartyServices({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getSupportedThirdPartyServices success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getSupportedThirdPartyServices fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getSupportedThirdPartyServices: typeof ty.device.getSupportedThirdPartyServices;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openRecommendSceneDetail } = device;
+ *
+ * openRecommendSceneDetail({
+ *   source: 'example',
+ *   sceneModel: {},
+ *   success: (result) => {
+ *     console.log('openRecommendSceneDetail success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('openRecommendSceneDetail fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openRecommendSceneDetail: typeof ty.device.openRecommendSceneDetail;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openDeviceExecutionAndAnutomation } = device;
+ *
+ * openDeviceExecutionAndAnutomation({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openDeviceExecutionAndAnutomation success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openDeviceExecutionAndAnutomation fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openDeviceExecutionAndAnutomation: typeof ty.device.openDeviceExecutionAndAnutomation;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { saveSceneAction } = device;
+ *
+ * saveSceneAction({
+ *   deviceId: 'device_001',
+ *   taskPosition: 0,
+ *   executorProperty: {},
+ *   extraProperty: {},
+ *   actionDisplayNew: {},
+ *   success: () => {
+ *     console.log('saveSceneAction success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('saveSceneAction fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const saveSceneAction: typeof ty.device.saveSceneAction;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { createAction } = device;
+ *
+ * createAction({
+ *   createType: 'example',
+ *   smartType: 'example',
+ *   actionArray: [],
+ *   success: (result) => {
+ *     console.log('createAction success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('createAction fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const createAction: typeof ty.device.createAction;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { editAction } = device;
+ *
+ * editAction({
+ *   editIndex: 'example',
+ *   smartType: 'example',
+ *   actionArray: [],
+ *   success: (result) => {
+ *     console.log('editAction success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('editAction fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const editAction: typeof ty.device.editAction;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { showSceneDialog } = device;
+ *
+ * showSceneDialog({
+ *   success: (result) => {
+ *     console.log('showSceneDialog success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('showSceneDialog fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const showSceneDialog: typeof ty.device.showSceneDialog;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openPreConditionPage } = device;
+ *
+ * openPreConditionPage({
+ *   success: (result) => {
+ *     console.log('openPreConditionPage success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('openPreConditionPage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openPreConditionPage: typeof ty.device.openPreConditionPage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { createCondition } = device;
+ *
+ * createCondition({
+ *   type: 'example',
+ *   success: (result) => {
+ *     console.log('createCondition success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('createCondition fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const createCondition: typeof ty.device.createCondition;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { editCondition } = device;
+ *
+ * editCondition({
+ *   type: 'example',
+ *   success: (result) => {
+ *     console.log('editCondition success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('editCondition fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const editCondition: typeof ty.device.editCondition;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getGroupDeviceList } = device;
+ *
+ * getGroupDeviceList({
+ *   groupId: 'example',
+ *   success: (result) => {
+ *     console.log('getGroupDeviceList success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getGroupDeviceList fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getGroupDeviceList: typeof ty.device.getGroupDeviceList;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getGroupDeviceNum } = device;
+ *
+ * getGroupDeviceNum({
+ *   groupId: 'example',
+ *   success: (result) => {
+ *     console.log('getGroupDeviceNum success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getGroupDeviceNum fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getGroupDeviceNum: typeof ty.device.getGroupDeviceNum;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceNumWithDpCode } = device;
+ *
+ * getDeviceNumWithDpCode({
+ *   groupId: 'example',
+ *   dpCode: 'switch_led',
+ *   success: (result) => {
+ *     console.log('getDeviceNumWithDpCode success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceNumWithDpCode fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceNumWithDpCode: typeof ty.device.getDeviceNumWithDpCode;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishGroupDpCodes } = device;
+ *
+ * publishGroupDpCodes({
+ *   groupId: 'example',
+ *   dpCodes: {},
+ *   success: () => {
+ *     console.log('publishGroupDpCodes success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishGroupDpCodes fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishGroupDpCodes: typeof ty.device.publishGroupDpCodes;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishSigMeshMultiDps } = device;
+ *
+ * publishSigMeshMultiDps({
+ *   groupId: 'example',
+ *   localId: 'example',
+ *   dps: {},
+ *   pcc: 'example',
+ *   success: () => {
+ *     console.log('publishSigMeshMultiDps success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishSigMeshMultiDps fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishSigMeshMultiDps: typeof ty.device.publishSigMeshMultiDps;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openMeshLocalGroup } = device;
+ *
+ * openMeshLocalGroup({
+ *   deviceId: 'device_001',
+ *   localId: 'example',
+ *   vendorIds: 'example',
+ *   success: () => {
+ *     console.log('openMeshLocalGroup success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openMeshLocalGroup fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openMeshLocalGroup: typeof ty.device.openMeshLocalGroup;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getGroupInfo } = device;
+ *
+ * getGroupInfo({
+ *   groupId: 'example',
+ *   success: (result) => {
+ *     console.log('getGroupInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getGroupInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getGroupInfo: typeof ty.device.getGroupInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishGroupDps } = device;
+ *
+ * publishGroupDps({
+ *   groupId: 'example',
+ *   dps: {},
+ *   success: () => {
+ *     console.log('publishGroupDps success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishGroupDps fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishGroupDps: typeof ty.device.publishGroupDps;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getGroupProperty } = device;
+ *
+ * getGroupProperty({
+ *   groupId: 'example',
+ *   success: (result) => {
+ *     console.log('getGroupProperty success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getGroupProperty fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getGroupProperty: typeof ty.device.getGroupProperty;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { setGroupProperty } = device;
+ *
+ * setGroupProperty({
+ *   groupId: 'example',
+ *   code: 'example',
+ *   value: 'example',
+ *   success: () => {
+ *     console.log('setGroupProperty success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('setGroupProperty fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const setGroupProperty: typeof ty.device.setGroupProperty;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerGroupChange } = device;
+ *
+ * registerGroupChange({
+ *   groupIdList: ['example'],
+ *   success: () => {
+ *     console.log('registerGroupChange success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerGroupChange fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerGroupChange: typeof ty.device.registerGroupChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unRegisterGroupChange } = device;
+ *
+ * unRegisterGroupChange({
+ *   success: () => {
+ *     console.log('unRegisterGroupChange success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unRegisterGroupChange fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unRegisterGroupChange: typeof ty.device.unRegisterGroupChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getMeshDeviceId } = device;
+ *
+ * getMeshDeviceId({
+ *   nodeId: 'example',
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getMeshDeviceId success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getMeshDeviceId fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getMeshDeviceId: typeof ty.device.getMeshDeviceId;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDpDataByMesh } = device;
+ *
+ * getDpDataByMesh({
+ *   deviceId: 'device_001',
+ *   dpIds: [],
+ *   success: () => {
+ *     console.log('getDpDataByMesh success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDpDataByMesh fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDpDataByMesh: typeof ty.device.getDpDataByMesh;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { checkOTAUpgradeStatus } = device;
+ *
+ * checkOTAUpgradeStatus({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('checkOTAUpgradeStatus success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('checkOTAUpgradeStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const checkOTAUpgradeStatus: typeof ty.device.checkOTAUpgradeStatus;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { openOTAUpgrade } = device;
+ *
+ * openOTAUpgrade({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('openOTAUpgrade success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('openOTAUpgrade fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const openOTAUpgrade: typeof ty.device.openOTAUpgrade;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { deviceIsSupportThingModel } = device;
+ *
+ * deviceIsSupportThingModel({
+ *   devId: 'device_001',
+ *   success: (result) => {
+ *     console.log('deviceIsSupportThingModel success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('deviceIsSupportThingModel fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const deviceIsSupportThingModel: typeof ty.device.deviceIsSupportThingModel;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { updateDeviceThingModelInfo } = device;
+ *
+ * updateDeviceThingModelInfo({
+ *   pid: 'example',
+ *   productVersion: 'example',
+ *   success: () => {
+ *     console.log('updateDeviceThingModelInfo success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('updateDeviceThingModelInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const updateDeviceThingModelInfo: typeof ty.device.updateDeviceThingModelInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceThingModelInfo } = device;
+ *
+ * getDeviceThingModelInfo({
+ *   devId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceThingModelInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceThingModelInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceThingModelInfo: typeof ty.device.getDeviceThingModelInfo;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishThingModelMessage } = device;
+ *
+ * publishThingModelMessage({
+ *   devId: 'device_001',
+ *   type: 0,
+ *   payload: {},
+ *   success: () => {
+ *     console.log('publishThingModelMessage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishThingModelMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishThingModelMessage: typeof ty.device.publishThingModelMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { subscribeReceivedThingModelMessage } = device;
+ *
+ * subscribeReceivedThingModelMessage({
+ *   devId: 'device_001',
+ *   success: () => {
+ *     console.log('subscribeReceivedThingModelMessage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('subscribeReceivedThingModelMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const subscribeReceivedThingModelMessage: typeof ty.device.subscribeReceivedThingModelMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unSubscribeReceivedThingModelMessage } = device;
+ *
+ * unSubscribeReceivedThingModelMessage({
+ *   devId: 'device_001',
+ *   success: () => {
+ *     console.log('unSubscribeReceivedThingModelMessage success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unSubscribeReceivedThingModelMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unSubscribeReceivedThingModelMessage: typeof ty.device.unSubscribeReceivedThingModelMessage;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onLeaveBeaconFence } = device;
+ *
+ * onLeaveBeaconFence((res) => {
+ *   console.log('onLeaveBeaconFence', res);
+ * });
+ * ```
  */
 export declare const onLeaveBeaconFence: typeof ty.device.onLeaveBeaconFence;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offLeaveBeaconFence } = device;
+ *
+ * offLeaveBeaconFence((res) => {
+ *   console.log('offLeaveBeaconFence', res);
+ * });
+ * ```
  */
 export declare const offLeaveBeaconFence: typeof ty.device.offLeaveBeaconFence;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onFileTransferProgress } = device;
+ *
+ * onFileTransferProgress((res) => {
+ *   console.log('onFileTransferProgress', res);
+ * });
+ * ```
  */
 export declare const onFileTransferProgress: typeof ty.device.onFileTransferProgress;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offFileTransferProgress } = device;
+ *
+ * offFileTransferProgress((res) => {
+ *   console.log('offFileTransferProgress', res);
+ * });
+ * ```
  */
 export declare const offFileTransferProgress: typeof ty.device.offFileTransferProgress;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLEConnectStatusChange } = device;
+ *
+ * onBLEConnectStatusChange((res) => {
+ *   console.log('onBLEConnectStatusChange', res);
+ * });
+ * ```
  */
 export declare const onBLEConnectStatusChange: typeof ty.device.onBLEConnectStatusChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLEConnectStatusChange } = device;
+ *
+ * offBLEConnectStatusChange((res) => {
+ *   console.log('offBLEConnectStatusChange', res);
+ * });
+ * ```
  */
 export declare const offBLEConnectStatusChange: typeof ty.device.offBLEConnectStatusChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLETransparentDataReport } = device;
+ *
+ * onBLETransparentDataReport((res) => {
+ *   console.log('onBLETransparentDataReport', res);
+ * });
+ * ```
  */
 export declare const onBLETransparentDataReport: typeof ty.device.onBLETransparentDataReport;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLETransparentDataReport } = device;
+ *
+ * offBLETransparentDataReport((res) => {
+ *   console.log('offBLETransparentDataReport', res);
+ * });
+ * ```
  */
 export declare const offBLETransparentDataReport: typeof ty.device.offBLETransparentDataReport;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLEBigDataChannelProgressEvent } = device;
+ *
+ * onBLEBigDataChannelProgressEvent((res) => {
+ *   console.log('onBLEBigDataChannelProgressEvent', res);
+ * });
+ * ```
  */
 export declare const onBLEBigDataChannelProgressEvent: typeof ty.device.onBLEBigDataChannelProgressEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLEBigDataChannelProgressEvent } = device;
+ *
+ * offBLEBigDataChannelProgressEvent((res) => {
+ *   console.log('offBLEBigDataChannelProgressEvent', res);
+ * });
+ * ```
  */
 export declare const offBLEBigDataChannelProgressEvent: typeof ty.device.offBLEBigDataChannelProgressEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLEScanBindDevice } = device;
+ *
+ * onBLEScanBindDevice((res) => {
+ *   console.log('onBLEScanBindDevice', res);
+ * });
+ * ```
  */
 export declare const onBLEScanBindDevice: typeof ty.device.onBLEScanBindDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLEScanBindDevice } = device;
+ *
+ * offBLEScanBindDevice((res) => {
+ *   console.log('offBLEScanBindDevice', res);
+ * });
+ * ```
  */
 export declare const offBLEScanBindDevice: typeof ty.device.offBLEScanBindDevice;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLEBigDataChannelDeviceToAppSuccess } = device;
+ *
+ * onBLEBigDataChannelDeviceToAppSuccess((res) => {
+ *   console.log('onBLEBigDataChannelDeviceToAppSuccess', res);
+ * });
+ * ```
  */
 export declare const onBLEBigDataChannelDeviceToAppSuccess: typeof ty.device.onBLEBigDataChannelDeviceToAppSuccess;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLEBigDataChannelDeviceToAppSuccess } = device;
+ *
+ * offBLEBigDataChannelDeviceToAppSuccess((res) => {
+ *   console.log('offBLEBigDataChannelDeviceToAppSuccess', res);
+ * });
+ * ```
  */
 export declare const offBLEBigDataChannelDeviceToAppSuccess: typeof ty.device.offBLEBigDataChannelDeviceToAppSuccess;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLEBigDataChannelUploadCloudProgress } = device;
+ *
+ * onBLEBigDataChannelUploadCloudProgress((res) => {
+ *   console.log('onBLEBigDataChannelUploadCloudProgress', res);
+ * });
+ * ```
  */
 export declare const onBLEBigDataChannelUploadCloudProgress: typeof ty.device.onBLEBigDataChannelUploadCloudProgress;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offBLEBigDataChannelUploadCloudProgress } = device;
+ *
+ * offBLEBigDataChannelUploadCloudProgress((res) => {
+ *   console.log('offBLEBigDataChannelUploadCloudProgress', res);
+ * });
+ * ```
  */
 export declare const offBLEBigDataChannelUploadCloudProgress: typeof ty.device.offBLEBigDataChannelUploadCloudProgress;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceInfoUpdateEvent } = device;
+ *
+ * onSubDeviceInfoUpdateEvent((res) => {
+ *   console.log('onSubDeviceInfoUpdateEvent', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceInfoUpdateEvent: typeof ty.device.onSubDeviceInfoUpdateEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSubDeviceInfoUpdateEvent } = device;
+ *
+ * offSubDeviceInfoUpdateEvent((res) => {
+ *   console.log('offSubDeviceInfoUpdateEvent', res);
+ * });
+ * ```
  */
 export declare const offSubDeviceInfoUpdateEvent: typeof ty.device.offSubDeviceInfoUpdateEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDirectlyConnectedSearchDeviceEvent } = device;
+ *
+ * onDirectlyConnectedSearchDeviceEvent((res) => {
+ *   console.log('onDirectlyConnectedSearchDeviceEvent', res);
+ * });
+ * ```
  */
 export declare const onDirectlyConnectedSearchDeviceEvent: typeof ty.device.onDirectlyConnectedSearchDeviceEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDirectlyConnectedSearchDeviceEvent } = device;
+ *
+ * offDirectlyConnectedSearchDeviceEvent((res) => {
+ *   console.log('offDirectlyConnectedSearchDeviceEvent', res);
+ * });
+ * ```
  */
 export declare const offDirectlyConnectedSearchDeviceEvent: typeof ty.device.offDirectlyConnectedSearchDeviceEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDpDataChange } = device;
+ *
+ * onDpDataChange((result) => {
+ *   console.log('onDpDataChange', result);
+ * });
+ * ```
  */
 export declare const onDpDataChange: typeof ty.device.onDpDataChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDpDataChange } = device;
+ *
+ * offDpDataChange((result) => {
+ *   console.log('offDpDataChange', result);
+ * });
+ * ```
  */
 export declare const offDpDataChange: typeof ty.device.offDpDataChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onMqttMessageReceived } = device;
+ *
+ * onMqttMessageReceived((res) => {
+ *   console.log('onMqttMessageReceived', res);
+ * });
+ * ```
  */
 export declare const onMqttMessageReceived: typeof ty.device.onMqttMessageReceived;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offMqttMessageReceived } = device;
+ *
+ * offMqttMessageReceived((res) => {
+ *   console.log('offMqttMessageReceived', res);
+ * });
+ * ```
  */
 export declare const offMqttMessageReceived: typeof ty.device.offMqttMessageReceived;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSocketMessageReceived } = device;
+ *
+ * onSocketMessageReceived((res) => {
+ *   console.log('onSocketMessageReceived', res);
+ * });
+ * ```
  */
 export declare const onSocketMessageReceived: typeof ty.device.onSocketMessageReceived;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSocketMessageReceived } = device;
+ *
+ * offSocketMessageReceived((res) => {
+ *   console.log('offSocketMessageReceived', res);
+ * });
+ * ```
  */
 export declare const offSocketMessageReceived: typeof ty.device.offSocketMessageReceived;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDeviceOnlineStatusUpdate } = device;
+ *
+ * onDeviceOnlineStatusUpdate((res) => {
+ *   console.log('onDeviceOnlineStatusUpdate', res);
+ * });
+ * ```
  */
 export declare const onDeviceOnlineStatusUpdate: typeof ty.device.onDeviceOnlineStatusUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDeviceOnlineStatusUpdate } = device;
+ *
+ * offDeviceOnlineStatusUpdate((res) => {
+ *   console.log('offDeviceOnlineStatusUpdate', res);
+ * });
+ * ```
  */
 export declare const offDeviceOnlineStatusUpdate: typeof ty.device.offDeviceOnlineStatusUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDeviceInfoUpdated } = device;
+ *
+ * onDeviceInfoUpdated((res) => {
+ *   console.log('onDeviceInfoUpdated', res);
+ * });
+ * ```
  */
 export declare const onDeviceInfoUpdated: typeof ty.device.onDeviceInfoUpdated;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDeviceInfoUpdated } = device;
+ *
+ * offDeviceInfoUpdated((res) => {
+ *   console.log('offDeviceInfoUpdated', res);
+ * });
+ * ```
  */
 export declare const offDeviceInfoUpdated: typeof ty.device.offDeviceInfoUpdated;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDeviceRemoved } = device;
+ *
+ * onDeviceRemoved((res) => {
+ *   console.log('onDeviceRemoved', res);
+ * });
+ * ```
  */
 export declare const onDeviceRemoved: typeof ty.device.onDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDeviceRemoved } = device;
+ *
+ * offDeviceRemoved((res) => {
+ *   console.log('offDeviceRemoved', res);
+ * });
+ * ```
  */
 export declare const offDeviceRemoved: typeof ty.device.offDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onMqttConnectState } = device;
+ *
+ * onMqttConnectState((res) => {
+ *   console.log('onMqttConnectState', res);
+ * });
+ * ```
  */
 export declare const onMqttConnectState: typeof ty.device.onMqttConnectState;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offMqttConnectState } = device;
+ *
+ * offMqttConnectState((res) => {
+ *   console.log('offMqttConnectState', res);
+ * });
+ * ```
  */
 export declare const offMqttConnectState: typeof ty.device.offMqttConnectState;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onTimerUpdate } = device;
+ *
+ * onTimerUpdate((res) => {
+ *   console.log('onTimerUpdate', res);
+ * });
+ * ```
  */
 export declare const onTimerUpdate: typeof ty.device.onTimerUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offTimerUpdate } = device;
+ *
+ * offTimerUpdate((res) => {
+ *   console.log('offTimerUpdate', res);
+ * });
+ * ```
  */
 export declare const offTimerUpdate: typeof ty.device.offTimerUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onGroupInfoChange } = device;
+ *
+ * onGroupInfoChange((res) => {
+ *   console.log('onGroupInfoChange', res);
+ * });
+ * ```
  */
 export declare const onGroupInfoChange: typeof ty.device.onGroupInfoChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offGroupInfoChange } = device;
+ *
+ * offGroupInfoChange((res) => {
+ *   console.log('offGroupInfoChange', res);
+ * });
+ * ```
  */
 export declare const offGroupInfoChange: typeof ty.device.offGroupInfoChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onGroupDpCodeChange } = device;
+ *
+ * onGroupDpCodeChange((res) => {
+ *   console.log('onGroupDpCodeChange', res);
+ * });
+ * ```
  */
 export declare const onGroupDpCodeChange: typeof ty.device.onGroupDpCodeChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offGroupDpCodeChange } = device;
+ *
+ * offGroupDpCodeChange((res) => {
+ *   console.log('offGroupDpCodeChange', res);
+ * });
+ * ```
  */
 export declare const offGroupDpCodeChange: typeof ty.device.offGroupDpCodeChange;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onGroupRemovedEvent } = device;
+ *
+ * onGroupRemovedEvent((res) => {
+ *   console.log('onGroupRemovedEvent', res);
+ * });
+ * ```
  */
 export declare const onGroupRemovedEvent: typeof ty.device.onGroupRemovedEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offGroupRemovedEvent } = device;
+ *
+ * offGroupRemovedEvent((res) => {
+ *   console.log('offGroupRemovedEvent', res);
+ * });
+ * ```
  */
 export declare const offGroupRemovedEvent: typeof ty.device.offGroupRemovedEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onGroupDpDataChangeEvent } = device;
+ *
+ * onGroupDpDataChangeEvent((res) => {
+ *   console.log('onGroupDpDataChangeEvent', res);
+ * });
+ * ```
  */
 export declare const onGroupDpDataChangeEvent: typeof ty.device.onGroupDpDataChangeEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offGroupDpDataChangeEvent } = device;
+ *
+ * offGroupDpDataChangeEvent((res) => {
+ *   console.log('offGroupDpDataChangeEvent', res);
+ * });
+ * ```
  */
 export declare const offGroupDpDataChangeEvent: typeof ty.device.offGroupDpDataChangeEvent;
 /**
  * @public
  * @since @ray-js/ray 0.6.23
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onReceivedThingModelMessage } = device;
+ *
+ * onReceivedThingModelMessage((res) => {
+ *   console.log('onReceivedThingModelMessage', res);
+ * });
+ * ```
  */
 export declare const onReceivedThingModelMessage: typeof ty.device.onReceivedThingModelMessage;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offReceivedThingModelMessage } = device;
+ *
+ * offReceivedThingModelMessage((res) => {
+ *   console.log('offReceivedThingModelMessage', res);
+ * });
+ * ```
  */
 export declare const offReceivedThingModelMessage: typeof ty.device.offReceivedThingModelMessage;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { connectBluetoothDevice } = device;
+ *
+ * connectBluetoothDevice({
+ *   devId: 'device_001',
+ *   success: () => {
+ *     console.log('connectBluetoothDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('connectBluetoothDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const connectBluetoothDevice: typeof ty.device.connectBluetoothDevice;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { disconnectBluetoothDevice } = device;
+ *
+ * disconnectBluetoothDevice({
+ *   devId: 'device_001',
+ *   success: () => {
+ *     console.log('disconnectBluetoothDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('disconnectBluetoothDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const disconnectBluetoothDevice: typeof ty.device.disconnectBluetoothDevice;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceAdded } = device;
+ *
+ * onSubDeviceAdded((res) => {
+ *   console.log('onSubDeviceAdded', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceAdded: typeof ty.device.onSubDeviceAdded;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSubDeviceAdded } = device;
+ *
+ * offSubDeviceAdded((res) => {
+ *   console.log('offSubDeviceAdded', res);
+ * });
+ * ```
  */
 export declare const offSubDeviceAdded: typeof ty.device.offSubDeviceAdded;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceDpUpdate } = device;
+ *
+ * onSubDeviceDpUpdate((res) => {
+ *   console.log('onSubDeviceDpUpdate', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceDpUpdate: typeof ty.device.onSubDeviceDpUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSubDeviceDpUpdate } = device;
+ *
+ * offSubDeviceDpUpdate((res) => {
+ *   console.log('offSubDeviceDpUpdate', res);
+ * });
+ * ```
  */
 export declare const offSubDeviceDpUpdate: typeof ty.device.offSubDeviceDpUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceInfoUpdate } = device;
+ *
+ * onSubDeviceInfoUpdate((res) => {
+ *   console.log('onSubDeviceInfoUpdate', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceInfoUpdate: typeof ty.device.onSubDeviceInfoUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSubDeviceInfoUpdate } = device;
+ *
+ * offSubDeviceInfoUpdate((res) => {
+ *   console.log('offSubDeviceInfoUpdate', res);
+ * });
+ * ```
  */
 export declare const offSubDeviceInfoUpdate: typeof ty.device.offSubDeviceInfoUpdate;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceRemoved } = device;
+ *
+ * onSubDeviceRemoved((res) => {
+ *   console.log('onSubDeviceRemoved', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceRemoved: typeof ty.device.onSubDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offSubDeviceRemoved } = device;
+ *
+ * offSubDeviceRemoved((res) => {
+ *   console.log('offSubDeviceRemoved', res);
+ * });
+ * ```
  */
 export declare const offSubDeviceRemoved: typeof ty.device.offSubDeviceRemoved;
 /**
  * @public
  * @since @ray-js/ray 0.8.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerGateWaySubDeviceListener } = device;
+ *
+ * registerGateWaySubDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('registerGateWaySubDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerGateWaySubDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerGateWaySubDeviceListener: typeof ty.device.registerGateWaySubDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.9.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { unregisterGateWaySubDeviceListener } = device;
+ *
+ * unregisterGateWaySubDeviceListener({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('unregisterGateWaySubDeviceListener success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('unregisterGateWaySubDeviceListener fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const unregisterGateWaySubDeviceListener: typeof ty.device.unregisterGateWaySubDeviceListener;
 /**
  * @public
  * @since @ray-js/ray 0.9.0
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceListByDevIds } = device;
+ *
+ * getDeviceListByDevIds({
+ *   deviceIds: ['device_001'],
+ *   success: (result) => {
+ *     console.log('getDeviceListByDevIds success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceListByDevIds fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceListByDevIds: typeof ty.device.getDeviceListByDevIds;
 /**
  * @public
  * @since @ray-js/ray 1.4.21
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { sendMqttMessage } = device;
+ *
+ * sendMqttMessage({
+ *   message: {},
+ *   deviceId: 'device_001',
+ *   protocol: 0,
+ *   options: {},
+ *   success: (result) => {
+ *     console.log('sendMqttMessage success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('sendMqttMessage fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const sendMqttMessage: typeof ty.device.sendMqttMessage;
 /**
  * @public
  * @since @ray-js/ray 1.4.21
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { dispatchSubFunctionTouchEvent } = device;
+ *
+ * dispatchSubFunctionTouchEvent({
+ *   id: 'example',
+ *   success: () => {
+ *     console.log('dispatchSubFunctionTouchEvent success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('dispatchSubFunctionTouchEvent fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const dispatchSubFunctionTouchEvent: typeof ty.device.dispatchSubFunctionTouchEvent;
 /**
  * @public
  * @since @ray-js/ray 1.4.57
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubFunctionDataChange } = device;
+ *
+ * onSubFunctionDataChange((res) => {
+ *   console.log('onSubFunctionDataChange', res);
+ * });
+ * ```
  */
 export declare const onSubFunctionDataChange: typeof ty.device.onSubFunctionDataChange;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { activeDeviceExtendModule } = device;
+ *
+ * activeDeviceExtendModule({
+ *   deviceId: 'device_001',
+ *   activeType: 0,
+ *   success: () => {
+ *     console.log('activeDeviceExtendModule success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('activeDeviceExtendModule fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const activeDeviceExtendModule: typeof ty.device.activeDeviceExtendModule;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { updateMeshProxyState } = device;
+ *
+ * updateMeshProxyState({
+ *   deviceId: 'device_001',
+ *   isOpen: true,
+ *   success: () => {
+ *     console.log('updateMeshProxyState success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('updateMeshProxyState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const updateMeshProxyState: typeof ty.device.updateMeshProxyState;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { updateMeshRelayState } = device;
+ *
+ * updateMeshRelayState({
+ *   deviceId: 'device_001',
+ *   isOpen: true,
+ *   success: () => {
+ *     console.log('updateMeshRelayState success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('updateMeshRelayState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const updateMeshRelayState: typeof ty.device.updateMeshRelayState;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { recordBleConnectEvent } = device;
+ *
+ * recordBleConnectEvent({
+ *   deviceId: 'device_001',
+ *   src: 0,
+ *   actId: 'example',
+ *   success: () => {
+ *     console.log('recordBleConnectEvent success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('recordBleConnectEvent fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const recordBleConnectEvent: typeof ty.device.recordBleConnectEvent;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { requestWifiSignal } = device;
+ *
+ * requestWifiSignal({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('requestWifiSignal success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('requestWifiSignal fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const requestWifiSignal: typeof ty.device.requestWifiSignal;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { yuChannelSync } = device;
+ *
+ * yuChannelSync({
+ *   success: () => {
+ *     console.log('yuChannelSync success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('yuChannelSync fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const yuChannelSync: typeof ty.device.yuChannelSync;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { isYuDeviceOnline } = device;
+ *
+ * isYuDeviceOnline({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('isYuDeviceOnline success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('isYuDeviceOnline fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const isYuDeviceOnline: typeof ty.device.isYuDeviceOnline;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { isYuDeviceOnlineSync } = device;
+ *
+ * const result = isYuDeviceOnlineSync();
+ * console.log('isYuDeviceOnlineSync result', result);
+ * ```
  */
 export declare const isYuDeviceOnlineSync: typeof ty.device.isYuDeviceOnlineSync;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { syncDeviceMeshDps } = device;
+ *
+ * syncDeviceMeshDps({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('syncDeviceMeshDps success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('syncDeviceMeshDps fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const syncDeviceMeshDps: typeof ty.device.syncDeviceMeshDps;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getOTAUpdateInfo } = device;
+ *
+ * getOTAUpdateInfo({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getOTAUpdateInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getOTAUpdateInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getOTAUpdateInfo: typeof ty.device.getOTAUpdateInfo;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceDetailConfiguration } = device;
+ *
+ * getDeviceDetailConfiguration({
+ *   success: (result) => {
+ *     console.log('getDeviceDetailConfiguration success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceDetailConfiguration fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceDetailConfiguration: typeof ty.device.getDeviceDetailConfiguration;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { dispatchDataResult } = device;
+ *
+ * dispatchDataResult({
+ *   id: 'example',
+ *   success: () => {
+ *     console.log('dispatchDataResult success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('dispatchDataResult fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const dispatchDataResult: typeof ty.device.dispatchDataResult;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getSubFunctionShowState } = device;
+ *
+ * getSubFunctionShowState({
+ *   ids: ['example'],
+ *   success: (result) => {
+ *     console.log('getSubFunctionShowState success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getSubFunctionShowState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getSubFunctionShowState: typeof ty.device.getSubFunctionShowState;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getSubFunctionExtShowData } = device;
+ *
+ * getSubFunctionExtShowData({
+ *   id: 'example',
+ *   success: (result) => {
+ *     console.log('getSubFunctionExtShowData success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getSubFunctionExtShowData fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getSubFunctionExtShowData: typeof ty.device.getSubFunctionExtShowData;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getRemoteRebootTimers } = device;
+ *
+ * getRemoteRebootTimers({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getRemoteRebootTimers success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getRemoteRebootTimers fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getRemoteRebootTimers: typeof ty.device.getRemoteRebootTimers;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onDispatchEvent } = device;
+ *
+ * onDispatchEvent((res) => {
+ *   console.log('onDispatchEvent', res);
+ * });
+ * ```
  */
 export declare const onDispatchEvent: typeof ty.device.onDispatchEvent;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offDispatchEvent } = device;
+ *
+ * offDispatchEvent((res) => {
+ *   console.log('offDispatchEvent', res);
+ * });
+ * ```
  */
 export declare const offDispatchEvent: typeof ty.device.offDispatchEvent;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { otaStatus } = device;
+ *
+ * otaStatus({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('otaStatus success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('otaStatus fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const otaStatus: typeof ty.device.otaStatus;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { registerOTACompleted } = device;
+ *
+ * registerOTACompleted({
+ *   success: () => {
+ *     console.log('registerOTACompleted success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('registerOTACompleted fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const registerOTACompleted: typeof ty.device.registerOTACompleted;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onOtaCompleted } = device;
+ *
+ * onOtaCompleted((res) => {
+ *   console.log('onOtaCompleted', res);
+ * });
+ * ```
  */
 export declare const onOtaCompleted: typeof ty.device.onOtaCompleted;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { offOtaCompleted } = device;
+ *
+ * offOtaCompleted((res) => {
+ *   console.log('offOtaCompleted', res);
+ * });
+ * ```
  */
 export declare const offOtaCompleted: typeof ty.device.offOtaCompleted;
 /**
  * @public
  * @since @ray-js/ray 1.5.30
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { initVirtualDevice } = device;
+ *
+ * initVirtualDevice({
+ *   pid: 'example',
+ *   success: (result) => {
+ *     console.log('initVirtualDevice success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('initVirtualDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const initVirtualDevice: typeof ty.device.initVirtualDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { startBLECommRodScanDevice } = device;
+ *
+ * startBLECommRodScanDevice({
+ *   success: () => {
+ *     console.log('startBLECommRodScanDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('startBLECommRodScanDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const startBLECommRodScanDevice: typeof ty.device.startBLECommRodScanDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { stopBLECommRodScanDevice } = device;
+ *
+ * stopBLECommRodScanDevice({
+ *   success: () => {
+ *     console.log('stopBLECommRodScanDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('stopBLECommRodScanDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const stopBLECommRodScanDevice: typeof ty.device.stopBLECommRodScanDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { connectBLECommRodDevice } = device;
+ *
+ * connectBLECommRodDevice({
+ *   deviceInfo: { deviceId: 'device_001', name: 'example', uuid: 'example', pid: 'example', mac: 'example', isActive: false },
+ *   machineKey: 'example',
+ *   schema: 'example',
+ *   success: () => {
+ *     console.log('connectBLECommRodDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('connectBLECommRodDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const connectBLECommRodDevice: typeof ty.device.connectBLECommRodDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { disconnectBLECommRodDevice } = device;
+ *
+ * disconnectBLECommRodDevice({
+ *   deviceId: 'device_001',
+ *   name: 'example',
+ *   uuid: 'example',
+ *   pid: 'example',
+ *   mac: 'example',
+ *   isActive: true,
+ *   success: () => {
+ *     console.log('disconnectBLECommRodDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('disconnectBLECommRodDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const disconnectBLECommRodDevice: typeof ty.device.disconnectBLECommRodDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishBLECommRodDps } = device;
+ *
+ * publishBLECommRodDps({
+ *   deviceInfo: { deviceId: 'device_001', name: 'example', uuid: 'example', pid: 'example', mac: 'example', isActive: false },
+ *   dps: {},
+ *   success: () => {
+ *     console.log('publishBLECommRodDps success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishBLECommRodDps fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishBLECommRodDps: typeof ty.device.publishBLECommRodDps;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLECommRodScanDevice } = device;
+ *
+ * onBLECommRodScanDevice((res) => {
+ *   console.log('onBLECommRodScanDevice', res);
+ * });
+ * ```
  */
 export declare const onBLECommRodScanDevice: typeof ty.device.onBLECommRodScanDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLECommRodConnectStatusChange } = device;
+ *
+ * onBLECommRodConnectStatusChange((res) => {
+ *   console.log('onBLECommRodConnectStatusChange', res);
+ * });
+ * ```
  */
 export declare const onBLECommRodConnectStatusChange: typeof ty.device.onBLECommRodConnectStatusChange;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLECommRodSchemaUpload } = device;
+ *
+ * onBLECommRodSchemaUpload((res) => {
+ *   console.log('onBLECommRodSchemaUpload', res);
+ * });
+ * ```
  */
 export declare const onBLECommRodSchemaUpload: typeof ty.device.onBLECommRodSchemaUpload;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onBLECommRodDpsChange } = device;
+ *
+ * onBLECommRodDpsChange((res) => {
+ *   console.log('onBLECommRodDpsChange', res);
+ * });
+ * ```
  */
 export declare const onBLECommRodDpsChange: typeof ty.device.onBLECommRodDpsChange;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { yuChannelSaveState } = device;
+ *
+ * yuChannelSaveState({
+ *   deviceId: 'device_001',
+ *   state: 0,
+ *   success: () => {
+ *     console.log('yuChannelSaveState success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('yuChannelSaveState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const yuChannelSaveState: typeof ty.device.yuChannelSaveState;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { yuChannelSyncSingle } = device;
+ *
+ * yuChannelSyncSingle({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('yuChannelSyncSingle success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('yuChannelSyncSingle fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const yuChannelSyncSingle: typeof ty.device.yuChannelSyncSingle;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { yuChannelSyncSingleSync } = device;
+ *
+ * const result = yuChannelSyncSingleSync();
+ * console.log('yuChannelSyncSingleSync result', result);
+ * ```
  */
 export declare const yuChannelSyncSingleSync: typeof ty.device.yuChannelSyncSingleSync;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { yuChannelQueryNodes } = device;
+ *
+ * yuChannelQueryNodes({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('yuChannelQueryNodes success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('yuChannelQueryNodes fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const yuChannelQueryNodes: typeof ty.device.yuChannelQueryNodes;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { checkCanJoinMatter } = device;
+ *
+ * checkCanJoinMatter({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('checkCanJoinMatter success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('checkCanJoinMatter fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const checkCanJoinMatter: typeof ty.device.checkCanJoinMatter;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { fetchAvailableMatterGatewayList } = device;
+ *
+ * fetchAvailableMatterGatewayList({
+ *   spaceId: 'example',
+ *   success: (result) => {
+ *     console.log('fetchAvailableMatterGatewayList success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('fetchAvailableMatterGatewayList fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const fetchAvailableMatterGatewayList: typeof ty.device.fetchAvailableMatterGatewayList;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { checkShowMatterMutilpleShare } = device;
+ *
+ * checkShowMatterMutilpleShare({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('checkShowMatterMutilpleShare success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('checkShowMatterMutilpleShare fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const checkShowMatterMutilpleShare: typeof ty.device.checkShowMatterMutilpleShare;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { changeDeviceAdvMatterState } = device;
+ *
+ * changeDeviceAdvMatterState({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('changeDeviceAdvMatterState success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('changeDeviceAdvMatterState fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const changeDeviceAdvMatterState: typeof ty.device.changeDeviceAdvMatterState;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { pairDeviceIntoHomeKit } = device;
+ *
+ * pairDeviceIntoHomeKit({
+ *   matterCode: 'example',
+ *   success: () => {
+ *     console.log('pairDeviceIntoHomeKit success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('pairDeviceIntoHomeKit fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const pairDeviceIntoHomeKit: typeof ty.device.pairDeviceIntoHomeKit;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { pairMatterDevice } = device;
+ *
+ * pairMatterDevice({
+ *   matterCode: 'example',
+ *   gwID: 'example',
+ *   spaceID: 'example',
+ *   success: () => {
+ *     console.log('pairMatterDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('pairMatterDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const pairMatterDevice: typeof ty.device.pairMatterDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { cancelMatterActivator } = device;
+ *
+ * cancelMatterActivator({
+ *   success: () => {
+ *     console.log('cancelMatterActivator success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('cancelMatterActivator fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const cancelMatterActivator: typeof ty.device.cancelMatterActivator;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { publishMeshCustomDataEvent } = device;
+ *
+ * publishMeshCustomDataEvent({
+ *   meshId: 'example',
+ *   nodeId: 'example',
+ *   opCode: 0,
+ *   payloadHexString: 'example',
+ *   success: () => {
+ *     console.log('publishMeshCustomDataEvent success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('publishMeshCustomDataEvent fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const publishMeshCustomDataEvent: typeof ty.device.publishMeshCustomDataEvent;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { lowPowerDeviceAwake } = device;
+ *
+ * lowPowerDeviceAwake({
+ *   deviceId: 'device_001',
+ *   timeout: 0,
+ *   success: (result) => {
+ *     console.log('lowPowerDeviceAwake success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('lowPowerDeviceAwake fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const lowPowerDeviceAwake: typeof ty.device.lowPowerDeviceAwake;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceDetailInfo } = device;
+ *
+ * getDeviceDetailInfo({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getDeviceDetailInfo success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceDetailInfo fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceDetailInfo: typeof ty.device.getDeviceDetailInfo;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceDetailCubeConfig } = device;
+ *
+ * getDeviceDetailCubeConfig({
+ *   success: (result) => {
+ *     console.log('getDeviceDetailCubeConfig success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceDetailCubeConfig fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceDetailCubeConfig: typeof ty.device.getDeviceDetailCubeConfig;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { wakeUpDevice } = device;
+ *
+ * wakeUpDevice({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('wakeUpDevice success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('wakeUpDevice fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const wakeUpDevice: typeof ty.device.wakeUpDevice;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { validDeviceOnline } = device;
+ *
+ * validDeviceOnline({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('validDeviceOnline success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('validDeviceOnline fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const validDeviceOnline: typeof ty.device.validDeviceOnline;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { queryGatewayReplacementCapabilityDeviceModel } = device;
+ *
+ * queryGatewayReplacementCapabilityDeviceModel({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('queryGatewayReplacementCapabilityDeviceModel success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('queryGatewayReplacementCapabilityDeviceModel fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const queryGatewayReplacementCapabilityDeviceModel: typeof ty.device.queryGatewayReplacementCapabilityDeviceModel;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { fetchReplaceableSubDevicesDeviceModel } = device;
+ *
+ * fetchReplaceableSubDevicesDeviceModel({
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('fetchReplaceableSubDevicesDeviceModel success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('fetchReplaceableSubDevicesDeviceModel fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const fetchReplaceableSubDevicesDeviceModel: typeof ty.device.fetchReplaceableSubDevicesDeviceModel;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { subDeviceReplace } = device;
+ *
+ * subDeviceReplace({
+ *   defaultSubDeviceId: 'example',
+ *   replaceSubDevId: 'example',
+ *   deleteOriginal: true,
+ *   timeout: 0,
+ *   success: (result) => {
+ *     console.log('subDeviceReplace success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('subDeviceReplace fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const subDeviceReplace: typeof ty.device.subDeviceReplace;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { fetchReplacementOutcomeJobModel } = device;
+ *
+ * fetchReplacementOutcomeJobModel({
+ *   defaultSubDeviceId: 'example',
+ *   jobId: 'example',
+ *   success: (result) => {
+ *     console.log('fetchReplacementOutcomeJobModel success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('fetchReplacementOutcomeJobModel fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const fetchReplacementOutcomeJobModel: typeof ty.device.fetchReplacementOutcomeJobModel;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getMeshDeviceIdHex } = device;
+ *
+ * getMeshDeviceIdHex({
+ *   nodeId: 'example',
+ *   deviceId: 'device_001',
+ *   success: (result) => {
+ *     console.log('getMeshDeviceIdHex success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('getMeshDeviceIdHex fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getMeshDeviceIdHex: typeof ty.device.getMeshDeviceIdHex;
 /**
  * @public
  * @since @ray-js/ray 1.6.8
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { onSubDeviceReplaceResult } = device;
+ *
+ * onSubDeviceReplaceResult((res) => {
+ *   console.log('onSubDeviceReplaceResult', res);
+ * });
+ * ```
  */
 export declare const onSubDeviceReplaceResult: typeof ty.device.onSubDeviceReplaceResult;
 /**
  * @public
  * @since @ray-js/ray 1.7.56
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { aes128EncryptedStringWithPassword } = device;
+ *
+ * aes128EncryptedStringWithPassword({
+ *   deviceId: 'device_001',
+ *   password: 'example',
+ *   success: (result) => {
+ *     console.log('aes128EncryptedStringWithPassword success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('aes128EncryptedStringWithPassword fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const aes128EncryptedStringWithPassword: typeof ty.device.aes128EncryptedStringWithPassword;
 /**
  * @public
  * @since @ray-js/ray 1.7.56
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { aes128DecryptedStringWithPassword } = device;
+ *
+ * aes128DecryptedStringWithPassword({
+ *   deviceId: 'device_001',
+ *   password: 'example',
+ *   success: (result) => {
+ *     console.log('aes128DecryptedStringWithPassword success', result);
+ *   },
+ *   fail: (error) => {
+ *     console.log('aes128DecryptedStringWithPassword fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const aes128DecryptedStringWithPassword: typeof ty.device.aes128DecryptedStringWithPassword;
 /**
  * @public
  * @since @ray-js/ray 1.7.41
+ * @example 基础调用
+ * ```tsx
+ * import { device } from '@ray-js/ray';
+ *
+ * const { getDeviceNetworkManager } = device;
+ *
+ * getDeviceNetworkManager({
+ *   deviceId: 'device_001',
+ *   success: () => {
+ *     console.log('getDeviceNetworkManager success');
+ *   },
+ *   fail: (error) => {
+ *     console.log('getDeviceNetworkManager fail', error.errorMsg);
+ *   },
+ * });
+ * ```
  */
 export declare const getDeviceNetworkManager: typeof ty.device.getDeviceNetworkManager;