Logo for jsDocs.io

@tarojs/taro-h5

  • Version 4.1.9
  • Published
  • 1.77 MB
  • 15 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 addPhoneCalendar

    const addPhoneCalendar: any;

      variable addPhoneRepeatCalendar

      const addPhoneRepeatCalendar: 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;

          • 从本地相册选择图片或使用相机拍照。

            Deprecated

            请使用 chooseMedia 接口

          variable chooseLocation

          const chooseLocation: any;

          • 打开地图选择位置。

          variable chooseVideo

          const chooseVideo: any;

          • 拍摄视频或从手机相册中选视频。

            Deprecated

            请使用 chooseMedia 接口

          variable cleanInterceptors

          const cleanInterceptors: 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 createIntersectionObserver

                  const createIntersectionObserver: any;

                    variable createMediaQueryObserver

                    const createMediaQueryObserver: any;

                      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

                          const env: {
                              FRAMEWORK: string | undefined;
                              TARO_ENV: string | undefined;
                              TARO_PLATFORM: string | undefined;
                              TARO_VERSION: string | undefined;
                          };

                            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 getEnterOptionsSync

                                      const getEnterOptionsSync: any;

                                        variable getEnv

                                        const getEnv: any;

                                          variable getImageInfo

                                          const getImageInfo: any;

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

                                          variable getLaunchOptionsSync

                                          const getLaunchOptionsSync: any;

                                            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 getVideoInfo

                                                      const getVideoInfo: 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 interceptorify

                                                            const interceptorify: 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 offError

                                                                          const offError: any;

                                                                            variable offNetworkStatusChange

                                                                            const offNetworkStatusChange: any;

                                                                              variable offPageNotFound

                                                                              const offPageNotFound: any;

                                                                                variable offThemeChange

                                                                                const offThemeChange: any;

                                                                                  variable offUnhandledRejection

                                                                                  const offUnhandledRejection: 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 onError

                                                                                        const onError: any;

                                                                                          variable onNetworkStatusChange

                                                                                          const onNetworkStatusChange: any;

                                                                                            variable onPageNotFound

                                                                                            const onPageNotFound: any;

                                                                                              variable onThemeChange

                                                                                              const onThemeChange: any;

                                                                                                variable onUnhandledRejection

                                                                                                const onUnhandledRejection: 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 previewMedia

                                                                                                      const previewMedia: any;

                                                                                                        variable removeStorage

                                                                                                        const removeStorage: any;

                                                                                                          variable removeStorageSync

                                                                                                          const removeStorageSync: any;

                                                                                                            variable removeTabBarBadge

                                                                                                            const removeTabBarBadge: any;

                                                                                                            • 移除 tabBar 某一项右上角的文本

                                                                                                            variable router

                                                                                                            const router: {
                                                                                                                addRouteBuilder: (
                                                                                                                    option?: {},
                                                                                                                    ...args: any[]
                                                                                                                ) => Promise<
                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                        Record<string, unknown> &
                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                >;
                                                                                                                getRouteContext: (
                                                                                                                    option?: {},
                                                                                                                    ...args: any[]
                                                                                                                ) => Promise<
                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                        Record<string, unknown> &
                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                >;
                                                                                                                removeRouteBuilder: (
                                                                                                                    option?: {},
                                                                                                                    ...args: any[]
                                                                                                                ) => Promise<
                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                        Record<string, unknown> &
                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                >;
                                                                                                            };

                                                                                                              variable saveImageToPhotosAlbum

                                                                                                              const saveImageToPhotosAlbum: any;

                                                                                                                variable saveVideoToPhotosAlbum

                                                                                                                const saveVideoToPhotosAlbum: 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 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: ModifiedTaro;

                                                                                                                              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 机型生效

                                                                                                                              variable worklet

                                                                                                                              const worklet: any;

                                                                                                                                Functions

                                                                                                                                function addCard

                                                                                                                                addCard: (
                                                                                                                                    option?: {},
                                                                                                                                    ...args: any[]
                                                                                                                                ) => Promise<
                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                        Record<string, unknown> &
                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                >;

                                                                                                                                  function addFileToFavorites

                                                                                                                                  addFileToFavorites: (
                                                                                                                                      option?: {},
                                                                                                                                      ...args: any[]
                                                                                                                                  ) => Promise<
                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                          Record<string, unknown> &
                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                  >;

                                                                                                                                    function addPhoneContact

                                                                                                                                    addPhoneContact: (
                                                                                                                                        option?: {},
                                                                                                                                        ...args: any[]
                                                                                                                                    ) => Promise<
                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                            Record<string, unknown> &
                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                    >;

                                                                                                                                      function addRecentColorSign

                                                                                                                                      addRecentColorSign: (
                                                                                                                                          option?: {},
                                                                                                                                          ...args: any[]
                                                                                                                                      ) => Promise<
                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                              Record<string, unknown> &
                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                      >;

                                                                                                                                        function addVideoToFavorites

                                                                                                                                        addVideoToFavorites: (
                                                                                                                                            option?: {},
                                                                                                                                            ...args: any[]
                                                                                                                                        ) => Promise<
                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                Record<string, unknown> &
                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                        >;

                                                                                                                                          function advancedGeneralIdentify

                                                                                                                                          advancedGeneralIdentify: (
                                                                                                                                              option?: {},
                                                                                                                                              ...args: any[]
                                                                                                                                          ) => Promise<
                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                          >;

                                                                                                                                            function animalClassify

                                                                                                                                            animalClassify: (
                                                                                                                                                option?: {},
                                                                                                                                                ...args: any[]
                                                                                                                                            ) => Promise<
                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                            >;

                                                                                                                                              function applyAddToMyApps

                                                                                                                                              applyAddToMyApps: (
                                                                                                                                                  option?: {},
                                                                                                                                                  ...args: any[]
                                                                                                                                              ) => Promise<
                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                              >;

                                                                                                                                                function arrayBufferToBase64

                                                                                                                                                arrayBufferToBase64: (arrayBuffer: ArrayBuffer) => string;

                                                                                                                                                  function authorize

                                                                                                                                                  authorize: (
                                                                                                                                                      option?: {},
                                                                                                                                                      ...args: any[]
                                                                                                                                                  ) => Promise<
                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                  >;

                                                                                                                                                    function authorizeForMiniProgram

                                                                                                                                                    authorizeForMiniProgram: (
                                                                                                                                                        option?: {},
                                                                                                                                                        ...args: any[]
                                                                                                                                                    ) => Promise<
                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                    >;

                                                                                                                                                      function authPrivateMessage

                                                                                                                                                      authPrivateMessage: (
                                                                                                                                                          option?: {},
                                                                                                                                                          ...args: any[]
                                                                                                                                                      ) => Promise<
                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                      >;

                                                                                                                                                      • 验证私密消息。

                                                                                                                                                      function base64ToArrayBuffer

                                                                                                                                                      base64ToArrayBuffer: (base64: string) => ArrayBufferLike;

                                                                                                                                                        function batchGetStorage

                                                                                                                                                        batchGetStorage: (
                                                                                                                                                            option?: {},
                                                                                                                                                            ...args: any[]
                                                                                                                                                        ) => Promise<
                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                        >;

                                                                                                                                                          function batchGetStorageSync

                                                                                                                                                          batchGetStorageSync: (
                                                                                                                                                              option?: {},
                                                                                                                                                              ...args: any[]
                                                                                                                                                          ) => Promise<
                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                          >;

                                                                                                                                                            function batchSetStorage

                                                                                                                                                            batchSetStorage: (
                                                                                                                                                                option?: {},
                                                                                                                                                                ...args: any[]
                                                                                                                                                            ) => Promise<
                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                            >;

                                                                                                                                                              function batchSetStorageSync

                                                                                                                                                              batchSetStorageSync: (
                                                                                                                                                                  option?: {},
                                                                                                                                                                  ...args: any[]
                                                                                                                                                              ) => Promise<
                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                              >;

                                                                                                                                                                function canIUseWebp

                                                                                                                                                                canIUseWebp: () => boolean;

                                                                                                                                                                  function carClassify

                                                                                                                                                                  carClassify: (
                                                                                                                                                                      option?: {},
                                                                                                                                                                      ...args: any[]
                                                                                                                                                                  ) => Promise<
                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                  >;

                                                                                                                                                                    function checkIsAddedToMyMiniProgram

                                                                                                                                                                    checkIsAddedToMyMiniProgram: (
                                                                                                                                                                        option?: {},
                                                                                                                                                                        ...args: any[]
                                                                                                                                                                    ) => Promise<
                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                    >;

                                                                                                                                                                      function checkIsOpenAccessibility

                                                                                                                                                                      checkIsOpenAccessibility: (
                                                                                                                                                                          option?: {},
                                                                                                                                                                          ...args: any[]
                                                                                                                                                                      ) => Promise<
                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                      >;

                                                                                                                                                                        function checkIsPictureInPictureActive

                                                                                                                                                                        checkIsPictureInPictureActive: (
                                                                                                                                                                            option?: {},
                                                                                                                                                                            ...args: any[]
                                                                                                                                                                        ) => Promise<
                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                        >;

                                                                                                                                                                          function checkIsSoterEnrolledInDevice

                                                                                                                                                                          checkIsSoterEnrolledInDevice: (
                                                                                                                                                                              option?: {},
                                                                                                                                                                              ...args: any[]
                                                                                                                                                                          ) => Promise<
                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                          >;

                                                                                                                                                                            function checkIsSupportFacialRecognition

                                                                                                                                                                            checkIsSupportFacialRecognition: (
                                                                                                                                                                                option?: {},
                                                                                                                                                                                ...args: any[]
                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                            >;

                                                                                                                                                                              function checkIsSupportSoterAuthentication

                                                                                                                                                                              checkIsSupportSoterAuthentication: (
                                                                                                                                                                                  option?: {},
                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                              >;

                                                                                                                                                                                function checkSession

                                                                                                                                                                                checkSession: (
                                                                                                                                                                                    option?: {},
                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                >;

                                                                                                                                                                                  function chooseAddress

                                                                                                                                                                                  chooseAddress: (
                                                                                                                                                                                      option?: {},
                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                  >;

                                                                                                                                                                                    function chooseContact

                                                                                                                                                                                    chooseContact: (
                                                                                                                                                                                        option?: {},
                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                    >;

                                                                                                                                                                                      function chooseInvoice

                                                                                                                                                                                      chooseInvoice: (
                                                                                                                                                                                          option?: {},
                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                      >;

                                                                                                                                                                                        function chooseInvoiceTitle

                                                                                                                                                                                        chooseInvoiceTitle: (
                                                                                                                                                                                            option?: {},
                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                        >;

                                                                                                                                                                                          function chooseLicensePlate

                                                                                                                                                                                          chooseLicensePlate: (
                                                                                                                                                                                              option?: {},
                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                          >;

                                                                                                                                                                                            function chooseMedia

                                                                                                                                                                                            chooseMedia: (
                                                                                                                                                                                                options: Taro.chooseMedia.Option,
                                                                                                                                                                                                methodName?: string
                                                                                                                                                                                            ) => Promise<Taro.chooseMedia.SuccessCallbackResult>;

                                                                                                                                                                                            • 拍摄或从手机相册中选择图片或视频。

                                                                                                                                                                                            function chooseMessageFile

                                                                                                                                                                                            chooseMessageFile: (
                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                            >;

                                                                                                                                                                                              function choosePoi

                                                                                                                                                                                              choosePoi: (
                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                              >;

                                                                                                                                                                                                function closeBLEConnection

                                                                                                                                                                                                closeBLEConnection: (
                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                >;

                                                                                                                                                                                                  function closeBluetoothAdapter

                                                                                                                                                                                                  closeBluetoothAdapter: (
                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                  >;

                                                                                                                                                                                                    function closeSocket

                                                                                                                                                                                                    closeSocket: () => void;

                                                                                                                                                                                                      function compressImage

                                                                                                                                                                                                      compressImage: (
                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                      >;

                                                                                                                                                                                                        function compressVideo

                                                                                                                                                                                                        compressVideo: (
                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                        >;

                                                                                                                                                                                                          function connectSocket

                                                                                                                                                                                                          connectSocket: (options?: Taro.connectSocket.Option) => Promise<unknown>;

                                                                                                                                                                                                            function connectWifi

                                                                                                                                                                                                            connectWifi: (
                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                            >;

                                                                                                                                                                                                              function createAudioContext

                                                                                                                                                                                                              createAudioContext: (
                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                              >;

                                                                                                                                                                                                                function createBLEConnection

                                                                                                                                                                                                                createBLEConnection: (
                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                >;

                                                                                                                                                                                                                  function createBLEPeripheralServer

                                                                                                                                                                                                                  createBLEPeripheralServer: (
                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                    function createBufferURL

                                                                                                                                                                                                                    createBufferURL: (
                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                      function createCacheManager

                                                                                                                                                                                                                      createCacheManager: (
                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                        function createCameraContext

                                                                                                                                                                                                                        createCameraContext: (
                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                          function createInferenceSession

                                                                                                                                                                                                                          createInferenceSession: (
                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                            function createInterstitialAd

                                                                                                                                                                                                                            createInterstitialAd: (
                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                              function createLivePlayerContext

                                                                                                                                                                                                                              createLivePlayerContext: (
                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                function createLivePusherContext

                                                                                                                                                                                                                                createLivePusherContext: (
                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                  function createMapContext

                                                                                                                                                                                                                                  createMapContext: (
                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                    function createMediaAudioPlayer

                                                                                                                                                                                                                                    createMediaAudioPlayer: (
                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                      function createMediaContainer

                                                                                                                                                                                                                                      createMediaContainer: (
                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                        function createMediaRecorder

                                                                                                                                                                                                                                        createMediaRecorder: (
                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                          function createOffscreenCanvas

                                                                                                                                                                                                                                          createOffscreenCanvas: (
                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                          • 创建离屏 canvas 实例

                                                                                                                                                                                                                                          function createRewardedVideoAd

                                                                                                                                                                                                                                          createRewardedVideoAd: (
                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                            function createTCPSocket

                                                                                                                                                                                                                                            createTCPSocket: (
                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                              function createUDPSocket

                                                                                                                                                                                                                                              createUDPSocket: (
                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                function createVideoDecoder

                                                                                                                                                                                                                                                createVideoDecoder: (
                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                  function createVKSession

                                                                                                                                                                                                                                                  createVKSession: (
                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                    function createWebAudioContext

                                                                                                                                                                                                                                                    createWebAudioContext: (
                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                      function createWorker

                                                                                                                                                                                                                                                      createWorker: (
                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                        function cropImage

                                                                                                                                                                                                                                                        cropImage: (
                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                          function disableAlertBeforeUnload

                                                                                                                                                                                                                                                          disableAlertBeforeUnload: (
                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                            function dishClassify

                                                                                                                                                                                                                                                            dishClassify: (
                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                              function editImage

                                                                                                                                                                                                                                                              editImage: (
                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                function enableAlertBeforeUnload

                                                                                                                                                                                                                                                                enableAlertBeforeUnload: (
                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                  function exitMiniProgram

                                                                                                                                                                                                                                                                  exitMiniProgram: (
                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                    function exitVoIPChat

                                                                                                                                                                                                                                                                    exitVoIPChat: (
                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                      function faceDetect

                                                                                                                                                                                                                                                                      faceDetect: (
                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                        function faceVerifyForPay

                                                                                                                                                                                                                                                                        faceVerifyForPay: (
                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                          function getAccountInfoSync

                                                                                                                                                                                                                                                                          getAccountInfoSync: (
                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                            function getAppInfo

                                                                                                                                                                                                                                                                            getAppInfo: () => { platform: string; taroVersion: string; designWidth: any };

                                                                                                                                                                                                                                                                              function getAvailableAudioSources

                                                                                                                                                                                                                                                                              getAvailableAudioSources: (
                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                function getBackgroundAudioManager

                                                                                                                                                                                                                                                                                getBackgroundAudioManager: () => BackgroundAudioManager;

                                                                                                                                                                                                                                                                                • 获取全局唯一的背景音频管理器

                                                                                                                                                                                                                                                                                function getBackgroundAudioPlayerState

                                                                                                                                                                                                                                                                                getBackgroundAudioPlayerState: (
                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                  function getBackgroundFetchData

                                                                                                                                                                                                                                                                                  getBackgroundFetchData: (
                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                    function getBackgroundFetchToken

                                                                                                                                                                                                                                                                                    getBackgroundFetchToken: (
                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                      function getBatteryInfoSync

                                                                                                                                                                                                                                                                                      getBatteryInfoSync: (
                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                        function getBeacons

                                                                                                                                                                                                                                                                                        getBeacons: (
                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                          function getBLEDeviceCharacteristics

                                                                                                                                                                                                                                                                                          getBLEDeviceCharacteristics: (
                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                            function getBLEDeviceRSSI

                                                                                                                                                                                                                                                                                            getBLEDeviceRSSI: (
                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                              function getBLEDeviceServices

                                                                                                                                                                                                                                                                                              getBLEDeviceServices: (
                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                function getBLEMTU

                                                                                                                                                                                                                                                                                                getBLEMTU: (
                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                  function getBluetoothAdapterState

                                                                                                                                                                                                                                                                                                  getBluetoothAdapterState: (
                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                    function getBluetoothDevices

                                                                                                                                                                                                                                                                                                    getBluetoothDevices: (
                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                      function getChannelsLiveInfo

                                                                                                                                                                                                                                                                                                      getChannelsLiveInfo: (
                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                        function getChannelsLiveNoticeInfo

                                                                                                                                                                                                                                                                                                        getChannelsLiveNoticeInfo: (
                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                          function getChannelsShareKey

                                                                                                                                                                                                                                                                                                          getChannelsShareKey: (
                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                            function getConnectedBluetoothDevices

                                                                                                                                                                                                                                                                                                            getConnectedBluetoothDevices: (
                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                              function getConnectedWifi

                                                                                                                                                                                                                                                                                                              getConnectedWifi: (
                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                function getCurrentInstance

                                                                                                                                                                                                                                                                                                                getCurrentInstance: () => Taro.getCurrentInstance.Current;

                                                                                                                                                                                                                                                                                                                  function getDeviceVoIPList

                                                                                                                                                                                                                                                                                                                  getDeviceVoIPList: (
                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                    function getExptInfoSync

                                                                                                                                                                                                                                                                                                                    getExptInfoSync: (
                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                      function getExtConfig

                                                                                                                                                                                                                                                                                                                      getExtConfig: (
                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                        function getExtConfigSync

                                                                                                                                                                                                                                                                                                                        getExtConfigSync: (
                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                          function getFileInfo

                                                                                                                                                                                                                                                                                                                          getFileInfo: (
                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                            function getFileSystemManager

                                                                                                                                                                                                                                                                                                                            getFileSystemManager: (
                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                              function getFuzzyLocation

                                                                                                                                                                                                                                                                                                                              getFuzzyLocation: (
                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                function getGroupEnterInfo

                                                                                                                                                                                                                                                                                                                                getGroupEnterInfo: (
                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                  function getGuildInfo

                                                                                                                                                                                                                                                                                                                                  getGuildInfo: (
                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                    function getHCEState

                                                                                                                                                                                                                                                                                                                                    getHCEState: (
                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                      function getInferenceEnvInfo

                                                                                                                                                                                                                                                                                                                                      getInferenceEnvInfo: (
                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                        function getLocalIPAddress

                                                                                                                                                                                                                                                                                                                                        getLocalIPAddress: (
                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                          function getLocation

                                                                                                                                                                                                                                                                                                                                          getLocation: (
                                                                                                                                                                                                                                                                                                                                              options?: Taro.getLocation.Option,
                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                          ) => Promise<Taro.getLocation.SuccessCallbackResult>;

                                                                                                                                                                                                                                                                                                                                            function getLogManager

                                                                                                                                                                                                                                                                                                                                            getLogManager: (
                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                              function getMenuButtonBoundingClientRect

                                                                                                                                                                                                                                                                                                                                              getMenuButtonBoundingClientRect: (
                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                function getNFCAdapter

                                                                                                                                                                                                                                                                                                                                                getNFCAdapter: (
                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                  function getOpenUserInfo

                                                                                                                                                                                                                                                                                                                                                  getOpenUserInfo: (
                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                    function getPerformance

                                                                                                                                                                                                                                                                                                                                                    getPerformance: (
                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                      function getPrivacySetting

                                                                                                                                                                                                                                                                                                                                                      getPrivacySetting: (
                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                        function getQQRunData

                                                                                                                                                                                                                                                                                                                                                        getQQRunData: (
                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                          function getRandomValues

                                                                                                                                                                                                                                                                                                                                                          getRandomValues: (
                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                            function getRealtimeLogManager

                                                                                                                                                                                                                                                                                                                                                            getRealtimeLogManager: (
                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                              function getRecorderManager

                                                                                                                                                                                                                                                                                                                                                              getRecorderManager: (
                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                function getRendererUserAgent

                                                                                                                                                                                                                                                                                                                                                                getRendererUserAgent: (
                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                  function getSavedFileInfo

                                                                                                                                                                                                                                                                                                                                                                  getSavedFileInfo: (
                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                    function getSavedFileList

                                                                                                                                                                                                                                                                                                                                                                    getSavedFileList: (
                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                      function getScreenBrightness

                                                                                                                                                                                                                                                                                                                                                                      getScreenBrightness: (
                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                        function getScreenRecordingState

                                                                                                                                                                                                                                                                                                                                                                        getScreenRecordingState: (
                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                          function getSelectedTextRange

                                                                                                                                                                                                                                                                                                                                                                          getSelectedTextRange: (
                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                            function getSetting

                                                                                                                                                                                                                                                                                                                                                                            getSetting: (
                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                              function getShareInfo

                                                                                                                                                                                                                                                                                                                                                                              getShareInfo: (
                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                              • 获取转发详细信息

                                                                                                                                                                                                                                                                                                                                                                              function getSkylineInfo

                                                                                                                                                                                                                                                                                                                                                                              getSkylineInfo: (
                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                function getSkylineInfoSync

                                                                                                                                                                                                                                                                                                                                                                                getSkylineInfoSync: (
                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                  function getSwanId

                                                                                                                                                                                                                                                                                                                                                                                  getSwanId: (
                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                    function getUpdateManager

                                                                                                                                                                                                                                                                                                                                                                                    getUpdateManager: (
                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                      function getUserCryptoManager

                                                                                                                                                                                                                                                                                                                                                                                      getUserCryptoManager: (
                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                        function getUserInfo

                                                                                                                                                                                                                                                                                                                                                                                        getUserInfo: (
                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                          function getUserProfile

                                                                                                                                                                                                                                                                                                                                                                                          getUserProfile: (
                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                            function getWeRunData

                                                                                                                                                                                                                                                                                                                                                                                            getWeRunData: (
                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                              function getWifiList

                                                                                                                                                                                                                                                                                                                                                                                              getWifiList: (
                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                function hideHomeButton

                                                                                                                                                                                                                                                                                                                                                                                                hideHomeButton: (
                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                  function hideKeyboard

                                                                                                                                                                                                                                                                                                                                                                                                  hideKeyboard: (
                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                    function hideNavigationBarLoading

                                                                                                                                                                                                                                                                                                                                                                                                    hideNavigationBarLoading: (
                                                                                                                                                                                                                                                                                                                                                                                                        options?: Taro.hideNavigationBarLoading.Option
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                    • 隐藏导航栏 loading 状态

                                                                                                                                                                                                                                                                                                                                                                                                    function hideShareMenu

                                                                                                                                                                                                                                                                                                                                                                                                    hideShareMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                    • 隐藏当前页面的转发按钮

                                                                                                                                                                                                                                                                                                                                                                                                    function imageAudit

                                                                                                                                                                                                                                                                                                                                                                                                    imageAudit: (
                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                      function initFaceDetect

                                                                                                                                                                                                                                                                                                                                                                                                      initFaceDetect: (
                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                        function initPxTransform

                                                                                                                                                                                                                                                                                                                                                                                                        initPxTransform: ({
                                                                                                                                                                                                                                                                                                                                                                                                            designWidth,
                                                                                                                                                                                                                                                                                                                                                                                                            deviceRatio,
                                                                                                                                                                                                                                                                                                                                                                                                            baseFontSize,
                                                                                                                                                                                                                                                                                                                                                                                                            unitPrecision,
                                                                                                                                                                                                                                                                                                                                                                                                            targetUnit,
                                                                                                                                                                                                                                                                                                                                                                                                        }: {
                                                                                                                                                                                                                                                                                                                                                                                                            designWidth?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                            deviceRatio?: TaroGeneral.TDeviceRatio | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                            baseFontSize?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                            unitPrecision?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                            targetUnit?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                        }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          function initTabBarApis

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

                                                                                                                                                                                                                                                                                                                                                                                                            function isAddedToMyApps

                                                                                                                                                                                                                                                                                                                                                                                                            isAddedToMyApps: (
                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                              function isBluetoothDevicePaired

                                                                                                                                                                                                                                                                                                                                                                                                              isBluetoothDevicePaired: (
                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                function isVKSupport

                                                                                                                                                                                                                                                                                                                                                                                                                isVKSupport: (
                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                  function join1v1Chat

                                                                                                                                                                                                                                                                                                                                                                                                                  join1v1Chat: (
                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                    function joinVoIPChat

                                                                                                                                                                                                                                                                                                                                                                                                                    joinVoIPChat: (
                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                      function login

                                                                                                                                                                                                                                                                                                                                                                                                                      login: (
                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                        function logoClassify

                                                                                                                                                                                                                                                                                                                                                                                                                        logoClassify: (
                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                          function makeBluetoothPair

                                                                                                                                                                                                                                                                                                                                                                                                                          makeBluetoothPair: (
                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                            navigateBackMiniProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                              navigateBackSmartProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                                                navigateToMiniProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                  navigateToSmartGameProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                    navigateToSmartProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function nextTick

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        function notifyBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                                                                                        notifyBLECharacteristicValueChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function objectDetectIdentify

                                                                                                                                                                                                                                                                                                                                                                                                                                          objectDetectIdentify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function ocrBankCard

                                                                                                                                                                                                                                                                                                                                                                                                                                            ocrBankCard: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function ocrDrivingLicense

                                                                                                                                                                                                                                                                                                                                                                                                                                              ocrDrivingLicense: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function ocrIdCard

                                                                                                                                                                                                                                                                                                                                                                                                                                                ocrIdCard: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function ocrVehicleLicense

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ocrVehicleLicense: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function offAudioInterruptionBegin

                                                                                                                                                                                                                                                                                                                                                                                                                                                    offAudioInterruptionBegin: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function offAudioInterruptionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                      offAudioInterruptionEnd: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function offBeaconServiceChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                        offBeaconServiceChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function offBeaconUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                          offBeaconUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function offBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                            offBLECharacteristicValueChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function offBLEConnectionStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                              offBLEConnectionStateChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function offBLEMTUChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                offBLEMTUChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function offBLEPeripheralConnectionStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offBLEPeripheralConnectionStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function offBluetoothAdapterStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offBluetoothAdapterStateChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function offBluetoothDeviceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offBluetoothDeviceFound: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function offCopyUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offCopyUrl: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 移除用户点击右上角菜单的「复制链接」按钮时触发的事件的监听函数

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function offGetWifiList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offGetWifiList: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function offGyroscopeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offGyroscopeChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function offHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offHCEMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function offKeyboardHeightChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offKeyboardHeightChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function offLazyLoadError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                offLazyLoadError: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function offLocalServiceDiscoveryStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offLocalServiceDiscoveryStop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function offLocalServiceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offLocalServiceFound: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function offLocalServiceLost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offLocalServiceLost: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function offLocalServiceResolveFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offLocalServiceResolveFail: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function offLocationChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offLocationChange: (callback: Taro.onLocationChange.Callback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function offLocationChangeError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offLocationChangeError: (callback: Taro.onLocationChange.Callback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function offMemoryWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offMemoryWarning: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function offNetworkWeakChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                offNetworkWeakChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function offScreenRecordingStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offScreenRecordingStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function offUserCaptureScreen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offUserCaptureScreen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function offVoIPChatInterrupted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offVoIPChatInterrupted: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function offVoIPChatMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offVoIPChatMembersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function offVoIPChatSpeakersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offVoIPChatSpeakersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function offVoIPChatStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            offVoIPChatStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function offVoIPVideoMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offVoIPVideoMembersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function offWifiConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                offWifiConnected: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function offWifiConnectedWithPartialInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offWifiConnectedWithPartialInfo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onAudioInterruptionBegin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onAudioInterruptionBegin: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onAudioInterruptionEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onAudioInterruptionEnd: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onBackgroundAudioPause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onBackgroundAudioPause: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onBackgroundAudioPlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBackgroundAudioPlay: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onBackgroundAudioStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBackgroundAudioStop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onBackgroundFetchData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onBackgroundFetchData: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onBeaconServiceChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onBeaconServiceChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onBeaconUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onBeaconUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onBLECharacteristicValueChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onBLECharacteristicValueChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onBLEConnectionStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBLEConnectionStateChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onBLEMTUChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onBLEMTUChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onBLEPeripheralConnectionStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBLEPeripheralConnectionStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onBluetoothAdapterStateChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onBluetoothAdapterStateChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onBluetoothDeviceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onBluetoothDeviceFound: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onCopyUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCopyUrl: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 监听用户点击右上角菜单的「复制链接」按钮时触发的事件

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onGetWifiList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onGetWifiList: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onGyroscopeChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onGyroscopeChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onHCEMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onKeyboardHeightChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onKeyboardHeightChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onLazyLoadError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onLazyLoadError: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onLocalServiceDiscoveryStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onLocalServiceDiscoveryStop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onLocalServiceFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onLocalServiceFound: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onLocalServiceLost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onLocalServiceLost: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onLocalServiceResolveFail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onLocalServiceResolveFail: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onLocationChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onLocationChange: (callback: Taro.onLocationChange.Callback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onLocationChangeError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onLocationChangeError: (callback: Taro.onLocationChange.Callback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onMemoryWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onMemoryWarning: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onNeedPrivacyAuthorization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onNeedPrivacyAuthorization: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onNetworkWeakChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onNetworkWeakChange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onScreenRecordingStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onScreenRecordingStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onSocketClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onSocketClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onSocketError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onSocketError: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onSocketMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onSocketMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onSocketOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onSocketOpen: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function onUserCaptureScreen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onUserCaptureScreen: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function onVoIPChatInterrupted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onVoIPChatInterrupted: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function onVoIPChatMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onVoIPChatMembersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function onVoIPChatSpeakersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onVoIPChatSpeakersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function onVoIPChatStateChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onVoIPChatStateChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onVoIPVideoMembersChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onVoIPVideoMembersChanged: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onWifiConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onWifiConnected: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function onWifiConnectedWithPartialInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onWifiConnectedWithPartialInfo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openAppAuthorizeSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    openAppAuthorizeSetting: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 跳转系统微信授权管理页

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openBluetoothAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    openBluetoothAdapter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openBusinessView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openBusinessView: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function openCard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openCard: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function openChannelsActivity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          openChannelsActivity: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function openChannelsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openChannelsEvent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function openChannelsLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openChannelsLive: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function openChannelsUserProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openChannelsUserProfile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function openCustomerServiceChat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  openCustomerServiceChat: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    openDocument: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openEmbeddedMiniProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openEmbeddedMiniProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function openLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openLocation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: Partial<{ scale: number }>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function openPrivacyContract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          openPrivacyContract: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function openQzonePublish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            openQzonePublish: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function openSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openSetting: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function openSystemBluetoothSetting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openSystemBluetoothSetting: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 跳转系统蓝牙设置页

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function openVideoEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openVideoEditor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function pauseBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pauseBackgroundAudio: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function pauseVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pauseVoice: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function plantClassify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      plantClassify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function playBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        playBackgroundAudio: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function playVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          playVoice: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function pluginLogin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pluginLogin: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function preloadAssets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              preloadAssets: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function preloadSkylineView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                preloadSkylineView: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function preloadSubPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  preloadSubPackage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function preloadWebview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preloadWebview: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function pxTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pxTransform: (size?: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function readBLECharacteristicValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readBLECharacteristicValue: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function removeSavedFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          removeSavedFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function reportAnalytics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reportAnalytics: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function reportEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reportEvent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function reportMonitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reportMonitor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function reportPerformance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reportPerformance: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    request: <T = any, U = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option: Taro.request.Option<T, U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Taro.RequestTask<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function requestDeviceVoIP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestDeviceVoIP: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function requestOrderPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requestOrderPayment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function requestPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          requestPayment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function requestPluginPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestPluginPayment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function requestPolymerPayment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestPolymerPayment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function requestSubscribeDeviceMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestSubscribeDeviceMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function requestSubscribeMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestSubscribeMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function requirePlugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requirePlugin: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function requirePrivacyAuthorize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requirePrivacyAuthorize: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function reserveChannelsLive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reserveChannelsLive: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function revokeBufferURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          revokeBufferURL: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function saveFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            saveFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function saveFileToDisk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              saveFileToDisk: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function scanCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scanCode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: Partial<{ needResult: number }>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function seekBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  seekBackgroundAudio: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function sendHCEMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sendHCEMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function sendSms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sendSms: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function sendSocketMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sendSocketMessage: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function setBackgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setBackgroundColor: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function setBackgroundFetchToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setBackgroundFetchToken: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setBackgroundTextStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setBackgroundTextStyle: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setBLEMTU

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setBLEMTU: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setCustomDress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setCustomDress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function setEnable1v1Chat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setEnable1v1Chat: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function setEnableDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setEnableDebug: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function setInnerAudioOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setInnerAudioOption: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function setKeepScreenOn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setKeepScreenOn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function setNavigationBarTitle

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setOfficialDress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setOfficialDress: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setPageInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setPageInfo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setScreenBrightness

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setScreenBrightness: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function setTopBarText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setTopBarText: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function setVisualEffectOnCapture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setVisualEffectOnCapture: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function setWifiList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setWifiList: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function setWindowSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setWindowSize: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 设置窗口大小，该接口仅适用于 PC 平台，使用细则请参见指南

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function shareFileMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shareFileMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 转发文件到聊天

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function shareToWeRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shareToWeRun: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function shareVideoMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            shareVideoMessage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 转发视频到聊天

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function showActionSheet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showActionSheet: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: Taro.showActionSheet.Option,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                methodName?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<Taro.showActionSheet.SuccessCallbackResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function showNavigationBarLoading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showNavigationBarLoading: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: Taro.showNavigationBarLoading.Option
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 展示导航栏 loading 状态

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function showRedPackage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showRedPackage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function showShareImageMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showShareImageMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 打开分享图片弹窗，可以将图片发送给朋友、收藏或下载

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function showShareMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showShareMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 显示当前页面的转发按钮

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function startBeaconDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                startBeaconDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function startBluetoothDevicesDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startBluetoothDevicesDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function startFacialRecognitionVerify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startFacialRecognitionVerify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function startFacialRecognitionVerifyAndUploadVideo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startFacialRecognitionVerifyAndUploadVideo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function startGyroscope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        startGyroscope: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function startHCE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          startHCE: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function startLocalServiceDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startLocalServiceDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function startLocationUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startLocationUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<TaroGeneral.CallbackResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function startLocationUpdateBackground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                startLocationUpdateBackground: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function startRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startRecord: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function startSoterAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startSoterAuthentication: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function startWifi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      startWifi: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function stopBackgroundAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stopBackgroundAudio: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function stopBeaconDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopBeaconDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function stopBluetoothDevicesDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stopBluetoothDevicesDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function stopFaceDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stopFaceDetect: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function stopGyroscope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stopGyroscope: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function stopHCE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stopHCE: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function stopLocalServiceDiscovery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stopLocalServiceDiscovery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function stopLocationUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stopLocationUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<TaroGeneral.CallbackResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function stopRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stopRecord: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function stopVoice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopVoice: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function stopWifi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stopWifi: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function subscribeVoIPVideoMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subscribeVoIPVideoMembers: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function textReview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                textReview: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function textToAudio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  textToAudio: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function tradePay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tradePay: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function updateQQApp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      updateQQApp: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function updateShareMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateShareMenu: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 更新转发属性

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function updateVoIPChatMuteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateVoIPChatMuteConfig: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function updateWeChatApp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateWeChatApp: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function writeBLECharacteristicValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            writeBLECharacteristicValue: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class cloud

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class cloud implements Taro.cloud {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property callContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callContainer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property callFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Cloud

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property CloudID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CloudID: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property database

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        database: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property deleteFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deleteFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property downloadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            downloadFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getTempFileURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getTempFileURL: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                init: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property uploadFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  uploadFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class NodesRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class NodesRef implements Taro.NodesRef {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          selector: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          querySelectorQuery: SelectorQuery,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          single: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method boundingClientRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        boundingClientRect: (cb: any) => SelectorQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          context: (cb: any) => SelectorQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fields: (fields: any, cb: any) => SelectorQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: (cb: any) => SelectorQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method scrollOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollOffset: (cb: any) => SelectorQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SocketTask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SocketTask {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(url: any, protocols: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property CLOSED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CLOSED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property closeDetail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        closeDetail: { code: any; reason: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property CLOSING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CLOSING: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property CONNECTING

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CONNECTING: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property OPEN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OPEN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property readyState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly readyState: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ws

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ws: WebSocket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    close: (opts?: Taro.SocketTask.CloseOption) => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClose: (func: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onError: (func: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onMessage: (func: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onOpen: (func: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              send: (opts?: Taro.SocketTask.SendOption) => Promise<{ errMsg: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace @tarojs/api

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module '@tarojs/api' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace @tarojs/components/dist/components

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module '@tarojs/components/dist/components' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function defineCustomElementTaroSwiperCore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defineCustomElementTaroSwiperCore: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function defineCustomElementTaroSwiperItemCore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defineCustomElementTaroSwiperItemCore: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (129)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (15)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (16)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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>