@tarojs/taro-h5

  • Version 3.5.6
  • Published
  • 1.66 MB
  • 7 dependencies
  • MIT license

Install

npm i @tarojs/taro-h5
yarn add @tarojs/taro-h5
pnpm add @tarojs/taro-h5

Overview

Taro h5 framework

Index

Variables

Functions

Classes

Namespaces

Variables

variable addInterceptor

const addInterceptor: any;

    variable Behavior

    const Behavior: any;

      variable canvasGetImageData

      const canvasGetImageData: any;
      • 获取 canvas 区域隐含的像素数据。

      variable canvasPutImageData

      const canvasPutImageData: any;
      • 将像素数据绘制到画布。在自定义组件下,第二个参数传入自定义组件实例 this,以操作组件内 组件 暂未支持尺寸相关功能

      variable canvasToTempFilePath

      const canvasToTempFilePath: any;
      • 把当前画布指定区域的内容导出生成指定大小的图片。在 draw() 回调里调用该方法才能保证图片导出成功。 暂未支持尺寸相关功能

      variable chooseImage

      const chooseImage: any;
      • 从本地相册选择图片或使用相机拍照。

      variable chooseLocation

      const chooseLocation: any;
      • 打开地图选择位置。

      variable chooseVideo

      const chooseVideo: any;
      • 拍摄视频或从手机相册中选视频。

      variable clearStorage

      const clearStorage: any;

        variable clearStorageSync

        const clearStorageSync: any;

          variable createAnimation

          const createAnimation: any;

            variable createCanvasContext

            const createCanvasContext: any;
            • 创建 canvas 的绘图上下文 CanvasContext 对象

            variable createInnerAudioContext

            const createInnerAudioContext: any;
            • 创建内部 audio 上下文 InnerAudioContext 对象。

            variable createSelectorQuery

            const createSelectorQuery: any;

              variable createVideoContext

              const createVideoContext: any;
              • 创建 video 上下文 VideoContext 对象。

              variable Current

              const Current: any;

                variable downloadFile

                const downloadFile: any;
                • 下载文件资源到本地。客户端直接发起一个 HTTPS GET 请求,返回文件的本地临时路径。使用前请注意阅读相关说明。 注意:请在服务端响应的 header 中指定合理的 Content-Type 字段,以保证客户端正确处理文件类型。

                variable ENV_TYPE

                const ENV_TYPE: any;

                  variable eventCenter

                  const eventCenter: any;

                    variable Events

                    const Events: any;

                      variable getApp

                      const getApp: any;

                        variable getAppAuthorizeSetting

                        const getAppAuthorizeSetting: any;
                        • 获取微信APP授权设置

                        variable getAppBaseInfo

                        const getAppBaseInfo: any;
                        • 获取微信APP基础信息

                        variable getBatteryInfo

                        const getBatteryInfo: any;

                          variable getClipboardData

                          const getClipboardData: any;
                          • 获取系统剪贴板的内容

                          variable getDeviceInfo

                          const getDeviceInfo: any;
                          • 获取设备设置

                          variable getEnv

                          const getEnv: any;

                            variable getImageInfo

                            const getImageInfo: any;
                            • 获取图片信息。网络图片需先配置download域名才能生效。

                            variable getNetworkType

                            const getNetworkType: any;

                              variable getStorage

                              const getStorage: any;

                                variable getStorageInfo

                                const getStorageInfo: any;

                                  variable getStorageInfoSync

                                  const getStorageInfoSync: any;

                                    variable getStorageSync

                                    const getStorageSync: any;

                                      variable getSystemInfo

                                      const getSystemInfo: any;
                                      • 获取系统信息

                                      variable getSystemInfoAsync

                                      const getSystemInfoAsync: any;
                                      • 获取系统信息

                                      variable getSystemInfoSync

                                      const getSystemInfoSync: any;
                                      • 获取设备设置

                                      variable getSystemSetting

                                      const getSystemSetting: any;
                                      • 获取设备设置

                                      variable getWindowInfo

                                      const getWindowInfo: any;
                                      • 获取窗口信息

                                      variable hideLoading

                                      const hideLoading: any;

                                        variable hideTabBar

                                        const hideTabBar: any;
                                        • 隐藏 tabBar

                                        variable hideTabBarRedDot

                                        const hideTabBarRedDot: any;
                                        • 隐藏 tabBar 某一项的右上角的红点

                                        variable hideToast

                                        const hideToast: any;

                                          variable initPxTransform

                                          const initPxTransform: any;

                                            variable interceptors

                                            const interceptors: any;
                                              const Link: any;

                                                variable loadFontFace

                                                const loadFontFace: any;

                                                  variable makePhoneCall

                                                  const makePhoneCall: any;

                                                    variable offAccelerometerChange

                                                    const offAccelerometerChange: any;
                                                    • 取消监听加速度数据事件,参数为空,则取消所有的事件监听

                                                    variable offAppHide

                                                    const offAppHide: any;

                                                      variable offAppShow

                                                      const offAppShow: any;

                                                        variable offCompassChange

                                                        const offCompassChange: any;
                                                        • 取消监听罗盘数据变化事件,参数为空,则取消所有的事件监听。

                                                        variable offDeviceMotionChange

                                                        const offDeviceMotionChange: any;
                                                        • 取消监听设备方向变化事件,参数为空,则取消所有的事件监听。

                                                        variable offNetworkStatusChange

                                                        const offNetworkStatusChange: any;

                                                          variable offWindowResize

                                                          const offWindowResize: any;
                                                          • 取消监听窗口尺寸变化事件

                                                          variable onAccelerometerChange

                                                          const onAccelerometerChange: any;
                                                          • 监听加速度数据事件。频率根据 Taro.startAccelerometer() 的 interval 参数。可使用 Taro.stopAccelerometer() 停止监听。

                                                          variable onAppHide

                                                          const onAppHide: any;

                                                            variable onAppShow

                                                            const onAppShow: any;

                                                              variable onCompassChange

                                                              const onCompassChange: any;
                                                              • 监听罗盘数据变化事件。频率:5 次/秒,接口调用后会自动开始监听,可使用 wx.stopCompass 停止监听。

                                                              variable onDeviceMotionChange

                                                              const onDeviceMotionChange: any;
                                                              • 监听设备方向变化事件。

                                                              variable onNetworkStatusChange

                                                              const onNetworkStatusChange: any;

                                                                variable onWindowResize

                                                                const onWindowResize: any;
                                                                • 监听窗口尺寸变化事件

                                                                variable options

                                                                const options: any;

                                                                  variable pageScrollTo

                                                                  const pageScrollTo: any;
                                                                  • 将页面滚动到目标位置

                                                                  variable preload

                                                                  const preload: any;

                                                                    variable previewImage

                                                                    const previewImage: any;
                                                                    • 在新页面中全屏预览图片。预览的过程中用户可以进行保存图片、发送给朋友等操作。

                                                                    variable removeStorage

                                                                    const removeStorage: any;

                                                                      variable removeStorageSync

                                                                      const removeStorageSync: any;

                                                                        variable removeTabBarBadge

                                                                        const removeTabBarBadge: any;
                                                                        • 移除 tabBar 某一项右上角的文本

                                                                        variable request

                                                                        const request: any;

                                                                          variable setClipboardData

                                                                          const setClipboardData: any;
                                                                          • 设置系统剪贴板的内容

                                                                          variable setNavigationBarColor

                                                                          const setNavigationBarColor: any;
                                                                          • 设置页面导航条颜色

                                                                          variable setStorage

                                                                          const setStorage: any;

                                                                            variable setStorageSync

                                                                            const setStorageSync: any;

                                                                              variable setTabBarBadge

                                                                              const setTabBarBadge: any;
                                                                              • 为 tabBar 某一项的右上角添加文本

                                                                              variable setTabBarItem

                                                                              const setTabBarItem: any;
                                                                              • 动态设置 tabBar 某一项的内容

                                                                              variable setTabBarStyle

                                                                              const setTabBarStyle: any;
                                                                              • 动态设置 tabBar 的整体样式

                                                                              variable showActionSheet

                                                                              const showActionSheet: any;

                                                                                variable showLoading

                                                                                const showLoading: any;

                                                                                  variable showModal

                                                                                  const showModal: any;

                                                                                    variable showTabBar

                                                                                    const showTabBar: any;
                                                                                    • 显示 tabBar

                                                                                    variable showTabBarRedDot

                                                                                    const showTabBarRedDot: any;
                                                                                    • 显示 tabBar 某一项的右上角的红点

                                                                                    variable showToast

                                                                                    const showToast: any;

                                                                                      variable startAccelerometer

                                                                                      const startAccelerometer: any;
                                                                                      • 开始监听加速度数据。

                                                                                      variable startCompass

                                                                                      const startCompass: any;
                                                                                      • 开始监听罗盘数据

                                                                                      variable startDeviceMotionListening

                                                                                      const startDeviceMotionListening: any;
                                                                                      • 开始监听设备方向的变化。

                                                                                      variable startPullDownRefresh

                                                                                      const startPullDownRefresh: any;
                                                                                      • 开始下拉刷新。调用后触发下拉刷新动画,效果与用户手动下拉刷新一致。

                                                                                      variable stopAccelerometer

                                                                                      const stopAccelerometer: any;
                                                                                      • 停止监听加速度数据。

                                                                                      variable stopCompass

                                                                                      const stopCompass: any;
                                                                                      • 停止监听罗盘数据

                                                                                      variable stopDeviceMotionListening

                                                                                      const stopDeviceMotionListening: any;
                                                                                      • 停止监听设备方向的变化。

                                                                                      variable stopPullDownRefresh

                                                                                      const stopPullDownRefresh: any;
                                                                                      • 停止当前页面下拉刷新。

                                                                                      variable taro

                                                                                      const taro: any;

                                                                                        variable uploadFile

                                                                                        const uploadFile: any;
                                                                                        • 将本地资源上传到服务器。客户端发起一个 HTTPS POST 请求,其中 content-type 为 multipart/form-data。使用前请注意阅读相关说明。

                                                                                        variable vibrateLong

                                                                                        const vibrateLong: any;
                                                                                        • 使手机发生较长时间的振动(400 ms)

                                                                                        variable vibrateShort

                                                                                        const vibrateShort: any;
                                                                                        • 使手机发生较短时间的振动(15 ms)。仅在 iPhone 7 / 7 Plus 以上及 Android 机型生效

                                                                                        Functions

                                                                                        function addCard

                                                                                        addCard: () => Promise<{ errMsg: string }>;

                                                                                          function addFileToFavorites

                                                                                          addFileToFavorites: () => Promise<{ errMsg: string }>;

                                                                                            function addPhoneCalendar

                                                                                            addPhoneCalendar: () => Promise<{ errMsg: string }>;

                                                                                              function addPhoneContact

                                                                                              addPhoneContact: () => Promise<{ errMsg: string }>;

                                                                                                function addPhoneRepeatCalendar

                                                                                                addPhoneRepeatCalendar: () => Promise<{ errMsg: string }>;

                                                                                                  function addVideoToFavorites

                                                                                                  addVideoToFavorites: () => Promise<{ errMsg: string }>;

                                                                                                    function advancedGeneralIdentify

                                                                                                    advancedGeneralIdentify: () => Promise<{ errMsg: string }>;

                                                                                                      function animalClassify

                                                                                                      animalClassify: () => Promise<{ errMsg: string }>;

                                                                                                        function arrayBufferToBase64

                                                                                                        arrayBufferToBase64: (arrayBuffer: any) => string;

                                                                                                          function authorize

                                                                                                          authorize: () => Promise<{ errMsg: string }>;

                                                                                                            function authorizeForMiniProgram

                                                                                                            authorizeForMiniProgram: () => Promise<{ errMsg: string }>;

                                                                                                              function authPrivateMessage

                                                                                                              authPrivateMessage: () => Promise<{ errMsg: string }>;

                                                                                                                function base64ToArrayBuffer

                                                                                                                base64ToArrayBuffer: (base64: any) => Uint8Array;

                                                                                                                  function canIUse

                                                                                                                  canIUse: () => Promise<{ errMsg: string }>;

                                                                                                                    function canIUseWebp

                                                                                                                    canIUseWebp: () => boolean;

                                                                                                                      function carClassify

                                                                                                                      carClassify: () => Promise<{ errMsg: string }>;

                                                                                                                        function checkIsOpenAccessibility

                                                                                                                        checkIsOpenAccessibility: () => Promise<{ errMsg: string }>;

                                                                                                                          function checkIsSoterEnrolledInDevice

                                                                                                                          checkIsSoterEnrolledInDevice: () => Promise<{ errMsg: string }>;

                                                                                                                            function checkIsSupportFacialRecognition

                                                                                                                            checkIsSupportFacialRecognition: () => Promise<{ errMsg: string }>;

                                                                                                                              function checkIsSupportSoterAuthentication

                                                                                                                              checkIsSupportSoterAuthentication: () => Promise<{ errMsg: string }>;

                                                                                                                                function checkSession

                                                                                                                                checkSession: () => Promise<{ errMsg: string }>;

                                                                                                                                  function chooseAddress

                                                                                                                                  chooseAddress: () => Promise<{ errMsg: string }>;

                                                                                                                                    function chooseContact

                                                                                                                                    chooseContact: () => Promise<{ errMsg: string }>;

                                                                                                                                      function chooseInvoice

                                                                                                                                      chooseInvoice: () => Promise<{ errMsg: string }>;

                                                                                                                                        function chooseInvoiceTitle

                                                                                                                                        chooseInvoiceTitle: () => Promise<{ errMsg: string }>;

                                                                                                                                          function chooseLicensePlate

                                                                                                                                          chooseLicensePlate: () => Promise<{ errMsg: string }>;

                                                                                                                                            function chooseMedia

                                                                                                                                            chooseMedia: () => Promise<{ errMsg: string }>;

                                                                                                                                              function chooseMessageFile

                                                                                                                                              chooseMessageFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                function choosePoi

                                                                                                                                                choosePoi: () => Promise<{ errMsg: string }>;

                                                                                                                                                  function closeBLEConnection

                                                                                                                                                  closeBLEConnection: () => Promise<{ errMsg: string }>;

                                                                                                                                                    function closeBluetoothAdapter

                                                                                                                                                    closeBluetoothAdapter: () => Promise<{ errMsg: string }>;

                                                                                                                                                      function closeSocket

                                                                                                                                                      closeSocket: () => void;

                                                                                                                                                        function compressImage

                                                                                                                                                        compressImage: () => Promise<{ errMsg: string }>;

                                                                                                                                                          function compressVideo

                                                                                                                                                          compressVideo: () => Promise<{ errMsg: string }>;

                                                                                                                                                            function connectSocket

                                                                                                                                                            connectSocket: (options: any) => Promise<unknown>;

                                                                                                                                                              function connectWifi

                                                                                                                                                              connectWifi: () => Promise<{ errMsg: string }>;

                                                                                                                                                                function createAudioContext

                                                                                                                                                                createAudioContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                  function createBLEConnection

                                                                                                                                                                  createBLEConnection: () => Promise<{ errMsg: string }>;

                                                                                                                                                                    function createBLEPeripheralServer

                                                                                                                                                                    createBLEPeripheralServer: () => Promise<{ errMsg: string }>;

                                                                                                                                                                      function createBufferURL

                                                                                                                                                                      createBufferURL: () => Promise<{ errMsg: string }>;

                                                                                                                                                                        function createCameraContext

                                                                                                                                                                        createCameraContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                          function createIntersectionObserver

                                                                                                                                                                          createIntersectionObserver: () => Promise<{ errMsg: string }>;

                                                                                                                                                                            function createInterstitialAd

                                                                                                                                                                            createInterstitialAd: () => Promise<{ errMsg: string }>;

                                                                                                                                                                              function createLivePlayerContext

                                                                                                                                                                              createLivePlayerContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                function createLivePusherContext

                                                                                                                                                                                createLivePusherContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                  function createMapContext

                                                                                                                                                                                  createMapContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                    function createMediaAudioPlayer

                                                                                                                                                                                    createMediaAudioPlayer: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                      function createMediaContainer

                                                                                                                                                                                      createMediaContainer: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                        function createMediaRecorder

                                                                                                                                                                                        createMediaRecorder: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                          function createOffscreenCanvas

                                                                                                                                                                                          createOffscreenCanvas: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                          • 创建离屏 canvas 实例

                                                                                                                                                                                          function createRewardedVideoAd

                                                                                                                                                                                          createRewardedVideoAd: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                            function createTCPSocket

                                                                                                                                                                                            createTCPSocket: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                              function createUDPSocket

                                                                                                                                                                                              createUDPSocket: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                function createVideoDecoder

                                                                                                                                                                                                createVideoDecoder: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                  function createVKSession

                                                                                                                                                                                                  createVKSession: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                    function createWebAudioContext

                                                                                                                                                                                                    createWebAudioContext: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                      function createWorker

                                                                                                                                                                                                      createWorker: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                        function disableAlertBeforeUnload

                                                                                                                                                                                                        disableAlertBeforeUnload: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                          function dishClassify

                                                                                                                                                                                                          dishClassify: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                            function enableAlertBeforeUnload

                                                                                                                                                                                                            enableAlertBeforeUnload: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                              function exitMiniProgram

                                                                                                                                                                                                              exitMiniProgram: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                function exitVoIPChat

                                                                                                                                                                                                                exitVoIPChat: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                  function faceDetect

                                                                                                                                                                                                                  faceDetect: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                    function faceVerifyForPay

                                                                                                                                                                                                                    faceVerifyForPay: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                      function getAccountInfoSync

                                                                                                                                                                                                                      getAccountInfoSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                        function getAvailableAudioSources

                                                                                                                                                                                                                        getAvailableAudioSources: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                          function getBackgroundAudioManager

                                                                                                                                                                                                                          getBackgroundAudioManager: () => BackgroundAudioManager;
                                                                                                                                                                                                                          • 获取全局唯一的背景音频管理器

                                                                                                                                                                                                                          function getBackgroundAudioPlayerState

                                                                                                                                                                                                                          getBackgroundAudioPlayerState: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                            function getBackgroundFetchData

                                                                                                                                                                                                                            getBackgroundFetchData: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                              function getBackgroundFetchToken

                                                                                                                                                                                                                              getBackgroundFetchToken: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                function getBatteryInfoSync

                                                                                                                                                                                                                                getBatteryInfoSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                  function getBeacons

                                                                                                                                                                                                                                  getBeacons: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                    function getBLEDeviceCharacteristics

                                                                                                                                                                                                                                    getBLEDeviceCharacteristics: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                      function getBLEDeviceRSSI

                                                                                                                                                                                                                                      getBLEDeviceRSSI: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                        function getBLEDeviceServices

                                                                                                                                                                                                                                        getBLEDeviceServices: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                          function getBLEMTU

                                                                                                                                                                                                                                          getBLEMTU: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                            function getBluetoothAdapterState

                                                                                                                                                                                                                                            getBluetoothAdapterState: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                              function getBluetoothDevices

                                                                                                                                                                                                                                              getBluetoothDevices: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                function getChannelsLiveInfo

                                                                                                                                                                                                                                                getChannelsLiveInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                  function getChannelsLiveNoticeInfo

                                                                                                                                                                                                                                                  getChannelsLiveNoticeInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                    function getConnectedBluetoothDevices

                                                                                                                                                                                                                                                    getConnectedBluetoothDevices: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                      function getConnectedWifi

                                                                                                                                                                                                                                                      getConnectedWifi: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                        function getCurrentInstance

                                                                                                                                                                                                                                                        getCurrentInstance: () => Taro.Current;

                                                                                                                                                                                                                                                          function getEnterOptionsSync

                                                                                                                                                                                                                                                          getEnterOptionsSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                            function getExptInfoSync

                                                                                                                                                                                                                                                            getExptInfoSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                              function getExtConfig

                                                                                                                                                                                                                                                              getExtConfig: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                function getExtConfigSync

                                                                                                                                                                                                                                                                getExtConfigSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                  function getFileInfo

                                                                                                                                                                                                                                                                  getFileInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                    function getFileSystemManager

                                                                                                                                                                                                                                                                    getFileSystemManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                      function getFuzzyLocation

                                                                                                                                                                                                                                                                      getFuzzyLocation: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                        function getGroupEnterInfo

                                                                                                                                                                                                                                                                        getGroupEnterInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                          function getHCEState

                                                                                                                                                                                                                                                                          getHCEState: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                            function getLaunchOptionsSync

                                                                                                                                                                                                                                                                            getLaunchOptionsSync: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                              function getLocalIPAddress

                                                                                                                                                                                                                                                                              getLocalIPAddress: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                function getLocation

                                                                                                                                                                                                                                                                                getLocation: (
                                                                                                                                                                                                                                                                                options?: Taro.getLocation.Option
                                                                                                                                                                                                                                                                                ) => Promise<Taro.getLocation.SuccessCallbackResult>;

                                                                                                                                                                                                                                                                                  function getLogManager

                                                                                                                                                                                                                                                                                  getLogManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                    function getMenuButtonBoundingClientRect

                                                                                                                                                                                                                                                                                    getMenuButtonBoundingClientRect: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                      function getNFCAdapter

                                                                                                                                                                                                                                                                                      getNFCAdapter: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                        function getOpenUserInfo

                                                                                                                                                                                                                                                                                        getOpenUserInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                          function getPerformance

                                                                                                                                                                                                                                                                                          getPerformance: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                            function getRandomValues

                                                                                                                                                                                                                                                                                            getRandomValues: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                              function getRealtimeLogManager

                                                                                                                                                                                                                                                                                              getRealtimeLogManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                function getRecorderManager

                                                                                                                                                                                                                                                                                                getRecorderManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                  function getSavedFileInfo

                                                                                                                                                                                                                                                                                                  getSavedFileInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                    function getSavedFileList

                                                                                                                                                                                                                                                                                                    getSavedFileList: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                      function getScreenBrightness

                                                                                                                                                                                                                                                                                                      getScreenBrightness: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                        function getSelectedTextRange

                                                                                                                                                                                                                                                                                                        getSelectedTextRange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                          function getSetting

                                                                                                                                                                                                                                                                                                          getSetting: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                            function getShareInfo

                                                                                                                                                                                                                                                                                                            getShareInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                              function getSwanId

                                                                                                                                                                                                                                                                                                              getSwanId: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                function getUpdateManager

                                                                                                                                                                                                                                                                                                                getUpdateManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                  function getUserCryptoManager

                                                                                                                                                                                                                                                                                                                  getUserCryptoManager: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                    function getUserInfo

                                                                                                                                                                                                                                                                                                                    getUserInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                      function getUserProfile

                                                                                                                                                                                                                                                                                                                      getUserProfile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                        function getVideoInfo

                                                                                                                                                                                                                                                                                                                        getVideoInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                          function getWeRunData

                                                                                                                                                                                                                                                                                                                          getWeRunData: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                            function getWifiList

                                                                                                                                                                                                                                                                                                                            getWifiList: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                              function hideHomeButton

                                                                                                                                                                                                                                                                                                                              hideHomeButton: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                function hideKeyboard

                                                                                                                                                                                                                                                                                                                                hideKeyboard: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                  function hideNavigationBarLoading

                                                                                                                                                                                                                                                                                                                                  hideNavigationBarLoading: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                    function hideShareMenu

                                                                                                                                                                                                                                                                                                                                    hideShareMenu: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                      function imageAudit

                                                                                                                                                                                                                                                                                                                                      imageAudit: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                        function initFaceDetect

                                                                                                                                                                                                                                                                                                                                        initFaceDetect: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                          function initTabBarApis

                                                                                                                                                                                                                                                                                                                                          initTabBarApis: (config?: AppConfig) => void;

                                                                                                                                                                                                                                                                                                                                            function isBluetoothDevicePaired

                                                                                                                                                                                                                                                                                                                                            isBluetoothDevicePaired: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                              function isVKSupport

                                                                                                                                                                                                                                                                                                                                              isVKSupport: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                function joinVoIPChat

                                                                                                                                                                                                                                                                                                                                                joinVoIPChat: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                  function login

                                                                                                                                                                                                                                                                                                                                                  login: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                    function logoClassify

                                                                                                                                                                                                                                                                                                                                                    logoClassify: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                      function makeBluetoothPair

                                                                                                                                                                                                                                                                                                                                                      makeBluetoothPair: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                        navigateBackMiniProgram: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                          navigateBackSmartProgram: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                            navigateToMiniProgram: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                              navigateToSmartGameProgram: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                                navigateToSmartProgram: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                  function nextTick

                                                                                                                                                                                                                                                                                                                                                                  nextTick: (callback: (...args: any[]) => any) => void;

                                                                                                                                                                                                                                                                                                                                                                    function notifyBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                    notifyBLECharacteristicValueChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                      function objectDetectIdentify

                                                                                                                                                                                                                                                                                                                                                                      objectDetectIdentify: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                        function ocrBankCard

                                                                                                                                                                                                                                                                                                                                                                        ocrBankCard: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                          function ocrDrivingLicense

                                                                                                                                                                                                                                                                                                                                                                          ocrDrivingLicense: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                            function ocrIdCard

                                                                                                                                                                                                                                                                                                                                                                            ocrIdCard: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                              function ocrVehicleLicense

                                                                                                                                                                                                                                                                                                                                                                              ocrVehicleLicense: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                function offAudioInterruptionBegin

                                                                                                                                                                                                                                                                                                                                                                                offAudioInterruptionBegin: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                  function offAudioInterruptionEnd

                                                                                                                                                                                                                                                                                                                                                                                  offAudioInterruptionEnd: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                    function offBeaconServiceChange

                                                                                                                                                                                                                                                                                                                                                                                    offBeaconServiceChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                      function offBeaconUpdate

                                                                                                                                                                                                                                                                                                                                                                                      offBeaconUpdate: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                        function offBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                                        offBLECharacteristicValueChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                          function offBLEConnectionStateChange

                                                                                                                                                                                                                                                                                                                                                                                          offBLEConnectionStateChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                            function offBLEMTUChange

                                                                                                                                                                                                                                                                                                                                                                                            offBLEMTUChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                              function offBLEPeripheralConnectionStateChanged

                                                                                                                                                                                                                                                                                                                                                                                              offBLEPeripheralConnectionStateChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                function offBluetoothAdapterStateChange

                                                                                                                                                                                                                                                                                                                                                                                                offBluetoothAdapterStateChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                  function offBluetoothDeviceFound

                                                                                                                                                                                                                                                                                                                                                                                                  offBluetoothDeviceFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                    function offCopyUrl

                                                                                                                                                                                                                                                                                                                                                                                                    offCopyUrl: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                      function offError

                                                                                                                                                                                                                                                                                                                                                                                                      offError: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                        function offGetWifiList

                                                                                                                                                                                                                                                                                                                                                                                                        offGetWifiList: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                          function offGyroscopeChange

                                                                                                                                                                                                                                                                                                                                                                                                          offGyroscopeChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                            function offHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                            offHCEMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                              function offKeyboardHeightChange

                                                                                                                                                                                                                                                                                                                                                                                                              offKeyboardHeightChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                function offLocalServiceDiscoveryStop

                                                                                                                                                                                                                                                                                                                                                                                                                offLocalServiceDiscoveryStop: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                  function offLocalServiceFound

                                                                                                                                                                                                                                                                                                                                                                                                                  offLocalServiceFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                    function offLocalServiceLost

                                                                                                                                                                                                                                                                                                                                                                                                                    offLocalServiceLost: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                      function offLocalServiceResolveFail

                                                                                                                                                                                                                                                                                                                                                                                                                      offLocalServiceResolveFail: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                        function offLocationChange

                                                                                                                                                                                                                                                                                                                                                                                                                        offLocationChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                          function offLocationChangeError

                                                                                                                                                                                                                                                                                                                                                                                                                          offLocationChangeError: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                            function offMemoryWarning

                                                                                                                                                                                                                                                                                                                                                                                                                            offMemoryWarning: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                              function offNetworkWeakChange

                                                                                                                                                                                                                                                                                                                                                                                                                              offNetworkWeakChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                function offPageNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                offPageNotFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function offThemeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                  offThemeChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function offUnhandledRejection

                                                                                                                                                                                                                                                                                                                                                                                                                                    offUnhandledRejection: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function offUserCaptureScreen

                                                                                                                                                                                                                                                                                                                                                                                                                                      offUserCaptureScreen: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function offVoIPChatInterrupted

                                                                                                                                                                                                                                                                                                                                                                                                                                        offVoIPChatInterrupted: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function offVoIPChatMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                          offVoIPChatMembersChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function offVoIPChatStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                            offVoIPChatStateChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function offVoIPVideoMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                              offVoIPVideoMembersChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function offWifiConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                offWifiConnected: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onAudioInterruptionBegin

                                                                                                                                                                                                                                                                                                                                                                                                                                                  onAudioInterruptionBegin: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onAudioInterruptionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                    onAudioInterruptionEnd: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onBackgroundAudioPause

                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBackgroundAudioPause: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onBackgroundAudioPlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                        onBackgroundAudioPlay: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onBackgroundAudioStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBackgroundAudioStop: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onBackgroundFetchData

                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBackgroundFetchData: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onBeaconServiceChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                              onBeaconServiceChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onBeaconUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                onBeaconUpdate: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onBLECharacteristicValueChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onBLEConnectionStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onBLEConnectionStateChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onBLEMTUChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBLEMTUChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onBLEPeripheralConnectionStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onBLEPeripheralConnectionStateChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onBluetoothAdapterStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBluetoothAdapterStateChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onBluetoothDeviceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBluetoothDeviceFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onCopyUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCopyUrl: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onError: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onGetWifiList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onGetWifiList: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onGyroscopeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onGyroscopeChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onHCEMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onKeyboardHeightChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onKeyboardHeightChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onLocalServiceDiscoveryStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onLocalServiceDiscoveryStop: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onLocalServiceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onLocalServiceFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onLocalServiceLost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onLocalServiceLost: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onLocalServiceResolveFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onLocalServiceResolveFail: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onLocationChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onLocationChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onLocationChangeError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onLocationChangeError: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onMemoryWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMemoryWarning: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onNetworkWeakChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onNetworkWeakChange: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 在最近的八次网络请求中, 出现下列三个现象之一则判定弱网。 - 出现三次以上连接超时 - 出现三次 rtt 超过 400 - 出现三次以上的丢包 > 弱网事件通知规则是: 弱网状态变化时立即通知, 状态不变时 30s 内最多通知一次。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onPageNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onPageNotFound: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onSocketClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onSocketClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onSocketError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onSocketError: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onSocketMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onSocketMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onSocketOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onSocketOpen: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onThemeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onThemeChange: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onUnhandledRejection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onUnhandledRejection: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onUserCaptureScreen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onUserCaptureScreen: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onVoIPChatInterrupted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onVoIPChatInterrupted: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onVoIPChatMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onVoIPChatMembersChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onVoIPChatSpeakersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onVoIPChatSpeakersChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onVoIPChatStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onVoIPChatStateChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onVoIPVideoMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onVoIPVideoMembersChanged: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onWifiConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onWifiConnected: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onWifiConnectedWithPartialInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onWifiConnectedWithPartialInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openAppAuthorizeSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openAppAuthorizeSetting: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 跳转系统微信授权管理页

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openBluetoothAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openBluetoothAdapter: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function openBusinessView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openBusinessView: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function openCard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          openCard: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function openChannelsActivity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openChannelsActivity: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function openChannelsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openChannelsEvent: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function openChannelsLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openChannelsLive: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function openCustomerServiceChat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  openCustomerServiceChat: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    openDocument: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openEmbeddedMiniProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openEmbeddedMiniProgram: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function openLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openLocation: (options?: Partial<{ scale: number }>) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function openSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          openSetting: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function openSystemBluetoothSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openSystemBluetoothSetting: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 跳转系统蓝牙设置页

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function openVideoEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openVideoEditor: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function pauseBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pauseBackgroundAudio: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function pauseVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pauseVoice: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function plantClassify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  plantClassify: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function playBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    playBackgroundAudio: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function playVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      playVoice: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function pluginLogin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pluginLogin: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function preloadSubPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          preloadSubPackage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function previewMedia

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            previewMedia: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function pxTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pxTransform: (size: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function readBLECharacteristicValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readBLECharacteristicValue: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function removeSavedFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  removeSavedFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function reportAnalytics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reportAnalytics: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function reportEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reportEvent: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function reportMonitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reportMonitor: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function reportPerformance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reportPerformance: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function requestOrderPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestOrderPayment: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function requestPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestPayment: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function requestPolymerPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestPolymerPayment: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function requestSubscribeMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestSubscribeMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function requirePlugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requirePlugin: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function reserveChannelsLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reserveChannelsLive: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function revokeBufferURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        revokeBufferURL: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function saveFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          saveFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function saveFileToDisk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            saveFileToDisk: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function saveImageToPhotosAlbum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              saveImageToPhotosAlbum: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function saveVideoToPhotosAlbum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                saveVideoToPhotosAlbum: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function scanCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scanCode: (options?: Partial<{ needResult: number }>) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function seekBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    seekBackgroundAudio: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function sendHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sendHCEMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function sendSocketMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sendSocketMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function setBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setBackgroundColor: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function setBackgroundFetchToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setBackgroundFetchToken: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setBackgroundTextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setBackgroundTextStyle: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setBLEMTU

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setBLEMTU: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setEnable1v1Chat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setEnable1v1Chat: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function setEnableDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setEnableDebug: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function setInnerAudioOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setInnerAudioOption: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function setKeepScreenOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setKeepScreenOn: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function setNavigationBarTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setNavigationBarTitle: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function setPageInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setPageInfo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setScreenBrightness

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setScreenBrightness: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setTopBarText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setTopBarText: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setVisualEffectOnCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setVisualEffectOnCapture: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function setWifiList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setWifiList: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function setWindowSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setWindowSize: () => Promise<{ errMsg: string }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 设置窗口大小,该接口仅适用于 PC 平台,使用细则请参见指南

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function shareFileMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shareFileMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function shareToWeRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        shareToWeRun: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function shareVideoMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shareVideoMessage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function showNavigationBarLoading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showNavigationBarLoading: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function showRedPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showRedPackage: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function showShareImageMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showShareImageMenu: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function showShareMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  showShareMenu: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function startBeaconDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startBeaconDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function startBluetoothDevicesDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startBluetoothDevicesDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function startFacialRecognitionVerify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        startFacialRecognitionVerify: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function startFacialRecognitionVerifyAndUploadVideo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          startFacialRecognitionVerifyAndUploadVideo: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function startGyroscope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startGyroscope: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function startHCE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startHCE: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function startLocalServiceDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                startLocalServiceDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function startLocationUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startLocationUpdate: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function startLocationUpdateBackground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startLocationUpdateBackground: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function startRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startRecord: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function startSoterAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        startSoterAuthentication: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function startWifi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          startWifi: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function stopBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stopBackgroundAudio: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function stopBeaconDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stopBeaconDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function stopBluetoothDevicesDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stopBluetoothDevicesDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function stopFaceDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stopFaceDetect: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function stopGyroscope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stopGyroscope: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function stopHCE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stopHCE: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function stopLocalServiceDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stopLocalServiceDiscovery: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function stopLocationUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopLocationUpdate: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function stopRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stopRecord: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function stopVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stopVoice: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function stopWifi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stopWifi: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function subscribeVoIPVideoMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subscribeVoIPVideoMembers: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function textReview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    textReview: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function textToAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      textToAudio: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function updateShareMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateShareMenu: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function updateVoIPChatMuteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateVoIPChatMuteConfig: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function updateWeChatApp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            updateWeChatApp: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function writeBLECharacteristicValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writeBLECharacteristicValue: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class cloud

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class cloud implements Taro.cloud {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property callContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callContainer: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property callFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callFunction: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Cloud

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Cloud: new (options: Taro.cloud.IOptions) => Taro.Cloud;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property CloudID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CloudID: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property database

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          database: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deleteFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deleteFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property downloadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              downloadFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getTempFileURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getTempFileURL: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  init: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property uploadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uploadFile: () => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace @tarojs/api

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module '@tarojs/api' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (111)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (7)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@tarojs/taro-h5.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@tarojs/taro-h5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@tarojs/taro-h5"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>