@stacksjs/desktop 0.2.20 → 0.2.24

package/dist/_bridge.d.ts

@@ -0,0 +1,105 @@
+/** True when `window.craft.<ns>` exists. Cheap; do not memoize. */
+export declare function hasBridge(ns: string): boolean;
+/**
+ * Get the bridge namespace, or throw a clear error if it isn't there.
+ * Use this in the rare case where a sensible web fallback doesn't exist
+ * (e.g. system-level battery info). For everything else, prefer
+ * `hasBridge` + manual fallback so the call works in browsers too.
+ */
+export declare function requireBridge<T = Record<string, any>>(ns: string): T;
+/**
+ * Subscribe to a `craft:*` window event with auto-detached cleanup.
+ *
+ * Two overloads:
+ * - **Known event** (string literal in `CraftEventMap`): `detail` is
+ *   typed to the matching payload, no generic argument needed.
+ * - **Custom event** (any other name): pass an explicit `T` to type
+ *   the payload yourself, or default to `unknown`.
+ */
+export declare function onCraftEvent<K extends keyof CraftEventMap>(name: K, cb: (detail: CraftEventMap[K]) => void): () => void;
+export declare function onCraftEvent<T = unknown>(name: string, cb: (detail: T) => void): () => void;
+/**
+ * Central index of every `craft:*` event the SDK currently knows about,
+ * mapped to its payload shape. Apps that subscribe via `onCraftEvent`
+ * with a literal name get fully-typed `detail` automatically — no
+ * `<unknown>` casts. Internal modules also use the map to keep their
+ * own `onXxx` callbacks honest.
+ *
+ * When adding a new event name on the native side, add a row here so
+ * the public TS surface stays in sync.
+ */
+export declare interface CraftEventMap {
+  'craft:powerSleep': void
+  'craft:powerWake': void
+  'craft:networkChange': { type: import('./network').ConnectionType, online: boolean }
+  'craft:screen:change': void
+  'craft:theme': import('./theme').ThemeInfo
+  'craft:bluetooth:deviceFound': import('./bluetooth').BluetoothDevice
+  'craft:bluetooth:deviceConnected': import('./bluetooth').BluetoothDevice
+  'craft:bluetooth:deviceDisconnected': import('./bluetooth').BluetoothDevice
+  'craft:bluetooth:characteristicValue': import('./bluetooth').BluetoothCharacteristicValueEvent
+  'craft:bonjour:found': import('./bonjour').BonjourService
+  'craft:bonjour:lost': import('./bonjour').BonjourService
+  'craft:deepLink': import('./deep-link').DeepLinkEvent
+  'craft:fs:change': import('./fs').FSChangeEvent
+  'craft:shortcut': import('./global-shortcuts').ShortcutFireEvent
+  'craft:handoff:incoming': import('./handoff').HandoffIncomingEvent
+  'craft:iap:purchased': import('./iap').IAPTransactionEvent
+  'craft:iap:failed': import('./iap').IAPFailureEvent
+  'craft:iap:restored': import('./iap').IAPTransactionEvent
+  'craft:iap:productsLoaded': { products?: import('./iap').IAPProduct[] }
+  'craft:iap:refunded': import('./iap').IAPRefundEvent
+  'craft:iap:subscriptionStatusChanged': import('./iap').IAPSubscriptionStatusEvent
+  'craft:localServer:request': import('./local-server').LocalServerRequestEvent
+  'craft:location:update': import('./location').LocationCoordinate
+  'craft:location:error': { message: string }
+  'craft:location:authChanged': { status: import('./location').LocationAuthStatus }
+  'craft:menu:action': import('./menu').MenuActionEvent
+  'craft:midi:message': import('./midi').MIDIMessageEvent
+  'craft:notification:actionClicked': import('./notifications').NotificationActionEvent
+  'craft:notification:reply': import('./notifications').NotificationReplyEvent
+  'craft:serial:data': import('./serial').SerialDataEvent
+  'craft:serviceMenu:invoked': import('./service-menu').ServiceMenuInvokedEvent
+  'craft:shell:stdout': import('./shell').ShellOutputEvent
+  'craft:shell:stderr': import('./shell').ShellOutputEvent
+  'craft:shell:exit': import('./shell').ShellExitEvent
+  'craft:speechRecognition:partial': { transcript: string }
+  'craft:speechRecognition:final': { transcript: string }
+  'craft:touchbar:action': import('./touchbar').TouchBarActionEvent
+  'craft:updateAvailable': import('./updater').UpdateInfo
+  'craft:updateDownloaded': import('./updater').UpdateInfo
+  'craft:window:focus': void
+  'craft:window:blur': void
+  'craft:window:resize': import('./window-events').WindowSize
+  'craft:window:move': import('./window-events').WindowPosition
+  'craft:window:close': void
+  'craft:window:minimize': void
+  'craft:window:restore': void
+  'craft:tray:menu': { id?: string }
+}
+/**
+ * Shared internals for craft bridge wrappers.
+ *
+ * Every public module in this package follows the same shape:
+ *   1. Detect whether `window.craft.<namespace>` is available.
+ *   2. Forward to it when running inside a Craft native window.
+ *   3. Fall back gracefully (or refuse with a clear error) elsewhere.
+ *
+ * Centralising these helpers keeps the per-module wrappers small and
+ * means a future bridge-detection change (e.g. version negotiation)
+ * lives in exactly one place.
+ *
+ * Internal — not re-exported from index.ts. Apps that want to call the
+ * bridge directly should use the namespaced public modules.
+ */
+// Augment the global window type so callers can import from this module
+// without each one redeclaring `(window as any).craft`. Kept as a loose
+// shape because the bridge is built from the Zig side and we don't want
+// the TS layer to drift out of sync if a single field renames.
+declare global {
+  interface Window {
+  craft?: Record<string, any>
+  __craftPendingDeepLink?: string
+  __craftCurrentTheme?: { appearance: 'light' | 'dark' }
+}
+}

