@astralsight/astroforge-core 0.0.1

package/dist/apis.d.mts

@@ -0,0 +1,992 @@
+//#region src/apis.d.ts
+type BridgeValue = unknown;
+type BridgeCallback<Args extends unknown[] = []> = (...args: Args) => void;
+type BridgeFailCallback = (errMsg: string, errCode: number) => void;
+interface CallbackOptions<Success = BridgeValue> {
+  success?: BridgeCallback<[Success]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface LocaleInfo {
+  language: string;
+  countryOrRegion: string;
+}
+interface RouteObject {
+  uri: string;
+  params?: Record<string, BridgeValue>;
+}
+interface RouterBackOptions {
+  path?: string;
+}
+interface RouteStack {
+  name: string;
+  path: string;
+}
+interface RouteState extends RouteStack {
+  index: number;
+}
+interface RouterApi {
+  getPages(): RouteStack[];
+  push(options: RouteObject): void;
+  replace(options: RouteObject): void;
+  back(options?: RouterBackOptions): void;
+  clear(): void;
+  getLength(): number;
+  getState(): RouteState;
+}
+interface AppSource {
+  [key: string]: BridgeValue;
+}
+interface AppInfo {
+  packageName: string;
+  name: string;
+  versionName: string;
+  versionCode: number;
+  icon: string;
+  logLevel: string;
+  source: AppSource;
+}
+interface AppApi {
+  getInfo(): AppInfo;
+  terminate(): void;
+  canIUse(capability?: BridgeValue): boolean;
+  loadLibrary(libraryName: string): BridgeValue;
+}
+interface PromptToastOptions {
+  message: string;
+  duration?: BridgeValue;
+}
+interface PromptDialogResult {
+  index: number;
+}
+interface PromptDialogOptions {
+  title?: string;
+  message: string;
+  autocancel?: boolean;
+  success?: BridgeCallback<[PromptDialogResult]>;
+  cancel?: BridgeCallback;
+  complete?: BridgeCallback;
+}
+interface PromptApi {
+  showToast(options: PromptToastOptions): void;
+  showDialog(options: PromptDialogOptions): void;
+}
+interface FetchOptions {
+  url: string;
+  data?: BridgeValue;
+  header?: BridgeValue;
+  method?: "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" | "PATCH" | string;
+  responseType?: "" | "text" | "json" | "file" | "arraybuffer" | string;
+  timeout?: number;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface UploadSuccess {
+  data?: BridgeValue;
+  statusCode?: number;
+  header?: BridgeValue;
+  [key: string]: BridgeValue;
+}
+interface UploadProgress {
+  progress: number;
+  totalBytesSent: number;
+  totalBytesExpectedToSend: number;
+}
+interface UploadFileOptions {
+  url: string;
+  filePath: string;
+  name: string;
+  header?: BridgeValue;
+  formData?: BridgeValue;
+  timeout?: number;
+  success?: BridgeCallback<[UploadSuccess]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface UploadTask {
+  abort(): void;
+  onProgressUpdate(callback: BridgeCallback<[UploadProgress]>): void;
+  offProgressUpdate(callback?: BridgeCallback<[UploadProgress]>): void;
+}
+interface DownloadNotifyData {
+  progress?: number;
+  totalBytesWritten?: number;
+  totalBytesExpectedToWrite?: number;
+  [key: string]: BridgeValue;
+}
+interface DownloadSuccess {
+  token: string;
+  [key: string]: BridgeValue;
+}
+interface DownloadCompleteSuccess {
+  uri: string;
+  [key: string]: BridgeValue;
+}
+interface DownloadOptions {
+  url: string;
+  header?: string;
+  filename?: string;
+  share?: boolean;
+  onDownLoadNotify?: BridgeCallback<[DownloadNotifyData]>;
+  success?: BridgeCallback<[DownloadSuccess]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface DownloadCompleteOptions {
+  token: string;
+  success?: BridgeCallback<[DownloadCompleteSuccess]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface NetworkApi {
+  fetch(options: FetchOptions): Promise<BridgeValue>;
+  uploadFile(options: UploadFileOptions): UploadTask;
+  download(options: DownloadOptions): void;
+  onDownloadComplete(options: DownloadCompleteOptions): void;
+  getType(options: CallbackOptions<NetworkTypeInfo>): void;
+  subscribe(options: {
+    callback?: BridgeCallback<[NetworkTypeInfo]>;
+    fail?: BridgeFailCallback;
+  }): void;
+  unsubscribe(): void;
+}
+type NetworkType = "2g" | "3g" | "4g" | "5g" | "wifi" | "bluetooth" | "none" | "others";
+interface NetworkTypeInfo {
+  type: NetworkType | string;
+}
+interface StorageGetOptions {
+  key: string;
+  default?: string;
+  success?: BridgeCallback<[string]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback<[string]>;
+}
+interface StorageSetOptions {
+  key: string;
+  value?: string;
+  success?: BridgeCallback<[string]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback<[string]>;
+}
+interface StorageDeleteOptions {
+  key: string;
+  success?: BridgeCallback<[string]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback<[string]>;
+}
+interface StorageKeyOptions {
+  index: number;
+  success?: BridgeCallback<[string]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback<[string]>;
+}
+interface StorageApi {
+  get(options: StorageGetOptions): void;
+  set(options: StorageSetOptions): void;
+  clear(options?: CallbackOptions<string>): void;
+  delete(options: StorageDeleteOptions): void;
+  key(options: StorageKeyOptions): void;
+  length: number;
+}
+interface ExchangeOptions {
+  key?: string;
+  value?: string;
+  scope?: string;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback<[string]>;
+}
+interface ExchangeApi {
+  set(options: ExchangeOptions & {
+    key: string;
+    value: string;
+  }): void;
+  get(options: ExchangeOptions & {
+    key: string;
+  }): void;
+  remove(options: ExchangeOptions & {
+    key: string;
+  }): void;
+  clear(options?: ExchangeOptions): void;
+}
+interface CryptoHashDigestOptions {
+  data?: BridgeValue;
+  uri?: string;
+  algo?: string;
+}
+interface CryptoHmacDigestOptions extends CallbackOptions {
+  data: string;
+  algo?: string;
+  key: string;
+}
+interface CryptoSignOptions extends CallbackOptions {
+  data?: BridgeValue;
+  uri?: string;
+  algo?: string;
+  privateKey: string;
+}
+interface CryptoVerifyOptions {
+  data?: BridgeValue;
+  uri?: string;
+  algo?: string;
+  signature: BridgeValue;
+  publicKey: string;
+  success?: BridgeCallback<[boolean]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface CryptoCryptOptions extends CallbackOptions {
+  data: BridgeValue;
+  algo?: string;
+  key: string;
+  options?: BridgeValue;
+}
+interface CryptoApi {
+  hashDigest(options: CryptoHashDigestOptions): string;
+  hmacDigest(options: CryptoHmacDigestOptions): void;
+  sign(options: CryptoSignOptions): void;
+  verify(options: CryptoVerifyOptions): void;
+  encrypt(options: CryptoCryptOptions): void;
+  decrypt(options: CryptoCryptOptions): void;
+  btoa(value: string): string;
+  atob(value: string): string;
+}
+interface CipherRSAOptions extends CallbackOptions {
+  action: string;
+  text: string;
+  key: string;
+  hashType?: string;
+}
+interface CipherVerifyOptions extends CallbackOptions {
+  text: string;
+  key: string;
+  hashType?: string;
+  signature: string;
+}
+interface CipherDigestOptions extends CallbackOptions {
+  hashType?: string;
+  text: string;
+}
+interface CipherMd5Options extends CallbackOptions {
+  text: string;
+}
+interface CipherAESOptions {
+  action: string;
+  text: string;
+  key: string;
+  iv: string;
+  ivOffset?: number;
+  ivLen?: number;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeCallback<[BridgeValue, number]>;
+  complete?: BridgeCallback;
+}
+interface CipherApi {
+  rsa(options: CipherRSAOptions): void;
+  sign(options: CipherRSAOptions): void;
+  verify(options: CipherVerifyOptions): void;
+  digest(options: CipherDigestOptions): void;
+  md5(options: CipherMd5Options): void;
+  aes(options: CipherAESOptions): void;
+}
+interface ProtobufType {
+  verify(message: BridgeValue): boolean;
+  encode(message: BridgeValue): BridgeValue;
+  decode(buffer: BridgeValue): BridgeValue;
+}
+interface ProtobufRoot {
+  readonly syntax: string;
+  lookupType(typeName: string): ProtobufType;
+}
+interface ProtobufLoadOptions {
+  filePath?: string;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface ProtobufApi {
+  load(options: ProtobufLoadOptions): Promise<{
+    root: ProtobufRoot;
+  }>;
+  release(root: ProtobufRoot): boolean;
+}
+interface MessageCodecApi {
+  verify(value: BridgeValue): boolean;
+  decode(value: BridgeValue): BridgeValue;
+  encode(value: BridgeValue): BridgeValue;
+}
+interface SensorCallbackOptions<T> {
+  reserved?: boolean;
+  interval?: string;
+  callback: BridgeCallback<[T]>;
+  fail?: BridgeFailCallback;
+}
+interface AccelerometerData {
+  x: number;
+  y: number;
+  z: number;
+}
+interface CompassData {
+  direction: number;
+}
+interface ProximityData {
+  distance?: number;
+  value?: BridgeValue;
+}
+interface LightData {
+  intensity?: number;
+  value?: BridgeValue;
+}
+interface ScalarSensorData {
+  value?: number;
+  accuracy?: number;
+  timestamp?: number;
+  [key: string]: BridgeValue;
+}
+interface GenericSensorSubscribeOptions {
+  type: number;
+  reserved?: boolean;
+  interval?: string;
+  callback: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+}
+interface SensorRecentDataOptions {
+  type: number;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface SensorApi {
+  subscribeAccelerometer(options: SensorCallbackOptions<AccelerometerData>): void;
+  unsubscribeAccelerometer(): void;
+  subscribeCompass(options: SensorCallbackOptions<CompassData>): void;
+  unsubscribeCompass(): void;
+  subscribeProximity(options: SensorCallbackOptions<ProximityData>): void;
+  unsubscribeProximity(): void;
+  subscribeLight(options: SensorCallbackOptions<LightData>): void;
+  unsubscribeLight(): void;
+  subscribeStepCounter(options: SensorCallbackOptions<ScalarSensorData>): void;
+  unsubscribeStepCounter(): void;
+  subscribePressure(options: SensorCallbackOptions<ScalarSensorData>): void;
+  unsubscribePressure(): void;
+  subscribeHumidity(options: SensorCallbackOptions<ScalarSensorData>): void;
+  unsubscribeHumidity(): void;
+  subscribeAmbientTemperature(options: SensorCallbackOptions<ScalarSensorData>): void;
+  unsubscribeAmbientTemperature(): void;
+  DATA_TYPES: BridgeValue;
+  subscribe(options: GenericSensorSubscribeOptions): number;
+  unsubscribe(subscriptionId: number): void;
+  getRecentData(options: SensorRecentDataOptions): void;
+  checkAvailable(sensorType: number): boolean;
+}
+interface GeolocationOptions {
+  timeout?: number;
+}
+interface LocationInfo {
+  longitude: number;
+  latitude: number;
+  altitude: number;
+  speed: number;
+  accuracy: number;
+  accuracyInfo: BridgeValue;
+}
+interface GeolocationApi {
+  getLocation(options?: GeolocationOptions): Promise<LocationInfo>;
+  subscribe(options: {
+    callback: BridgeCallback<[LocationInfo]>;
+    fail?: BridgeFailCallback;
+  }): void;
+  unsubscribe(): void;
+}
+interface VibrateOptions {
+  mode?: string;
+}
+interface VibrateStartOptions {
+  duration?: number;
+  interval?: number;
+  count?: number;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface VibratorApi {
+  vibrate(options?: VibrateOptions): void;
+  start(options: VibrateStartOptions): void;
+  stop(vibrationId: number): boolean;
+  getSystemDefaultMode(): number;
+}
+interface FileCallbacks<T = string> {
+  success?: BridgeCallback<[T]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface FileMoveOptions extends FileCallbacks {
+  srcUri: string;
+  dstUri: string;
+}
+interface FileListOptions extends FileCallbacks<{
+  fileList: BridgeValue[];
+}> {
+  uri: string;
+}
+interface FileGetOptions extends FileCallbacks<BridgeValue> {
+  uri: string;
+  recursive?: boolean;
+}
+interface FileUriOptions extends FileCallbacks<void> {
+  uri: string;
+}
+interface FileWriteTextOptions extends FileCallbacks<void> {
+  uri: string;
+  text: string;
+  encoding?: string;
+  append?: boolean;
+}
+interface FileWriteArrayBufferOptions extends FileCallbacks<void> {
+  uri: string;
+  buffer: BridgeValue;
+  position?: number;
+  append?: boolean;
+}
+interface FileReadTextOptions extends FileCallbacks<BridgeValue> {
+  uri: string;
+  encoding?: string;
+}
+interface FileReadArrayBufferOptions extends FileCallbacks<BridgeValue> {
+  uri: string;
+  position?: number;
+  length?: number;
+}
+interface FileMkdirOptions extends FileCallbacks<void> {
+  uri: string;
+  recursive?: boolean;
+}
+interface FileApi {
+  move(options: FileMoveOptions): void;
+  copy(options: FileMoveOptions): void;
+  list(options: FileListOptions): void;
+  get(options: FileGetOptions): void;
+  delete(options: FileUriOptions): void;
+  writeText(options: FileWriteTextOptions): void;
+  writeArrayBuffer(options: FileWriteArrayBufferOptions): void;
+  readText(options: FileReadTextOptions): void;
+  readArrayBuffer(options: FileReadArrayBufferOptions): void;
+  access(options: FileUriOptions): void;
+  mkdir(options: FileMkdirOptions): void;
+  rmdir(options: FileMkdirOptions): void;
+}
+interface ZipApi {
+  decompress(options: {
+    srcUri: string;
+    dstUri: string;
+    success?: BridgeCallback;
+    fail?: BridgeFailCallback;
+    complete?: BridgeCallback;
+  }): void;
+}
+interface ZlibApi {
+  decompressSync(compressedData: BridgeValue): BridgeValue;
+}
+interface ServiceClientConnectOptions {
+  name: string;
+  package?: string;
+  params?: BridgeValue;
+  policy?: string;
+}
+interface ServiceInstance {
+  postMessage(message: BridgeValue): void;
+  disconnect(): void;
+  onmessage(callback: BridgeCallback<[string]>): void;
+  onerror(callback: BridgeCallback<[number]>): void;
+}
+interface ServiceClientApi {
+  connect(options: ServiceClientConnectOptions): ServiceInstance;
+}
+interface SystemEventApi {
+  publish(options: {
+    eventName: string;
+    options?: BridgeValue;
+  }): void;
+  subscribe(options: {
+    eventName: string;
+    callback: BridgeCallback<[BridgeValue]>;
+  }): BridgeValue;
+  unsubscribe(options: {
+    id: number;
+  }): void;
+}
+interface DeviceInfo {
+  brand?: string;
+  manufacturer?: string;
+  model?: string;
+  product?: string;
+  osType?: string;
+  osVersionName?: string;
+  osVersionCode?: number;
+  platformVersionName?: string;
+  platformVersionCode?: number;
+  screenWidth?: number;
+  screenHeight?: number;
+  windowWidth?: number;
+  windowHeight?: number;
+  statusBarHeight?: number;
+  [key: string]: BridgeValue;
+}
+interface DeviceCommonOptions extends CallbackOptions {}
+interface DeviceApi {
+  getInfo(options: CallbackOptions<DeviceInfo>): void;
+  getSystemUptime(): Promise<{
+    systemUptime: number;
+  }>;
+  getDeviceId(options?: DeviceCommonOptions): string;
+  getId(options: DeviceCommonOptions): void;
+  getSerial(options: DeviceCommonOptions): void;
+  getTotalStorage(options: DeviceCommonOptions): void;
+  getAvailableStorage(options: DeviceCommonOptions): void;
+}
+interface FolmeAnimationOptions {
+  id: string;
+  fromState?: BridgeValue;
+  toState?: BridgeValue;
+  config?: BridgeValue;
+  onUpdate?: BridgeCallback;
+  onComplete?: BridgeCallback;
+}
+interface FolmeApi {
+  to(options: Omit<FolmeAnimationOptions, "fromState">): void;
+  setTo(options: Omit<FolmeAnimationOptions, "fromState" | "onUpdate" | "onComplete">): void;
+  fromTo(options: FolmeAnimationOptions): void;
+  startGroup(options: FolmeAnimationOptions[]): void;
+  cancel(options: {
+    id: string;
+    attrs?: BridgeValue;
+  }): void;
+  getState(options: {
+    id: string;
+    attr: string;
+  }): {
+    value: string;
+    isFinished: boolean;
+    speed: number;
+  };
+}
+interface VolumeValue {
+  value: number;
+}
+interface VolumeApi {
+  onMediaValueChanged(callback: BridgeCallback<[VolumeValue]>): void;
+  setMediaValue(options: {
+    value: number;
+    success?: BridgeCallback<[VolumeValue]>;
+    fail?: BridgeFailCallback;
+    complete?: BridgeCallback<[string]>;
+  }): void;
+  getMediaValue(options: {
+    success?: BridgeCallback<[VolumeValue]>;
+    fail?: BridgeFailCallback;
+    complete?: BridgeCallback<[string]>;
+  }): void;
+}
+interface AudioMetaInfo {
+  title?: string;
+  album?: string;
+  artist?: string;
+  [key: string]: BridgeValue;
+}
+interface AudioState {
+  state?: string;
+  currentTime?: number;
+  duration?: number;
+  [key: string]: BridgeValue;
+}
+interface AudioApi {
+  src: string;
+  meta: AudioMetaInfo;
+  currentTime: number;
+  readonly duration: number;
+  autoplay: boolean;
+  loop: boolean;
+  volume: number;
+  muted: boolean;
+  readonly streamType: string;
+  readonly percent: number;
+  play(): void;
+  pause(): void;
+  stop(): void;
+  getPlayState(options: CallbackOptions<AudioState>): void;
+  onplay?: BridgeCallback;
+  onpause?: BridgeCallback;
+  onstop?: BridgeCallback;
+  onloadeddata?: BridgeCallback;
+  onended?: BridgeCallback;
+  ondurationchange?: BridgeCallback;
+  ontimeupdate?: BridgeCallback;
+  onerror?: BridgeCallback;
+  onctrlplayprev?: BridgeCallback;
+  onctrlplaynext?: BridgeCallback;
+}
+interface MediaSessionFeedback {
+  success?: BridgeCallback<[string]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface MediaSession {
+  start(options: MediaSessionFeedback): void;
+  pause(options: MediaSessionFeedback): void;
+  stop(options: MediaSessionFeedback): void;
+  prev(options: MediaSessionFeedback): void;
+  next(options: MediaSessionFeedback): void;
+  increaseVolume(options: MediaSessionFeedback): void;
+  decreaseVolume(options: MediaSessionFeedback): void;
+  onEvent?: BridgeCallback<[string]>;
+}
+interface MediaSessionApi {
+  createSession(name: string): MediaSession;
+}
+interface RecordStartOptions {
+  duration?: number;
+  sampleRate?: number;
+  numberOfChannels?: number;
+  encodeBitRate?: number;
+  frameSize?: number;
+  format?: string;
+  success?: BridgeCallback<[BridgeValue]>;
+  fail?: BridgeFailCallback;
+  complete?: BridgeCallback;
+}
+interface RecordApi {
+  onframerecorded(callback: BridgeCallback<[BridgeValue]>): void;
+  start(options: RecordStartOptions): void;
+  stop(): void;
+}
+interface DebugApi {
+  enable(): Promise<number>;
+  disable(): Promise<number>;
+  getStatus(): Promise<number>;
+}
+interface PowerApi {
+  shutDown(options?: CallbackOptions<string>): void;
+  reboot(options?: CallbackOptions<string>): void;
+}
+interface PackageInfo {
+  packageName: string;
+  name: string;
+  icon: string;
+  installedPath: string;
+  manifest: string;
+  appType: string;
+  version: string;
+  installTime: string;
+  appSize?: number;
+  extra?: string;
+}
+interface PackageApi {
+  getAllPackageInfo(): PackageInfo[];
+  getPackageInfo(packageName: string): PackageInfo;
+  clearAppCache(packageName: string): number;
+  installPackage(options: {
+    path: string;
+    isForce?: boolean;
+    progress?: BridgeCallback<[string, number]>;
+    result?: BridgeCallback<[string, number, string]>;
+  }): void;
+  uninstallPackage(options: {
+    packageName: string;
+    isClearCache?: boolean;
+    result?: BridgeCallback<[string, number, string]>;
+  }): void;
+}
+interface ActivityApi {
+  startActivity(abilityName: string, params?: BridgeValue): number;
+  stopActivity(abilityName: string): number;
+  startService(serviceName: string, params?: BridgeValue): number;
+  stopService(serviceName: string): number;
+  bindService(serviceName: string, params: BridgeValue, connection: {
+    connectCallBack: BridgeCallback;
+    disconnectCallBack: BridgeCallback;
+  }): number;
+  unbindService(connectionId: number): void;
+  moveToBackground(enabled: boolean): boolean;
+}
+interface MessageChannelApi {
+  sendMessage(target: string, message: string): Promise<string>;
+  reply(requestId: number, message: string): void;
+  setReceiveRequestCallback(topic: string, callback: BridgeCallback<[number, string]>): void;
+  notifyMessage(topic: string, message: string): void;
+  setTopicListener(topic: string, callback: BridgeCallback<[string, string]>): void;
+  unsetTopicListener(topic: string): void;
+  unsetTopicListenerCb(topic: string, callback: BridgeCallback<[string, string]>): void;
+  createSession(peer: string): Promise<number>;
+  sessionSend(sessionId: number, message: string): void;
+  sessionClose(sessionId: number): void;
+  acceptSession(sessionId: number): void;
+  sessionOnData(sessionId: number, callback: BridgeCallback<[string]>): void;
+  readonly SESSION_REASON_CLOSE: 0;
+  readonly SESSION_REASON_CLOSE_PEER: 1;
+  readonly SESSION_REASON_PEER_SHUTDOWN: 2;
+  sessionOnClose(sessionId: number, callback: BridgeCallback<[number]>): void;
+  sessionOnReceive(topic: string, callback: BridgeCallback<[number, string]>): void;
+  print(message: string): void;
+}
+interface InterconnectReadyState {
+  status: 1 | 2 | number;
+}
+interface InterconnectDiagnosisResult {
+  status: 0 | 204 | 1000 | 1001 | number;
+}
+interface InterconnectError {
+  data?: string;
+  code?: number;
+  [key: string]: BridgeValue;
+}
+interface InterconnectMessage {
+  data?: BridgeValue;
+  status?: number;
+  isReconnected?: boolean;
+  code?: number;
+  [key: string]: BridgeValue;
+}
+interface InterconnectConnect {
+  getReadyState(options?: {
+    success?: BridgeCallback<[InterconnectReadyState]>;
+    fail?: BridgeCallback<[string | InterconnectError, number]>;
+  }): void;
+  diagnosis(options?: {
+    timeout?: number;
+    success?: BridgeCallback<[InterconnectDiagnosisResult]>;
+    fail?: BridgeCallback<[string | InterconnectError, number]>;
+  }): void;
+  send(options: {
+    data: Record<string, BridgeValue>;
+    success?: BridgeCallback;
+    fail?: BridgeCallback<[string | InterconnectError, number]>;
+  }): void;
+  onmessage?: BridgeCallback<[InterconnectMessage]>;
+  onopen?: BridgeCallback<[InterconnectMessage]>;
+  onclose?: BridgeCallback<[InterconnectMessage]>;
+  onerror?: BridgeCallback<[InterconnectMessage]>;
+}
+interface InterconnectApi {
+  instance(): InterconnectConnect;
+}
+interface BatteryStatus {
+  charging: boolean;
+  level: number;
+}
+interface BatteryApi {
+  getStatus(options?: CallbackOptions<BatteryStatus>): void;
+}
+interface BrightnessValue {
+  value: number;
+}
+interface BrightnessMode {
+  mode: 0 | 1 | number;
+}
+interface BrightnessApi {
+  getValue(options?: CallbackOptions<BrightnessValue>): void;
+  setValue(options: {
+    value: number;
+  } & CallbackOptions<void>): void;
+  getMode(options?: CallbackOptions<BrightnessMode>): void;
+  setMode(options: {
+    mode: 0 | 1 | number;
+  } & CallbackOptions<void>): void;
+  setKeepScreenOn(options: {
+    keepScreenOn: boolean;
+  } & CallbackOptions<void>): void;
+}
+type BLEAddressType = "PUBLIC" | "RANDOM" | "ANONYMOUS" | "UNKNOWN";
+interface BLEScanFilter {
+  deviceId?: string;
+  name?: string;
+  serviceUuid?: string;
+}
+interface BLEScanOptions {
+  dutyMode?: number;
+}
+interface BLEScanResult {
+  deviceId: string;
+  name?: string;
+  serviceUuid?: string;
+  rssi?: number;
+  addressType?: BLEAddressType | string;
+  [key: string]: BridgeValue;
+}
+interface BLEStartScanOptions extends CallbackOptions<void> {
+  filters: BLEScanFilter[];
+  options?: BLEScanOptions;
+}
+interface BLEScanStateResult {
+  scanState: number;
+}
+interface BLEScanner {
+  startBLEScan(options: BLEStartScanOptions): void;
+  stopBLEScan(): void;
+  getScanState(options?: CallbackOptions<BLEScanStateResult>): void;
+  subscribeBLEDeviceFind(options?: {
+    callback?: BridgeCallback<[BLEScanResult[]]>;
+    fail?: BridgeFailCallback;
+  }): number;
+  unsubscribeBLEDeviceFind(subscribeId: number): void;
+  close(): void;
+}
+interface BLEGattService {
+  uuid?: string;
+  isPrimary?: boolean;
+  [key: string]: BridgeValue;
+}
+interface BLEGattCharacteristic {
+  serviceUuid?: string;
+  characteristicUuid?: string;
+  value?: BridgeValue;
+  properties?: BridgeValue;
+  [key: string]: BridgeValue;
+}
+interface BLEGattDescriptor {
+  serviceUuid?: string;
+  characteristicUuid?: string;
+  descriptorUuid?: string;
+  value?: BridgeValue;
+  [key: string]: BridgeValue;
+}
+interface BLEGattOptions<T = void> extends CallbackOptions<T> {
+  serviceUuid?: string;
+  characteristicUuid?: string;
+  descriptorUuid?: string;
+  value?: BridgeValue;
+  mtu?: number;
+  enable?: boolean;
+}
+interface BLEGattClientDevice {
+  connect(options?: CallbackOptions<void>): void;
+  disconnect(options?: CallbackOptions<void>): void;
+  close(): void;
+  getServices(options?: CallbackOptions<{
+    services: BLEGattService[];
+  }>): void;
+  readCharacteristicValue(options: BLEGattOptions<{
+    characteristic: BLEGattCharacteristic;
+  }>): void;
+  readDescriptorValue(options: BLEGattOptions<{
+    descriptor: BLEGattDescriptor;
+  }>): void;
+  writeCharacteristicValue(options: BLEGattOptions<void>): void;
+  writeDescriptorValue(options: BLEGattOptions<void>): void;
+  setBLEMtuSize(options: BLEGattOptions<void>): void;
+  setNotifyCharacteristicChanged(options: BLEGattOptions<void>): void;
+  getDeviceName(options?: CallbackOptions<{
+    name: string;
+  }>): void;
+  getRssiValue(options?: CallbackOptions<{
+    rssi: number;
+  }>): void;
+  onBLECharacteristicChange?: BridgeCallback<[BLEGattCharacteristic]>;
+  onBLEConnectionStateChange?: BridgeCallback<[BridgeValue]>;
+}
+interface BluetoothBLEApi {
+  createScanner(): BLEScanner;
+  createGattClientDevice(deviceId: string, addressType?: BLEAddressType): BLEGattClientDevice;
+}
+declare const ScanDuty: {
+  readonly SCAN_MODE_LOW_POWER: 0;
+  readonly SCAN_MODE_BALANCED: 1;
+  readonly SCAN_MODE_LOW_LATENCY: 2;
+};
+declare const ScanState: {
+  readonly STATE_NON_SCAN: 0;
+  readonly STATE_SCANING: 1;
+};
+interface JumpAppApi {
+  jumpApp(packageName: string, paramsOrPath?: string): void;
+  launchQuickApp(packageName: string): void;
+}
+interface VelaApi {
+  locale: {
+    get(): LocaleInfo;
+  };
+  exchange: ExchangeApi;
+  crypto: CryptoApi;
+  configuration: {
+    getLocale(): LocaleInfo;
+  };
+  zlib: ZlibApi;
+  serviceclient: ServiceClientApi;
+  event: SystemEventApi;
+  folme: FolmeApi;
+  volume: VolumeApi;
+  mediaSession: MediaSessionApi;
+  protobuf: ProtobufApi;
+  mqttmessage: MessageCodecApi;
+  debug: DebugApi;
+  interconnect: InterconnectApi;
+  battery: BatteryApi;
+  brightness: BrightnessApi;
+  bluetoothBLE: BluetoothBLEApi;
+  jumpApp: JumpAppApi;
+  internals: VelaInternalsApi;
+}
+interface SystemApi {
+  app: AppApi;
+  prompt: PromptApi;
+  router: RouterApi;
+  storage: StorageApi;
+  network: NetworkApi;
+  cipher: CipherApi;
+  sensor: SensorApi;
+  geolocation: GeolocationApi;
+  vibrator: VibratorApi;
+  file: FileApi;
+  zip: ZipApi;
+  device: DeviceApi;
+  audio: AudioApi;
+  record: RecordApi;
+  vela: VelaApi;
+}
+interface VelaInternalsApi {
+  power: PowerApi;
+  package: PackageApi;
+  activity: ActivityApi;
+  messageChannel: MessageChannelApi;
+}
+declare const router: RouterApi;
+declare const app: AppApi;
+declare const prompt: PromptApi;
+declare const network: NetworkApi;
+declare const storage: StorageApi;
+declare const cipher: CipherApi;
+declare const sensor: SensorApi;
+declare const geolocation: GeolocationApi;
+declare const vibrator: VibratorApi;
+declare const file: FileApi;
+declare const zip: ZipApi;
+declare const device: DeviceApi;
+declare const audio: AudioApi;
+declare const record: RecordApi;
+declare const velaLocale: {
+  get(): LocaleInfo;
+};
+declare const velaExchange: ExchangeApi;
+declare const velaCrypto: CryptoApi;
+declare const velaConfiguration: {
+  getLocale(): LocaleInfo;
+};
+declare const velaZlib: ZlibApi;
+declare const velaServiceClient: ServiceClientApi;
+declare const velaEvent: SystemEventApi;
+declare const velaFolme: FolmeApi;
+declare const velaVolume: VolumeApi;
+declare const velaMediaSession: MediaSessionApi;
+declare const velaProtobuf: ProtobufApi;
+declare const velaMqttMessage: MessageCodecApi;
+declare const velaDebug: DebugApi;
+declare const velaInterconnect: InterconnectApi;
+declare const velaBattery: BatteryApi;
+declare const velaBrightness: BrightnessApi;
+declare const velaBluetoothBLE: BluetoothBLEApi;
+declare const velaJumpApp: JumpAppApi;
+declare const velaInternals: VelaInternalsApi;
+declare const VelaInternals: VelaInternalsApi;
+declare const vela: VelaApi;
+declare const system: SystemApi;
+//#endregion
+export { AccelerometerData, ActivityApi, AppApi, AppInfo, AppSource, AudioApi, AudioMetaInfo, AudioState, BLEAddressType, BLEGattCharacteristic, BLEGattClientDevice, BLEGattDescriptor, BLEGattOptions, BLEGattService, BLEScanFilter, BLEScanOptions, BLEScanResult, BLEScanStateResult, BLEScanner, BLEStartScanOptions, BatteryApi, BatteryStatus, BluetoothBLEApi, BridgeCallback, BridgeFailCallback, BridgeValue, BrightnessApi, BrightnessMode, BrightnessValue, CallbackOptions, CipherAESOptions, CipherApi, CipherDigestOptions, CipherMd5Options, CipherRSAOptions, CipherVerifyOptions, CompassData, CryptoApi, CryptoCryptOptions, CryptoHashDigestOptions, CryptoHmacDigestOptions, CryptoSignOptions, CryptoVerifyOptions, DebugApi, DeviceApi, DeviceCommonOptions, DeviceInfo, DownloadCompleteOptions, DownloadCompleteSuccess, DownloadNotifyData, DownloadOptions, DownloadSuccess, ExchangeApi, ExchangeOptions, FetchOptions, FileApi, FileCallbacks, FileGetOptions, FileListOptions, FileMkdirOptions, FileMoveOptions, FileReadArrayBufferOptions, FileReadTextOptions, FileUriOptions, FileWriteArrayBufferOptions, FileWriteTextOptions, FolmeAnimationOptions, FolmeApi, GenericSensorSubscribeOptions, GeolocationApi, GeolocationOptions, InterconnectApi, InterconnectConnect, InterconnectDiagnosisResult, InterconnectError, InterconnectMessage, InterconnectReadyState, JumpAppApi, LightData, LocaleInfo, LocationInfo, MediaSession, MediaSessionApi, MediaSessionFeedback, MessageChannelApi, MessageCodecApi, NetworkApi, NetworkType, NetworkTypeInfo, PackageApi, PackageInfo, PowerApi, PromptApi, PromptDialogOptions, PromptDialogResult, PromptToastOptions, ProtobufApi, ProtobufLoadOptions, ProtobufRoot, ProtobufType, ProximityData, RecordApi, RecordStartOptions, RouteObject, RouteStack, RouteState, RouterApi, RouterBackOptions, ScalarSensorData, ScanDuty, ScanState, SensorApi, SensorCallbackOptions, SensorRecentDataOptions, ServiceClientApi, ServiceClientConnectOptions, ServiceInstance, StorageApi, StorageDeleteOptions, StorageGetOptions, StorageKeyOptions, StorageSetOptions, SystemApi, SystemEventApi, UploadFileOptions, UploadProgress, UploadSuccess, UploadTask, VelaApi, VelaInternals, VelaInternalsApi, VibrateOptions, VibrateStartOptions, VibratorApi, VolumeApi, VolumeValue, ZipApi, ZlibApi, app, audio, cipher, device, file, geolocation, network, prompt, record, router, sensor, storage, system, vela, velaBattery, velaBluetoothBLE, velaBrightness, velaConfiguration, velaCrypto, velaDebug, velaEvent, velaExchange, velaFolme, velaInterconnect, velaInternals, velaJumpApp, velaLocale, velaMediaSession, velaMqttMessage, velaProtobuf, velaServiceClient, velaVolume, velaZlib, vibrator, zip };