@monimesl/dot-dash 0.1.0-alpha.9 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,4 +1,390 @@
-import { HostCallOptions, HostError, HostErrorCode, HostRequest } from "@monimesl/dot-core";
+import { HostCallOptions, HostError, HostError as DashError, HostErrorCode, HostErrorCode as DashErrorCode, HostRequest } from "@monimesl/dot-core";
+//#region src/contacts/pick-phone.d.ts
+interface PickedContact {
+  name: string;
+  phone: string;
+}
+interface PickPhoneMethods {
+  'dash.contacts.pickPhone': {
+    params: Record<string, never>;
+    result: PickedContact;
+  };
+}
+/**
+ * Shows the phone's contacts so the person chooses one phone number, such as who to send money to.
+ * Needs the `contacts` permission. The dot sees only the chosen contact. Rejects with `cancelled` if
+ * the person closes it.
+ * @since 1.0
+ */
+declare function pickPhone(callOptions?: CallOptions): DashRequest<PickedContact>;
+declare namespace index_d_exports$10 {
+  export { ContactsMethods, PickedContact, pickPhone };
+}
+type ContactsMethods = PickPhoneMethods;
+declare namespace index_d_exports$9 {
+  export { CryptoInput, CryptoMethods, CryptoOutputOptions, HmacAlgorithm, HmacOptions, hmac, randomBytes, randomUUID, sha256, sha512 };
+}
+type CryptoInput = string | {
+  base64: string;
+};
+interface CryptoOutputOptions {
+  as?: 'hex' | 'base64';
+}
+type HmacAlgorithm = 'sha256' | 'sha512';
+interface HmacOptions extends CryptoOutputOptions {
+  algorithm: HmacAlgorithm;
+  key: CryptoInput;
+  data: CryptoInput;
+}
+type InputEncoding = 'text' | 'base64';
+type OutputEncoding = 'hex' | 'base64';
+interface WireInput {
+  data: string;
+  dataEncoding: InputEncoding;
+  as: OutputEncoding;
+}
+interface CryptoMethods {
+  'dash.crypto.sha256': {
+    params: WireInput;
+    result: string;
+  };
+  'dash.crypto.sha512': {
+    params: WireInput;
+    result: string;
+  };
+  'dash.crypto.hmac': {
+    params: WireInput & {
+      algorithm: HmacAlgorithm;
+      key: string;
+      keyEncoding: InputEncoding;
+    };
+    result: string;
+  };
+  'dash.crypto.randomBytes': {
+    params: {
+      count: number;
+      as: OutputEncoding;
+    };
+    result: string;
+  };
+  'dash.crypto.randomUUID': {
+    params: Record<string, never>;
+    result: string;
+  };
+}
+/** @since 1.0 */
+declare function sha256(data: CryptoInput, options?: CryptoOutputOptions, callOptions?: CallOptions): DashRequest<string>;
+/** @since 1.0 */
+declare function sha512(data: CryptoInput, options?: CryptoOutputOptions, callOptions?: CallOptions): DashRequest<string>;
+/**
+ * Signs `data` with `key`, as HMAC-SHA256 or HMAC-SHA512, such as
+ * `hmac({ algorithm: 'sha256', key, data })`.
+ * @since 1.0
+ */
+declare function hmac(options: HmacOptions, callOptions?: CallOptions): DashRequest<string>;
+/**
+ * `count` secure random bytes, from 1 to 1024, such as for a nonce.
+ * @since 1.0
+ */
+declare function randomBytes(count: number, options?: CryptoOutputOptions, callOptions?: CallOptions): DashRequest<string>;
+/**
+ * A random version 4 UUID, such as "3f0e5c3a-6d1b-4c8e-9a2f-1b7d4e6a9c05".
+ * @since 1.0
+ */
+declare function randomUUID(callOptions?: CallOptions): DashRequest<string>;
+declare namespace index_d_exports$8 {
+  export { DotMethods, close };
+}
+interface DotMethods {
+  'dash.dot.close': {
+    params: Record<string, never>;
+    result: void;
+  };
+}
+/**
+ * Closes the dot, as going back from its first page does. Calls still running are cancelled.
+ * @since 1.0
+ */
+declare function close(callOptions?: CallOptions): DashRequest<void>;
+//#endregion
+//#region src/files.d.ts
+interface DotFile {
+  id: string;
+  name: string;
+  size: number;
+  contentType: string;
+  url: string;
+}
+//#endregion
+//#region src/media/pick-file.d.ts
+interface PickFileOptions {
+  types?: string[];
+}
+interface PickFileMethods {
+  'dash.media.pickFile': {
+    params: {
+      types?: string[];
+    };
+    result: DotFile;
+  };
+}
+/**
+ * Lets the person choose a file from their phone, of at most 25 MB. Needs the `files` permission.
+ * Rejects with `cancelled` if they close the picker, and with `invalid` for a larger file. Like a
+ * download, it lasts until the dot closes, so `dash.storage.file.save` it to keep it.
+ * @since 1.0
+ */
+declare function pickFile(options?: PickFileOptions, callOptions?: CallOptions): DashRequest<DotFile>;
+//#endregion
+//#region src/media/pick-photo.d.ts
+type PhotoSource = 'library' | 'camera';
+interface PickPhotoOptions {
+  source: PhotoSource;
+}
+interface PickPhotoMethods {
+  'dash.media.pickPhoto': {
+    params: {
+      source: PhotoSource;
+    };
+    result: DotFile;
+  };
+}
+/**
+ * Lets the person choose a photo or take one. Resolves with it as a JPEG of at most 2048 pixels on its
+ * longest side, without its location or other details. Rejects with `cancelled` if they close the
+ * picker, and with `unsupported` on a device without a camera. Save it with `dash.storage.file.save`
+ * to keep it after the dot closes.
+ * @since 1.0
+ */
+declare function pickPhoto(options: PickPhotoOptions, callOptions?: CallOptions): DashRequest<DotFile>;
+//#endregion
+//#region src/media/scan-code.d.ts
+type CodeFormat = 'qr';
+interface ScannedCode {
+  text: string;
+  format: CodeFormat;
+}
+interface ScanCodeMethods {
+  'dash.media.scanCode': {
+    params: Record<string, never>;
+    result: ScannedCode;
+  };
+}
+/**
+ * Opens Dash's scanner until it reads a QR code. Needs the `camera` permission. Rejects with
+ * `cancelled` if the person closes it, and with `unsupported` where Dash has no scanner.
+ * @since 1.0
+ */
+declare function scanCode(callOptions?: CallOptions): DashRequest<ScannedCode>;
+declare namespace index_d_exports$7 {
+  export { CodeFormat, MediaMethods, PhotoSource, PickFileOptions, PickPhotoOptions, ScannedCode, pickFile, pickPhoto, scanCode };
+}
+type MediaMethods = PickFileMethods & PickPhotoMethods & ScanCodeMethods;
+declare namespace http_d_exports {
+  export { HttpDownloadRequest, HttpDownloadResponse, HttpMethod, HttpMethods, HttpReadOptions, HttpRequest, HttpRequestBody, HttpResponse, HttpUploadFile, HttpUploadRequest, download, request$1 as request, upload };
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+type HttpRequestBody = string | object;
+interface HttpRequest<Body extends HttpRequestBody = HttpRequestBody> {
+  url: string;
+  method?: HttpMethod;
+  headers?: Record<string, string>;
+  body?: Body;
+}
+interface HttpResponse<Body = string> {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  body: Body;
+}
+type HttpReadOptions<Body> = [Body] extends [string] ? {
+  as?: 'text';
+} : {
+  as: 'json';
+};
+interface HttpDownloadRequest extends HttpRequest {
+  name?: string;
+}
+type HttpDownloadResponse = (Omit<HttpResponse, 'ok' | 'body'> & {
+  ok: true;
+  file: DotFile;
+}) | (Omit<HttpResponse, 'ok'> & {
+  ok: false;
+});
+interface HttpUploadFile {
+  field: string;
+  file: DotFile;
+  name?: string;
+}
+interface HttpUploadRequest {
+  url: string;
+  method?: 'POST' | 'PUT' | 'PATCH';
+  headers?: Record<string, string>;
+  fields?: Record<string, string>;
+  files: HttpUploadFile[];
+}
+type WireRequest<Request extends HttpRequest> = Omit<Request, 'headers' | 'body'> & {
+  headers?: Record<string, string> | undefined;
+  body?: string | undefined;
+};
+interface HttpMethods {
+  'dash.network.http.request': {
+    params: WireRequest<HttpRequest>;
+    result: HttpResponse;
+  };
+  'dash.network.http.download': {
+    params: WireRequest<HttpDownloadRequest>;
+    result: HttpDownloadResponse;
+  };
+  'dash.network.http.upload': {
+    params: Omit<HttpUploadRequest, 'files'> & {
+      files: {
+        field: string;
+        file: string;
+        name?: string;
+      }[];
+    };
+    result: HttpResponse;
+  };
+}
+/**
+ * Like fetch, resolves with any response, even a 404. An object body is sent as JSON.
+ * @since 1.0
+ */
+declare function request$1<ResponseBody = string, RequestBody extends HttpRequestBody = HttpRequestBody>(options: HttpRequest<RequestBody> & HttpReadOptions<ResponseBody>, callOptions?: CallOptions): DashRequest<HttpResponse<ResponseBody>>;
+/**
+ * Saves a 2xx response's body, up to 256 MB, to a temporary file.
+ * @since 1.0
+ */
+declare function download(options: HttpDownloadRequest, callOptions?: CallOptions): DashRequest<HttpDownloadResponse>;
+/**
+ * Sends the dot's files as a multipart form.
+ * @since 1.0
+ */
+declare function upload<ResponseBody = string>(options: HttpUploadRequest & HttpReadOptions<ResponseBody>, callOptions?: CallOptions): DashRequest<HttpResponse<ResponseBody>>;
+//#endregion
+//#region src/network/status.d.ts
+type ConnectionType = 'wifi' | 'cellular' | 'other' | 'none';
+interface NetworkStatus {
+  online: boolean;
+  type: ConnectionType;
+}
+interface StatusMethods {
+  'dash.network.status': {
+    params: Record<string, never>;
+    result: NetworkStatus;
+  };
+}
+/**
+ * Whether the phone is online now, and how. It can still be online without reaching a server.
+ * @since 1.0
+ */
+declare function status(callOptions?: CallOptions): DashRequest<NetworkStatus>;
+declare namespace index_d_exports$6 {
+  export { ConnectionType, HttpDownloadRequest, HttpDownloadResponse, HttpMethod, HttpReadOptions, HttpRequest, HttpRequestBody, HttpResponse, HttpUploadFile, HttpUploadRequest, NetworkMethods, NetworkStatus, http_d_exports as http, status };
+}
+type NetworkMethods = HttpMethods & StatusMethods;
+//#endregion
+//#region src/payments/payments.d.ts
+interface Money {
+  currency: 'SLE' | 'USD';
+  value: number;
+}
+interface OrderLineItem {
+  name: string;
+  unitPrice: Money;
+  quantity?: number | undefined;
+  imageUrl?: string | undefined;
+}
+interface Order {
+  name: string;
+  reference: string;
+  description?: string | undefined;
+  lineItems: OrderLineItem[];
+  metadata?: Record<string, string> | undefined;
+}
+interface ProviderFilter {
+  include?: string[] | undefined;
+  exclude?: string[] | undefined;
+}
+interface LinkMethod {
+  type: 'link';
+  providers?: ProviderFilter | undefined;
+}
+interface CardMethod {
+  type: 'card';
+}
+interface MomoMethod {
+  type: 'momo';
+  providers?: ProviderFilter | undefined;
+  phoneNumber?: string | undefined;
+}
+type PaymentMethod = LinkMethod | CardMethod | MomoMethod;
+interface PaymentOptions {
+  order: Order;
+  methods?: PaymentMethod[] | undefined;
+  financialAccountId?: string | undefined;
+}
+type PaymentStatus = 'pending' | 'completed' | 'failed' | 'expired' | 'cancelled';
+interface PaymentResultBase {
+  reference: string;
+  requestId: string;
+  status: PaymentStatus;
+  amount: Money;
+  paymentId?: string | undefined;
+  orderNumber?: string | undefined;
+}
+interface CardPaymentResult extends PaymentResultBase {
+  method: 'card';
+  checkoutSessionId: string;
+}
+interface MomoPaymentResult extends PaymentResultBase {
+  method: 'momo';
+  paymentCodeId: string;
+}
+interface LinkPaymentResult extends PaymentResultBase {
+  method: 'link';
+  paymentId: string;
+}
+type PaymentResult = CardPaymentResult | MomoPaymentResult | LinkPaymentResult;
+type PaymentCallOptions = Omit<CallOptions, 'timeout'>;
+interface PaymentsMethods {
+  'dash.payments.request': {
+    params: PaymentOptions;
+    result: PaymentResult;
+  };
+  'dash.payments.get': {
+    params: {
+      reference: string;
+    };
+    result: PaymentResult | null;
+  };
+}
+/**
+ * Opens Dash's payment sheet for `order`, where the person picks one of `methods` and pays the
+ * Space that owns the dot. Needs `payments` in dot.json's permissions. Monime checks the request
+ * before the sheet opens: an order it won't take, such as one below its smallest amount, rejects
+ * with `invalid`, a dot or Space it won't take payments for rejects with `denied`, and `failed`
+ * means Dash couldn't reach Monime. If a method fails, the sheet stays open for the person to try
+ * again or pick another. Once they pick a method, it resolves with how the payment ended:
+ * `completed`, `pending` while it's still on its way, `expired`, or `cancelled` if the person
+ * closed the sheet. Before that, it rejects with `cancelled` if the person closes the sheet, or
+ * `timeout` if Dash's time runs out. A payment already under way carries on after `cancel()`: read
+ * it later with `get`.
+ * @since 1.0
+ */
+declare function request(options: PaymentOptions, callOptions?: PaymentCallOptions): DashRequest<PaymentResult>;
+/**
+ * The payment for the order with this reference, such as to check a pending one later, or after
+ * the dot opens again. Undefined if this dot never asked for it, or the person never picked a
+ * method. Needs `payments` in dot.json's permissions.
+ * @since 1.0
+ */
+declare function get$2(reference: string, callOptions?: CallOptions): DashRequest<PaymentResult | undefined>;
+declare namespace index_d_exports$5 {
+  export { CardMethod, CardPaymentResult, LinkMethod, LinkPaymentResult, MomoMethod, MomoPaymentResult, Money, Order, OrderLineItem, PaymentCallOptions, PaymentMethod, PaymentOptions, PaymentResult, PaymentStatus, PaymentsMethods, ProviderFilter, get$2 as get, request };
+}
 declare namespace cache_d_exports {
   export { CacheMethods, CacheSetOptions, CacheValue, clear$1 as clear, exists, get$1 as get, keys, remove$2 as remove, set$1 as set };
 }
@@ -44,21 +430,24 @@ interface CacheMethods {
 interface CacheSetOptions {
   ttl?: number | undefined;
 }
+/**
+ * Resolves with null for a missing or expired key.
+ * @since 1.0
+ */
 declare function get$1<Value extends CacheValue = CacheValue>(key: string, callOptions?: CallOptions): DashRequest<Value | null>;
+/** @since 1.0 */
 declare function set$1(key: string, value: CacheValue, options?: CacheSetOptions, callOptions?: CallOptions): DashRequest<void>;
+/** @since 1.0 */
 declare function remove$2(key: string, callOptions?: CallOptions): DashRequest<void>;
+/** @since 1.0 */
 declare function exists(key: string, callOptions?: CallOptions): DashRequest<boolean>;
+/**
+ * The keys, sorted.
+ * @since 1.0
+ */
 declare function keys(callOptions?: CallOptions): DashRequest<string[]>;
+/** @since 1.0 */
 declare function clear$1(callOptions?: CallOptions): DashRequest<void>;
-//#endregion
-//#region src/files.d.ts
-interface DotFile {
-  id: string;
-  name: string;
-  size: number;
-  contentType: string;
-  url: string;
-}
 declare namespace file_d_exports {
   export { FileEncoding, FileEntry, FileMethods, ReadOptions, ReplaceOptions, StorageUsage, WriteOptions, copy, createFolder, list, move, open, read, remove$1 as remove, save, stat, usage, write };
 }
@@ -163,20 +552,49 @@ interface WriteOptions {
 interface ReplaceOptions {
   overwrite?: boolean;
 }
+/**
+ * Reads a file of up to 5 MB.
+ * @since 1.0
+ */
 declare function read(path: string, options?: ReadOptions, callOptions?: CallOptions): DashRequest<string>;
+/**
+ * Creates any missing folders above the file.
+ * @since 1.0
+ */
 declare function write(path: string, data: string, options?: WriteOptions, callOptions?: CallOptions): DashRequest<FileEntry>;
+/** @since 1.0 */
 declare function stat(path: string, callOptions?: CallOptions): DashRequest<FileEntry | null>;
+/**
+ * Sorted by path.
+ * @since 1.0
+ */
 declare function list(path?: string, options?: {
   recursive?: boolean;
 }, callOptions?: CallOptions): DashRequest<FileEntry[]>;
+/** @since 1.0 */
 declare function createFolder(path: string, callOptions?: CallOptions): DashRequest<FileEntry>;
+/** @since 1.0 */
 declare function move(from: string, to: string, options?: ReplaceOptions, callOptions?: CallOptions): DashRequest<FileEntry>;
+/** @since 1.0 */
 declare function copy(from: string, to: string, options?: ReplaceOptions, callOptions?: CallOptions): DashRequest<FileEntry>;
+/**
+ * Removing a folder that isn't empty needs `recursive`.
+ * @since 1.0
+ */
 declare function remove$1(path: string, options?: {
   recursive?: boolean;
 }, callOptions?: CallOptions): DashRequest<void>;
-declare function save(file: DotFile | string, path: string, options?: ReplaceOptions, callOptions?: CallOptions): DashRequest<FileEntry>;
+/**
+ * Keeps a temporary file, such as a download, at `path`.
+ * @since 1.0
+ */
+declare function save(file: DotFile, path: string, options?: ReplaceOptions, callOptions?: CallOptions): DashRequest<FileEntry>;
+/**
+ * A stored file as a DotFile, to show with its `url` or send with `http.upload`.
+ * @since 1.0
+ */
 declare function open(path: string, callOptions?: CallOptions): DashRequest<DotFile>;
+/** @since 1.0 */
 declare function usage(callOptions?: CallOptions): DashRequest<StorageUsage>;
 declare namespace secret_d_exports {
   export { SecretMethods, clear, get, remove, set };
@@ -206,11 +624,15 @@ interface SecretMethods {
     result: void;
   };
 }
+/** @since 1.0 */
 declare function get(key: string, callOptions?: CallOptions): DashRequest<string | null>;
+/** @since 1.0 */
 declare function set(key: string, value: string, callOptions?: CallOptions): DashRequest<void>;
+/** @since 1.0 */
 declare function remove(key: string, callOptions?: CallOptions): DashRequest<void>;
+/** @since 1.0 */
 declare function clear(callOptions?: CallOptions): DashRequest<void>;
-declare namespace index_d_exports$3 {
+declare namespace index_d_exports$4 {
   export { CacheSetOptions, CacheValue, FileEncoding, FileEntry, ReadOptions, ReplaceOptions, StorageMethods, StorageUsage, WriteOptions, cache_d_exports as cache, file_d_exports as file, secret_d_exports as secret };
 }
 type StorageMethods = FileMethods & CacheMethods & SecretMethods;
@@ -224,6 +646,7 @@ interface ClipboardMethods {
     result: void;
   };
 }
+/** @since 1.0 */
 declare function copyText(text: string, callOptions?: CallOptions): DashRequest<void>;
 //#endregion
 //#region src/system/delay.d.ts
@@ -235,8 +658,30 @@ interface DelayMethods {
     result: void;
   };
 }
+/**
+ * Resolves after `milliseconds`. The host keeps the time, since a dot's logic has no timers.
+ * @since 1.0
+ */
 declare function delay(milliseconds: number, callOptions?: CallOptions): DashRequest<void>;
 //#endregion
+//#region src/system/dial.d.ts
+interface DialMethods {
+  'dash.system.dial': {
+    params: {
+      number: string;
+    };
+    result: void;
+  };
+}
+/**
+ * Opens the phone's dialer with `number` ready, such as "+232 76 123456" or a USSD code such as
+ * "*715#". The person taps Call. Spaces and dashes are fine; anything else but digits, +, * and #
+ * rejects with `invalid`. For a code, Dash asks the person first, and rejects with `cancelled` if
+ * they say no. Codes that set up call forwarding, such as "**21*…#", reject with `denied`.
+ * @since 1.0
+ */
+declare function dial(number: string, callOptions?: CallOptions): DashRequest<void>;
+//#endregion
 //#region src/system/haptics.d.ts
 type VibrationStyle = 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error';
 interface VibrateOptions {
@@ -248,8 +693,35 @@ interface HapticsMethods {
     result: void;
   };
 }
+/**
+ * Plays a short vibration. Resolves once it's done.
+ * @since 1.0
+ */
 declare function vibrate(options?: VibrateOptions, callOptions?: CallOptions): DashRequest<void>;
 //#endregion
+//#region src/system/info.d.ts
+type Platform = 'ios' | 'android' | 'simulator';
+interface SystemInfo {
+  platform: Platform;
+  osVersion: string;
+  language: string;
+  region: string | null;
+  timeZone: string;
+  dashVersion: string;
+  apiVersions: string[];
+}
+interface InfoMethods {
+  'dash.system.info': {
+    params: Record<string, never>;
+    result: SystemInfo;
+  };
+}
+/**
+ * The phone and the Dash the dot runs in. It has nothing that identifies the person or the phone.
+ * @since 1.0
+ */
+declare function info(callOptions?: CallOptions): DashRequest<SystemInfo>;
+//#endregion
 //#region src/system/open-url.d.ts
 interface OpenUrlMethods {
   'dash.system.openUrl': {
@@ -259,14 +731,47 @@ interface OpenUrlMethods {
     result: void;
   };
 }
+/**
+ * Opens an https address in the device's browser. Any other address rejects with `invalid`.
+ * @since 1.0
+ */
 declare function openUrl(url: string, callOptions?: CallOptions): DashRequest<void>;
 //#endregion
+//#region src/system/screen.d.ts
+type BrightnessLevel = 'max' | 'normal';
+interface ScreenMethods {
+  'dash.system.keepAwake': {
+    params: {
+      on: boolean;
+    };
+    result: void;
+  };
+  'dash.system.brightness': {
+    params: {
+      level: BrightnessLevel;
+    };
+    result: void;
+  };
+}
+/**
+ * Keeps the screen from dimming and locking while the dot shows, such as while a ticket's QR code is
+ * up. Dash undoes it when the dot closes.
+ * @since 1.0
+ */
+declare function keepAwake(on: boolean, callOptions?: CallOptions): DashRequest<void>;
+/**
+ * `max` makes the screen as bright as it goes, so a scanner can read a QR code on it, and `normal`
+ * puts it back. Dash puts it back too when the dot closes or the person leaves the app.
+ * @since 1.0
+ */
+declare function brightness(level: BrightnessLevel, callOptions?: CallOptions): DashRequest<void>;
+//#endregion
 //#region src/system/share.d.ts
 interface ShareOptions {
   title?: string;
   text?: string;
   url?: string;
-  file?: DotFile | string;
+  file?: DotFile;
 }
 interface ShareMethods {
   'dash.system.share': {
@@ -279,23 +784,30 @@ interface ShareMethods {
     result: void;
   };
 }
+/**
+ * Opens the device's share sheet. Resolves once it shows.
+ * @since 1.0
+ */
 declare function share(options: ShareOptions, callOptions?: CallOptions): DashRequest<void>;
 //#endregion
 //#region src/system/torch.d.ts
-type TorchState = 'on' | 'off';
 interface TorchMethods {
   'dash.system.torch': {
     params: {
-      state: TorchState;
+      on: boolean;
     };
     result: void;
   };
 }
-declare function torch(state: TorchState, callOptions?: CallOptions): DashRequest<void>;
-declare namespace index_d_exports$2 {
-  export { ShareOptions, SystemMethods, TorchState, VibrateOptions, VibrationStyle, copyText, delay, openUrl, share, torch, vibrate };
+/**
+ * Turns the torch on or off. Rejects with `unsupported` on a device without one.
+ * @since 1.0
+ */
+declare function torch(on: boolean, callOptions?: CallOptions): DashRequest<void>;
+declare namespace index_d_exports$3 {
+  export { BrightnessLevel, Platform, ShareOptions, SystemInfo, SystemMethods, VibrateOptions, VibrationStyle, brightness, copyText, delay, dial, info, keepAwake, openUrl, share, torch, vibrate };
 }
-type SystemMethods = ClipboardMethods & DelayMethods & HapticsMethods & OpenUrlMethods & ShareMethods & TorchMethods;
+type SystemMethods = ClipboardMethods & DelayMethods & DialMethods & HapticsMethods & InfoMethods & OpenUrlMethods & ScreenMethods & ShareMethods & TorchMethods;
 //#endregion
 //#region src/ui/dialogs.d.ts
 interface AlertAction {
@@ -317,106 +829,222 @@ interface DialogMethods {
     result: AlertResult;
   };
 }
+/**
+ * Shows a native alert. Resolves with the action the person chose.
+ * @since 1.0
+ */
 declare function alert(options: AlertOptions, callOptions?: CallOptions): DashRequest<AlertResult>;
-declare namespace index_d_exports$1 {
-  export { AlertAction, AlertOptions, AlertResult, UIMethods, alert };
+//#endregion
+//#region src/ui/pickers.d.ts
+interface PickDateOptions {
+  title?: string | undefined;
+  value?: string | undefined;
+  min?: string | undefined;
+  max?: string | undefined;
+}
+interface PickTimeOptions {
+  title?: string | undefined;
+  value?: string | undefined;
 }
-type UIMethods = DialogMethods;
+interface PickerMethods {
+  'dash.ui.pickDate': {
+    params: PickDateOptions;
+    result: string;
+  };
+  'dash.ui.pickTime': {
+    params: PickTimeOptions;
+    result: string;
+  };
+}
+/**
+ * Opens the phone's own calendar. Resolves with the chosen date, such as "2026-10-24", or rejects
+ * with `cancelled` if the person closes it.
+ * @since 1.0
+ */
+declare function pickDate(options?: PickDateOptions, callOptions?: CallOptions): DashRequest<string>;
+/**
+ * Opens the phone's own clock. Resolves with the chosen time in 24 hours, such as "19:30", or
+ * rejects with `cancelled` if the person closes it.
+ * @since 1.0
+ */
+declare function pickTime(options?: PickTimeOptions, callOptions?: CallOptions): DashRequest<string>;
+declare namespace index_d_exports$2 {
+  export { AlertAction, AlertOptions, AlertResult, PickDateOptions, PickTimeOptions, UIMethods, alert, pickDate, pickTime };
+}
+type UIMethods = DialogMethods & PickerMethods;
 //#endregion
 //#region src/methods.d.ts
-type DashMethods = UIMethods & SystemMethods & NetworkMethods & StorageMethods;
+type DashMethods = UIMethods & SystemMethods & NetworkMethods & StorageMethods & MediaMethods & ContactsMethods & DotMethods & AccountMethods & CryptoMethods & PaymentsMethods;
 type DashMethod = keyof DashMethods;
 //#endregion
 //#region src/call.d.ts
 type CallOptions = HostCallOptions;
 type DashRequest<Result> = HostRequest<Result>;
-declare namespace http_d_exports {
-  export { HttpDownloadRequest, HttpDownloadResponse, HttpMethod, HttpMethods, HttpReadOptions, HttpRequest, HttpRequestBody, HttpResponse, HttpUploadFile, HttpUploadRequest, download, request, upload };
+declare namespace index_d_exports$1 {
+  export { AccountMethods, OidcProfile, OidcScope, OidcSignIn, OidcSignInOptions, SignInMode, SimpleSignIn, SimpleSignInOptions, signIn };
 }
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
-type HttpRequestBody = string | object;
-interface HttpRequest<Body extends HttpRequestBody = HttpRequestBody> {
-  url: string;
-  method?: HttpMethod;
-  headers?: Record<string, string>;
-  body?: Body;
+type SignInMode = 'simple' | 'oidc';
+interface SimpleSignInOptions {
+  mode: 'simple';
+  nonce?: string | undefined;
 }
-interface HttpResponse<Body = string> {
-  ok: boolean;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-  body: Body;
+interface SimpleSignIn {
+  fullName: string;
+  alias: string;
+  accountIdToken: string;
 }
-type HttpReadOptions<Body> = [Body] extends [string] ? {
-  as?: 'text';
-} : {
-  as: 'json';
-};
-interface HttpDownloadRequest extends HttpRequest {
-  name?: string;
+type OidcScope = 'profile' | 'phone' | 'email';
+interface OidcSignInOptions {
+  mode: 'oidc';
+  scopes?: OidcScope[] | undefined;
+  nonce?: string | undefined;
 }
-type HttpDownloadResponse = (Omit<HttpResponse, 'ok' | 'body'> & {
-  ok: true;
-  file: DotFile;
-}) | (Omit<HttpResponse, 'ok'> & {
-  ok: false;
-});
-interface HttpUploadFile {
-  field: string;
-  file: DotFile | string;
-  name?: string;
+interface OidcProfile {
+  name?: string | undefined;
+  givenName?: string | undefined;
+  familyName?: string | undefined;
+  phone?: string | undefined;
+  email?: string | undefined;
 }
-interface HttpUploadRequest {
-  url: string;
-  method?: 'POST' | 'PUT' | 'PATCH';
-  headers?: Record<string, string>;
-  fields?: Record<string, string>;
-  files: HttpUploadFile[];
+interface OidcSignIn {
+  id: string;
+  idToken: string;
+  expiresAt: string;
+  profile: OidcProfile;
 }
-type WireRequest<Request extends HttpRequest> = Omit<Request, 'headers' | 'body'> & {
-  headers?: Record<string, string> | undefined;
-  body?: string | undefined;
-};
-interface HttpMethods {
-  'dash.network.http.request': {
-    params: WireRequest<HttpRequest>;
-    result: HttpResponse;
-  };
-  'dash.network.http.download': {
-    params: WireRequest<HttpDownloadRequest>;
-    result: HttpDownloadResponse;
-  };
-  'dash.network.http.upload': {
-    params: Omit<HttpUploadRequest, 'files'> & {
-      files: {
-        field: string;
-        file: string;
-        name?: string;
-      }[];
+interface AccountMethods {
+  'dash.account.signIn': {
+    params: {
+      mode: SignInMode;
+      nonce: string;
+      scopes?: OidcScope[];
     };
-    result: HttpResponse;
+    result: SimpleSignIn | OidcSignIn;
   };
 }
-declare function request<ResponseBody = string, RequestBody extends HttpRequestBody = HttpRequestBody>(options: HttpRequest<RequestBody> & HttpReadOptions<ResponseBody>, callOptions?: CallOptions): DashRequest<HttpResponse<ResponseBody>>;
-declare function download(options: HttpDownloadRequest, callOptions?: CallOptions): DashRequest<HttpDownloadResponse>;
-declare function upload<ResponseBody = string>(options: HttpUploadRequest & HttpReadOptions<ResponseBody>, callOptions?: CallOptions): DashRequest<HttpResponse<ResponseBody>>;
+/**
+ * Signs the person in to the dot with their Dash account. Needs the `account` permission.
+ *
+ * With `mode: 'simple'`, resolves with their full name, their phone number or email address, and a
+ * token that names them in this dot. With `mode: 'oidc'`, OpenID Connect, it will resolve with an ID
+ * token for the dot's server; until Dash has it, it rejects with `unsupported`.
+ *
+ * Rejects with `invalid` for a nonce longer than 128 characters, with `unsupported` for a mode this
+ * Dash doesn't have, and with `failed` when no one is signed in or Dash can't reach Monime.
+ * @since 1.0
+ */
+declare function signIn(options: SimpleSignInOptions, callOptions?: CallOptions): DashRequest<SimpleSignIn>;
+declare function signIn(options: OidcSignInOptions, callOptions?: CallOptions): DashRequest<OidcSignIn>;
+//#endregion
+//#region src/api-versions.d.ts
+export declare const DASH_API_VERSION = "1.0";
+export declare const DASH_API_SINCE: {
+  readonly 'account.signIn': "1.0";
+  readonly 'contacts.pickPhone': "1.0";
+  readonly 'crypto.hmac': "1.0";
+  readonly 'crypto.randomBytes': "1.0";
+  readonly 'crypto.randomUUID': "1.0";
+  readonly 'crypto.sha256': "1.0";
+  readonly 'crypto.sha512': "1.0";
+  readonly 'dot.close': "1.0";
+  readonly 'media.pickFile': "1.0";
+  readonly 'media.pickPhoto': "1.0";
+  readonly 'media.scanCode': "1.0";
+  readonly 'network.http.download': "1.0";
+  readonly 'network.http.request': "1.0";
+  readonly 'network.http.upload': "1.0";
+  readonly 'network.status': "1.0";
+  readonly 'payments.get': "1.0";
+  readonly 'payments.request': "1.0";
+  readonly 'storage.cache.clear': "1.0";
+  readonly 'storage.cache.exists': "1.0";
+  readonly 'storage.cache.get': "1.0";
+  readonly 'storage.cache.keys': "1.0";
+  readonly 'storage.cache.remove': "1.0";
+  readonly 'storage.cache.set': "1.0";
+  readonly 'storage.file.copy': "1.0";
+  readonly 'storage.file.createFolder': "1.0";
+  readonly 'storage.file.list': "1.0";
+  readonly 'storage.file.move': "1.0";
+  readonly 'storage.file.open': "1.0";
+  readonly 'storage.file.read': "1.0";
+  readonly 'storage.file.remove': "1.0";
+  readonly 'storage.file.save': "1.0";
+  readonly 'storage.file.stat': "1.0";
+  readonly 'storage.file.usage': "1.0";
+  readonly 'storage.file.write': "1.0";
+  readonly 'storage.secret.clear': "1.0";
+  readonly 'storage.secret.get': "1.0";
+  readonly 'storage.secret.remove': "1.0";
+  readonly 'storage.secret.set': "1.0";
+  readonly 'system.brightness': "1.0";
+  readonly 'system.copyText': "1.0";
+  readonly 'system.delay': "1.0";
+  readonly 'system.dial': "1.0";
+  readonly 'system.info': "1.0";
+  readonly 'system.keepAwake': "1.0";
+  readonly 'system.openUrl': "1.0";
+  readonly 'system.share': "1.0";
+  readonly 'system.torch': "1.0";
+  readonly 'system.vibrate': "1.0";
+  readonly 'ui.alert': "1.0";
+  readonly 'ui.pickDate': "1.0";
+  readonly 'ui.pickTime': "1.0";
+};
+type DashFeature = keyof typeof DASH_API_SINCE;
+export declare function useHostDashApiVersions(versions: readonly string[]): void;
+export declare function warnAboveDashApiVersion(minApiVersion: string | undefined): void;
+/**
+ * Whether the Dash the dot runs in has `feature`: a call, such as "contacts.pickPhone", or a field
+ * added to a call later. Check it before using one that's newer than the dot's minApiVersion.
+ * @since 1.0
+ */
+declare function supports(feature: DashFeature): boolean;
+//#endregion
+//#region src/utils/encoding.d.ts
+declare const base64: {
+  encode(text: string): string;
+  decode(encoded: string): string;
+};
+declare const hex: {
+  encode(text: string): string;
+  decode(encoded: string): string;
+};
 declare namespace index_d_exports {
-  export { HttpDownloadRequest, HttpDownloadResponse, HttpMethod, HttpReadOptions, HttpRequest, HttpRequestBody, HttpResponse, HttpUploadFile, HttpUploadRequest, NetworkMethods, http_d_exports as http };
+  export { base64, hex };
 }
-type NetworkMethods = HttpMethods;
 //#endregion
 //#region src/tracked.d.ts
 export declare function tracked<Group extends object>(group: Group, track: (request: DashRequest<unknown>) => void): Group;
 //#endregion
+//#region src/errors.d.ts
+type DashErrorWith<Code extends HostErrorCode> = HostError & {
+  readonly code: Code;
+};
+export declare function isDashError<Code extends HostErrorCode>(error: unknown, ...codes: Code[]): error is DashErrorWith<Code>;
+export declare function errorMessage(error: unknown): string;
+export declare function unlessCancelled<Result>(call: PromiseLike<Result>): Promise<Result | undefined>;
+//#endregion
+//#region src/latest.d.ts
+export declare function latest(): <Result>(call: DashRequest<Result>) => DashRequest<Result>;
+export declare function debounce(milliseconds: number): (dash: Dash) => Promise<boolean>;
+//#endregion
 //#region src/index.d.ts
 export declare const dash: {
-  ui: typeof index_d_exports$1;
-  system: typeof index_d_exports$2;
-  network: typeof index_d_exports;
-  storage: typeof index_d_exports$3;
+  ui: typeof index_d_exports$2;
+  system: typeof index_d_exports$3;
+  network: typeof index_d_exports$6;
+  storage: typeof index_d_exports$4;
+  media: typeof index_d_exports$7;
+  contacts: typeof index_d_exports$10;
+  dot: typeof index_d_exports$8;
+  account: typeof index_d_exports$1;
+  payments: typeof index_d_exports$5;
+  crypto: typeof index_d_exports$9;
+  utils: typeof index_d_exports;
+  supports: typeof supports;
 };
 export type Dash = typeof dash;
 //#endregion
-export { type AlertAction, type AlertOptions, type AlertResult, type CacheSetOptions, type CacheValue, type CallOptions, type DashMethod, type DashMethods, type DashRequest, type DotFile, type FileEncoding, type FileEntry, HostError, type HostErrorCode, type HttpDownloadRequest, type HttpDownloadResponse, type HttpMethod, type HttpReadOptions, type HttpRequest, type HttpRequestBody, type HttpResponse, type HttpUploadFile, type HttpUploadRequest, type NetworkMethods, type ReadOptions, type ReplaceOptions, type ShareOptions, type StorageMethods, type StorageUsage, type SystemMethods, type TorchState, type UIMethods, type VibrateOptions, type VibrationStyle, type WriteOptions };
+export { type AlertAction, type AlertOptions, type AlertResult, type BrightnessLevel, type CacheSetOptions, type CacheValue, type CallOptions, type CardMethod, type CardPaymentResult, type CodeFormat, type ConnectionType, type ContactsMethods, type CryptoInput, type CryptoOutputOptions, DashError, type DashErrorCode, type DashFeature, type DashMethod, type DashMethods, type DashRequest, type DotFile, type FileEncoding, type FileEntry, type HmacAlgorithm, type HmacOptions, type HttpDownloadRequest, type HttpDownloadResponse, type HttpMethod, type HttpReadOptions, type HttpRequest, type HttpRequestBody, type HttpResponse, type HttpUploadFile, type HttpUploadRequest, type LinkMethod, type LinkPaymentResult, type MediaMethods, type MomoMethod, type MomoPaymentResult, type Money, type NetworkMethods, type NetworkStatus, type OidcProfile, type OidcScope, type OidcSignIn, type OidcSignInOptions, type Order, type OrderLineItem, type PaymentCallOptions, type PaymentMethod, type PaymentOptions, type PaymentResult, type PaymentStatus, type PaymentsMethods, type PhotoSource, type PickDateOptions, type PickFileOptions, type PickPhotoOptions, type PickTimeOptions, type PickedContact, type Platform, type ProviderFilter, type ReadOptions, type ReplaceOptions, type ScannedCode, type ShareOptions, type SignInMode, type SimpleSignIn, type SimpleSignInOptions, type StorageMethods, type StorageUsage, type SystemInfo, type SystemMethods, type UIMethods, type VibrateOptions, type VibrationStyle, type WriteOptions };
 //# sourceMappingURL=index.d.ts.map