package/dist/app-info.d.ts

@@ -0,0 +1,22 @@
+export declare const app: AppAPI;
+export declare interface AppInfo {
+  name: string
+  version: string
+  bundleId?: string
+  bundlePath?: string
+  executablePath?: string
+}
+export declare interface AppNotifyOptions {
+  title: string
+  body?: string
+  sound?: string
+}
+export declare interface AppAPI {
+  hideDockIcon: () => Promise<void>
+  showDockIcon: () => Promise<void>
+  quit: () => Promise<void>
+  getInfo: () => Promise<AppInfo>
+  notify: (options: AppNotifyOptions) => Promise<void>
+  setBadge: (count: number) => Promise<void>
+  bounce: (type?: 'critical' | 'informational') => Promise<void>
+}

package/dist/apple-script.d.ts

@@ -0,0 +1,8 @@
+export declare const appleScript: AppleScriptAPI;
+export declare interface AppleScriptResult {
+  ok: boolean
+  result?: string
+}
+export declare interface AppleScriptAPI {
+  execute: (source: string) => Promise<AppleScriptResult>
+}

package/dist/audio.d.ts

@@ -0,0 +1,17 @@
+export declare const audio: AudioAPI;
+export declare interface AudioPlayOptions {
+  volume?: number
+  loops?: boolean
+}
+export declare interface AudioRecordOptions {
+  maxDurationSec?: number
+}
+export declare interface AudioAPI {
+  play: (path: string, options?: AudioPlayOptions) => Promise<boolean>
+  playSystemSound: (name: string) => Promise<boolean>
+  stop: () => Promise<void>
+  isPlaying: () => Promise<boolean>
+  startRecording: (path: string, options?: AudioRecordOptions) => Promise<boolean>
+  stopRecording: () => Promise<void>
+  isRecording: () => Promise<boolean>
+}

package/dist/battery.d.ts

