Logo for jsDocs.io

@tarojs/taro-h5

  • Version 3.6.7
  • Published
  • 4.02 MB
  • 11 dependencies
  • MIT license

Install

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

Overview

Taro h5 framework

Index

Variables

Functions

Classes

Namespaces

Variables

variable addInterceptor

const addInterceptor: any;

    variable Behavior

    const Behavior: any;

      variable canvasGetImageData

      const canvasGetImageData: any;

      • 获取 canvas 区域隐含的像素数据。

      variable canvasPutImageData

      const canvasPutImageData: any;

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

      variable canvasToTempFilePath

      const canvasToTempFilePath: any;

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

      variable chooseImage

      const chooseImage: any;

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

      variable chooseLocation

      const chooseLocation: any;

      • 打开地图选择位置。

      variable chooseVideo

      const chooseVideo: any;

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

      variable 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 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 removeStorage

                                                                                                const removeStorage: any;

                                                                                                  variable removeStorageSync

                                                                                                  const removeStorageSync: any;

                                                                                                    variable removeTabBarBadge

                                                                                                    const removeTabBarBadge: any;

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

                                                                                                    variable request

                                                                                                    const request: any;

                                                                                                      variable setClipboardData

                                                                                                      const setClipboardData: any;

                                                                                                      • 设置系统剪贴板的内容

                                                                                                      variable setNavigationBarColor

                                                                                                      const setNavigationBarColor: any;

                                                                                                      • 设置页面导航条颜色

                                                                                                      variable setStorage

                                                                                                      const setStorage: any;

                                                                                                        variable setStorageSync

                                                                                                        const setStorageSync: any;

                                                                                                          variable setTabBarBadge

                                                                                                          const setTabBarBadge: any;

                                                                                                          • 为 tabBar 某一项的右上角添加文本

                                                                                                          variable setTabBarItem

                                                                                                          const setTabBarItem: any;

                                                                                                          • 动态设置 tabBar 某一项的内容

                                                                                                          variable setTabBarStyle

                                                                                                          const setTabBarStyle: any;

                                                                                                          • 动态设置 tabBar 的整体样式

                                                                                                          variable showActionSheet

                                                                                                          const showActionSheet: any;

                                                                                                            variable showLoading

                                                                                                            const showLoading: any;

                                                                                                              variable showModal

                                                                                                              const showModal: any;

                                                                                                                variable showTabBar

                                                                                                                const showTabBar: any;

                                                                                                                • 显示 tabBar

                                                                                                                variable showTabBarRedDot

                                                                                                                const showTabBarRedDot: any;

                                                                                                                • 显示 tabBar 某一项的右上角的红点

                                                                                                                variable showToast

                                                                                                                const showToast: any;

                                                                                                                  variable startAccelerometer

                                                                                                                  const startAccelerometer: any;

                                                                                                                  • 开始监听加速度数据。

                                                                                                                  variable startCompass

                                                                                                                  const startCompass: any;

                                                                                                                  • 开始监听罗盘数据

                                                                                                                  variable startDeviceMotionListening

                                                                                                                  const startDeviceMotionListening: any;

                                                                                                                  • 开始监听设备方向的变化。

                                                                                                                  variable startPullDownRefresh

                                                                                                                  const startPullDownRefresh: any;

                                                                                                                  • 开始下拉刷新。调用后触发下拉刷新动画，效果与用户手动下拉刷新一致。

                                                                                                                  variable stopAccelerometer

                                                                                                                  const stopAccelerometer: any;

                                                                                                                  • 停止监听加速度数据。

                                                                                                                  variable stopCompass

                                                                                                                  const stopCompass: any;

                                                                                                                  • 停止监听罗盘数据

                                                                                                                  variable stopDeviceMotionListening

                                                                                                                  const stopDeviceMotionListening: any;

                                                                                                                  • 停止监听设备方向的变化。

                                                                                                                  variable stopPullDownRefresh

                                                                                                                  const stopPullDownRefresh: any;

                                                                                                                  • 停止当前页面下拉刷新。

                                                                                                                  variable taro

                                                                                                                  const taro: any;

                                                                                                                    variable uploadFile

                                                                                                                    const uploadFile: any;

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

                                                                                                                    variable vibrateLong

                                                                                                                    const vibrateLong: any;

                                                                                                                    • 使手机发生较长时间的振动（400 ms)

                                                                                                                    variable vibrateShort

                                                                                                                    const vibrateShort: any;

                                                                                                                    • 使手机发生较短时间的振动（15 ms）。仅在 iPhone 7 / 7 Plus 以上及 Android 机型生效

                                                                                                                    Functions

                                                                                                                    function addCard

                                                                                                                    addCard: (
                                                                                                                        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 addPhoneCalendar

                                                                                                                        addPhoneCalendar: (
                                                                                                                            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 addPhoneRepeatCalendar

                                                                                                                            addPhoneRepeatCalendar: (
                                                                                                                                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 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) => Uint8Array;

                                                                                                                                              function canIUse

                                                                                                                                              canIUse: (
                                                                                                                                                  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: (
                                                                                                                                                                                option?: {},
                                                                                                                                                                                ...args: any[]
                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                            >;

                                                                                                                                                                              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 createCameraContext

                                                                                                                                                                                                        createCameraContext: (
                                                                                                                                                                                                            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 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 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 getHCEState

                                                                                                                                                                                                                                                                                                            getHCEState: (
                                                                                                                                                                                                                                                                                                                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 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 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 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 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 getVideoInfo

                                                                                                                                                                                                                                                                                                                                                        getVideoInfo: (
                                                                                                                                                                                                                                                                                                                                                            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: (
                                                                                                                                                                                                                                                                                                                                                                      option?: {},
                                                                                                                                                                                                                                                                                                                                                                      ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                      Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                          Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                          TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                    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 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 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 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: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function offLocationChangeError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 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 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 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: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option?: {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ...args: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Partial<TaroGeneral.CallbackResult> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Record<string, unknown> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TaroGeneral.CallbackResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function onLocationChangeError

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function onMemoryWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onMemoryWarning: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 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 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 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 preloadSubPackage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function previewMedia

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  previewMedia: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 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 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 reserveChannelsLive

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