@@ -0,0 +1,15 @@
+export declare const battery: BatteryAPI;
+export declare interface BatteryAPI {
+  isCharging: () => Promise<boolean>
+  isPluggedIn: () => Promise<boolean>
+  isLowPowerMode: () => Promise<boolean>
+  level: () => Promise<number | null>
+  timeRemaining: () => Promise<number | null>
+  thermalState: () => Promise<ThermalState>
+  uptimeSeconds: () => Promise<number>
+  preventSleep: (reason?: string) => Promise<void>
+  allowSleep: () => Promise<void>
+  onSleep: (cb: () => void) => () => void
+  onWake: (cb: () => void) => () => void
+}
+export type ThermalState = 'nominal' | 'fair' | 'serious' | 'critical' | 'unknown';

package/dist/biometric.d.ts

@@ -0,0 +1,14 @@
+export declare const biometric: BiometricAPI;
+export declare interface BiometricEvaluateOptions {
+  allowPasscodeFallback?: boolean
+}
+export declare interface BiometricEvaluateResult {
+  success: boolean
+  errorCode?: number
+}
+export declare interface BiometricAPI {
+  isAvailable: () => Promise<boolean>
+  getBiometryType: () => Promise<BiometryType>
+  evaluate: (reason: string, options?: BiometricEvaluateOptions) => Promise<BiometricEvaluateResult>
+}
+export type BiometryType = 'none' | 'touchID' | 'faceID' | 'opticID';

package/dist/bluetooth.d.ts

@@ -0,0 +1,52 @@
+export declare const bluetooth: BluetoothAPI;
+export declare interface BluetoothDevice {
+  id: string
+  name: string
+  connected: boolean
+  rssi?: number
+  manufacturer?: string
+}
+export declare interface BluetoothService {
+  uuid: string
+  primary?: boolean
+}
+export declare interface BluetoothCharacteristic {
+  uuid: string
+  serviceUuid: string
+  properties?: Array<'read' | 'write' | 'writeWithoutResponse' | 'notify' | 'indicate' | 'broadcast' | 'authenticatedSignedWrites' | 'extendedProperties'>
+}
+export declare interface BluetoothCharacteristicValueEvent {
+  deviceId: string
+  serviceUuid: string
+  characteristicUuid: string
+  valueHex: string
+}
+export declare interface BluetoothAPI {
+  isEnabled: () => Promise<boolean>
+  powerState: () => Promise<BluetoothPowerState>
+  connectedDevices: () => Promise<BluetoothDevice[]>
+  pairedDevices: () => Promise<BluetoothDevice[]>
+  startDiscovery: () => Promise<void>
+  stopDiscovery: () => Promise<void>
+  isDiscovering: () => Promise<boolean>
+  connect: (id: string) => Promise<void>
+  disconnect: (id: string) => Promise<void>
+  openPreferences: () => Promise<void>
+  discoverServices: (deviceId: string) => Promise<BluetoothService[]>
+  discoverCharacteristics: (deviceId: string, serviceUuid: string) => Promise<BluetoothCharacteristic[]>
+  readCharacteristic: (deviceId: string, serviceUuid: string, characteristicUuid: string) => Promise<{ ok: boolean, valueHex?: string, reason?: string }>
+  writeCharacteristic: (
+    deviceId: string,
+    serviceUuid: string,
+    characteristicUuid: string,
+    valueHex: string,
+    mode?: BluetoothWriteMode,
+  ) => Promise<{ ok: boolean, reason?: string }>
+  setCharacteristicNotify: (deviceId: string, serviceUuid: string, characteristicUuid: string, on: boolean) => Promise<{ ok: boolean, reason?: string }>
+  onDeviceFound: (cb: (device: BluetoothDevice) => void) => () => void
+  onDeviceConnected: (cb: (device: BluetoothDevice) => void) => () => void
+  onDeviceDisconnected: (cb: (device: BluetoothDevice) => void) => () => void
+  onCharacteristicValue: (cb: (event: BluetoothCharacteristicValueEvent) => void) => () => void
+}
+export type BluetoothPowerState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
+export type BluetoothWriteMode = 'with-response' | 'without-response';

package/dist/bonjour.d.ts

@@ -0,0 +1,13 @@
+export declare const bonjour: BonjourAPI;
+export declare interface BonjourService {
+  name: string
+  host?: string
+  port?: number
+  type: string
+}
+export declare interface BonjourAPI {
+  browse: (serviceType: string) => Promise<{ started: boolean, reason?: string }>
+  stop: () => Promise<void>
+  onFound: (cb: (service: BonjourService) => void) => () => void
+  onLost: (cb: (service: BonjourService) => void) => () => void
+}

package/dist/capabilities.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Snapshot of every known bridge's availability on the current host.
+ * Re-call after the bridge IIFE loads (e.g. `DOMContentLoaded`) — the
+ * `available` field is computed against `window.craft` at call time.
+ */
+export declare function getCapabilities(): BridgeCapability[];
+/**
+ * Lookup a single capability by name. Returns `undefined` for bridges
+ * the SDK doesn't know about.
+ */
+export declare function getCapability(name: string): BridgeCapability | undefined;
+/**
+ * Convenience predicate — `true` when a bridge is *both* known to the
+ * SDK and currently reachable.
+ */
+export declare function isAvailable(name: string): boolean;
+export declare interface BridgeCapability {
+  name: string
+  support: BridgePlatformSupport
+  available: boolean
+}
+/**
+ * The set of bridges the SDK knows about, plus the platforms each is
+ * implemented on. Used to power the `capabilities` map and to drive
+ * docs / tooling.
+ *
+ * `'all'` means the bridge has a working web/non-bridge fallback too;
+ * `'macos'` means it requires a Craft macOS host; `'native'` means it
+ * needs *some* Craft host (mac/linux/windows) but has no web fallback.
+ */
+export type BridgePlatformSupport = 'all' | 'native' | 'macos';

package/dist/clipboard.d.ts

@@ -0,0 +1,11 @@
+export declare const clipboard: Clipboard;
+export declare interface Clipboard {
+  writeText: (text: string) => Promise<void>
+  readText: () => Promise<string>
+  writeHTML: (html: string) => Promise<void>
+  readHTML: () => Promise<string>
+  clear: () => Promise<void>
+  hasText: () => Promise<boolean>
+  hasHTML: () => Promise<boolean>
+  hasImage: () => Promise<boolean>
+}

package/dist/continuity-camera.d.ts

@@ -0,0 +1,10 @@
+export declare const continuityCamera: ContinuityCameraAPI;
+export declare interface ContinuityCameraDevice {
+  id: string
+  name: string
+  manufacturer: string
+  isContinuity: boolean
+}
+export declare interface ContinuityCameraAPI {
+  listCameras: () => Promise<ContinuityCameraDevice[]>
+}

package/dist/coreml.d.ts

@@ -0,0 +1,6 @@
+export declare const coreml: CoreMLAPI;
+export declare interface CoreMLAPI {
+  loadModel: (id: string, path: string) => Promise<boolean>
+  unloadModel: (id: string) => Promise<void>
+  predict: (id: string, input: Record<string, unknown>) => Promise<unknown>
+}

package/dist/crash-reporter.d.ts

@@ -0,0 +1,46 @@
+/** Default redactor — replaces emails, IPv4s, and home paths with placeholders. */
+export declare function redactPII(entry: StoredCrashEntry): StoredCrashEntry;
+/** Sign `body` with HMAC-SHA256 + `secret`. Returns lowercase hex. */
+export declare function signPayload(secret: string, body: string): Promise<string>;
+export declare const crashReporter: CrashReporterAPI;
+export declare interface CrashReport {
+  severity?: CrashSeverity
+  message: string
+  source?: 'js' | 'native'
+  stack?: string
+}
+export declare interface StoredCrashEntry {
+  timestamp: number
+  severity: string
+  message: string
+  source: string
+  stack: string
+  userId?: string
+  appVersion?: string
+}
+export declare interface CrashForwarderOptions {
+  endpoint: string
+  intervalMs?: number
+  signingSecret?: string
+  redact?: boolean | ((entry: StoredCrashEntry) => StoredCrashEntry)
+  headers?: Record<string, string>
+  maxRetries?: number
+  persistKey?: string | null
+}
+export declare interface CrashForwarderHandle {
+  flushNow: () => Promise<void>
+  stop: () => void
+  pending: () => StoredCrashEntry[]
+}
+export declare interface CrashReporterAPI {
+  report: (entry: CrashReport | Error) => Promise<void>
+  flush: () => Promise<StoredCrashEntry[]>
+  clear: () => Promise<void>
+  setEnabled: (on: boolean) => Promise<void>
+  isEnabled: () => Promise<boolean>
+  setUser: (id: string) => Promise<void>
+  setAppVersion: (version: string) => Promise<void>
+  attachGlobalHandlers: () => () => void
+  forwardTo: (options: CrashForwarderOptions) => CrashForwarderHandle
+}
+export type CrashSeverity = 'fatal' | 'error' | 'warning';

package/dist/deep-link.d.ts

@@ -0,0 +1,10 @@
+export declare const deepLinks: DeepLinks;
+export declare interface DeepLinkEvent {
+  url: string
+}
+export declare interface DeepLinks {
+  onUrl: (cb: (e: DeepLinkEvent) => void) => () => void
+  getInitialUrl: () => string | null
+  consumeInitialUrl: () => string | null
+  isAvailable: () => boolean
+}

package/dist/drag-out.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Start a native drag with the given file path(s). Returns a promise
+ * that resolves when the drag has *started* (not when it ends — there's
+ * no reliable native callback for that without per-source delegate
+ * scaffolding, and the OS handles the success path on the destination
+ * side anyway).
+ *
+ * Outside a Craft window this rejects with a descriptive error so
+ * callers can offer a fallback (e.g. trigger a download).
+ */
+export declare function dragOut(paths: string | string[], options?: DragOutOptions): Promise<void>;
+/** True when native drag-out is available. */
+export declare function isDragOutAvailable(): boolean;
+export declare interface DragOutOptions {
+  event?: MouseEvent
+  x?: number
+  y?: number
+}

package/dist/file-associations.d.ts

@@ -0,0 +1,5 @@
+export declare const fileAssociations: FileAssociationsAPI;
+export declare interface FileAssociationsAPI {
+  getDefault: (uti: string) => Promise<string | null>
+  setDefault: (uti: string, bundleId: string) => Promise<boolean>
+}

package/dist/fs.d.ts

@@ -0,0 +1,62 @@
+// Each method is `async` so that the synchronous `requireBridge` throw
+// surfaces as a rejected promise — matching the rest of the surface and
+// keeping call sites uniformly awaitable.
+export declare const fs: FS;
+export declare interface FileStat {
+  isFile: boolean
+  isDirectory: boolean
+  isSymlink: boolean
+  size: number
+  modifiedAt: number
+}
+export declare interface FSChangeEvent {
+  id: string
+  path: string
+  kind?: 'created' | 'modified' | 'deleted' | 'renamed' | 'unknown'
+}
+export declare interface WatchOptions {
+  recursive?: boolean
+  coalesceMs?: number
+  kinds?: Array<NonNullable<FSChangeEvent['kind']>>
+}
+export declare interface WatchHandle {
+  stop: () => Promise<void>
+  id: string
+}
+export declare interface DirEntry {
+  name: string
+  path: string
+  isDirectory: boolean
+}
+export declare interface MkdirOptions {
+  recursive?: boolean
+}
+export declare interface RmdirOptions {
+  recursive?: boolean
+}
+export declare interface FS {
+  readFile: (path: string) => Promise<string>
+  readBuffer: (path: string) => Promise<Uint8Array>
+  writeFile: (path: string, data: string) => Promise<void>
+  writeBuffer: (path: string, data: Uint8Array) => Promise<void>
+  appendFile: (path: string, data: string) => Promise<void>
+  deleteFile: (path: string) => Promise<void>
+  exists: (path: string) => Promise<boolean>
+  stat: (path: string) => Promise<FileStat>
+  readDir: (path: string) => Promise<DirEntry[]>
+  mkdir: (path: string, opts?: MkdirOptions) => Promise<void>
+  rmdir: (path: string, opts?: RmdirOptions) => Promise<void>
+  copy: (from: string, to: string) => Promise<void>
+  move: (from: string, to: string) => Promise<void>
+  watch: (path: string, id?: string) => Promise<void>
+  unwatch: (id: string) => Promise<void>
+  onChange: (cb: (event: FSChangeEvent) => void) => () => void
+  watchTree: (
+    path: string,
+    options: WatchOptions,
+    cb: (events: FSChangeEvent[]) => void,
+  ) => Promise<WatchHandle>
+  homeDir: () => Promise<string>
+  tempDir: () => Promise<string>
+  appDataDir: () => Promise<string>
+}

package/dist/global-shortcuts.d.ts

@@ -0,0 +1,19 @@
+export declare const globalShortcuts: GlobalShortcuts;
+export declare interface GlobalShortcutOptions {
+  repeats?: boolean
+}
+export declare interface ShortcutFireEvent {
+  id: string
+  accelerator: string
+  timestamp: number
+}
+export declare interface GlobalShortcuts {
+  register: (id: string, accelerator: string, opts?: GlobalShortcutOptions) => Promise<void>
+  unregister: (id: string) => Promise<void>
+  unregisterAll: () => Promise<void>
+  enable: (id: string) => Promise<void>
+  disable: (id: string) => Promise<void>
+  isRegistered: (id: string) => Promise<boolean>
+  list: () => Promise<Array<{ id: string, accelerator: string, enabled: boolean }>>
+  on: (cb: (e: ShortcutFireEvent) => void) => () => void
+}

package/dist/handoff.d.ts

@@ -0,0 +1,24 @@
+export declare const handoff: HandoffAPI;
+export declare interface HandoffActivityOptions {
+  title?: string
+  webpageURL?: string
+  userInfo?: Record<string, unknown>
+}
+export declare interface HandoffSnapshot {
+  type: string
+  title: string
+  webpageURL: string
+}
+export declare interface HandoffIncomingEvent {
+  type: string
+  title?: string
+  webpageURL?: string
+  userInfo?: Record<string, unknown>
+}
+export declare interface HandoffAPI {
+  startActivity: (type: string, options?: HandoffActivityOptions) => Promise<boolean>
+  updateActivity: (options: HandoffActivityOptions) => Promise<boolean>
+  stopActivity: () => Promise<void>
+  getCurrentActivity: () => Promise<HandoffSnapshot | null>
+  onIncoming: (cb: (event: HandoffIncomingEvent) => void) => () => void
+}

package/dist/hotkeys.d.ts

@@ -37,25 +37,27 @@ export declare function unregisterAllHotkeys(): void;
  */
 export declare function getRegisteredHotkeys(): HotkeyRegistration[];
 /**
- * Global Hotkey API
+ * Hotkey API (in-window, document-level)
  *
- * Register global keyboard shortcuts that work even when the app is not focused.
- * Communicates with Craft's native side to register system-wide hotkeys.
- * Falls back to document-level listeners in web/non-native mode.
+ * Register keyboard shortcuts via document-level listeners. These fire
+ * **only while a Craft window has focus** — a thin wrapper around
+ * `keydown`. Use this for app-internal shortcuts like
+ * "Cmd+K opens the command palette."
+ *
+ * **For system-wide shortcuts** that fire even when the app isn't
+ * focused (e.g. global "Cmd+Shift+V to bring up your clipboard
+ * manager"), use `globalShortcuts` from `./global-shortcuts` — that
+ * talks to the native `RegisterEventHotKey` / `RegisterHotKey` APIs.
  *
  * @example
  * ```typescript
  * import { registerHotkey, unregisterAllHotkeys } from '@stacksjs/desktop'
  *
- * // Register a global shortcut
  * const reg = registerHotkey('Cmd+Shift+C', () => {
  *   console.log('Hotkey triggered!')
  * })
  *
- * // Unregister a specific shortcut
  * reg.unregister()
- *
- * // Unregister all shortcuts
  * unregisterAllHotkeys()
  * ```
  */

package/dist/iap.d.ts

@@ -0,0 +1,79 @@
+export declare const iap: IAPAPI;
+export declare interface IAPSubscriptionInfo {
+  numberOfUnits: number
+  unit: IAPSubscriptionPeriod
+  introductoryOffer?: IAPIntroductoryOffer
+  familyShareable?: boolean
+  groupIdentifier?: string
+}
+export declare interface IAPIntroductoryOffer {
+  paymentMode: 'free-trial' | 'pay-as-you-go' | 'pay-up-front'
+  localizedPrice: string
+  numberOfUnits: number
+  unit: IAPSubscriptionPeriod
+  numberOfPeriods?: number
+}
+export declare interface IAPProduct {
+  id: string
+  title: string
+  description?: string
+  price: string
+  currency?: string
+  localizedPrice?: string
+  type?: IAPProductType
+  subscription?: IAPSubscriptionInfo
+}
+export declare interface IAPPurchaseResult {
+  queued: boolean
+  productId?: string
+  reason?: string
+}
+export declare interface IAPTransactionEvent {
+  productId: string
+  transactionId: string
+  date?: string
+  originalTransactionId?: string
+  familyShared?: boolean
+  restored?: boolean
+  autoRenewing?: boolean
+  expiresAt?: string
+  inIntroPeriod?: boolean
+}
+export declare interface IAPFailureEvent {
+  productId: string
+  code?: number
+  message?: string
+}
+export declare interface IAPRefundEvent {
+  productId: string
+  transactionId: string
+  refundedAt?: string
+  reason?: string
+}
+export declare interface IAPSubscriptionStatusEvent {
+  productId: string
+  status: 'active' | 'expired' | 'in-grace-period' | 'in-billing-retry' | 'revoked'
+  changedAt?: string
+  expiresAt?: string
+}
+export declare interface IAPAPI {
+  isAvailable: () => Promise<boolean>
+  getProducts: (ids: string[] | string) => Promise<IAPProduct[]>
+  purchase: (productId: string) => Promise<IAPPurchaseResult>
+  restorePurchases: () => Promise<{ ok: boolean }>
+  finishTransaction: (transactionId: string) => Promise<void>
+  getReceiptData: () => Promise<string | null>
+  onPurchased: (cb: (e: IAPTransactionEvent) => void) => () => void
+  onFailed: (cb: (e: IAPFailureEvent) => void) => () => void
+  onRestored: (cb: (e: IAPTransactionEvent) => void) => () => void
+  onProductsLoaded: (cb: (products: IAPProduct[]) => void) => () => void
+  onRefunded: (cb: (e: IAPRefundEvent) => void) => () => void
+  onSubscriptionStatusChanged: (cb: (e: IAPSubscriptionStatusEvent) => void) => () => void
+  getActiveSubscriptions: () => Promise<IAPSubscriptionStatusEvent[]>
+  isEligibleForIntroOffer: (productId: string) => Promise<boolean>
+}
+export type IAPProductType = | 'consumable'
+  | 'non-consumable'
+  | 'auto-subscription'
+  | 'non-auto-subscription';
+export type IAPSubscriptionPeriod = 'day' | 'week' | 'month' | 'year';