akanjs 3.0.0-beta.9 → 3.0.1

package/types/vendor/@akanjs/native/plugins/screen/src/index.d.ts

@@ -0,0 +1,70 @@
+export { sameDisplays } from "./web.ts";
+/**
+ * Displays and the mouse cursor (plugins.md §5).
+ *
+ * Coordinates are logical pixels (CSS px) with the origin at the top-left corner of the primary
+ * display (the one with the menu bar) and y growing down: the same space as the window plugin's
+ * positions (`appWindow.setPosition`, `getState().x/y`), so a window can be placed on a display
+ * with `setPosition({ x: d.workArea.x + 20, y: d.workArea.y + 20 })`. Displays above or left of
+ * the primary one have negative coordinates.
+ *
+ * - macOS: TAO monitors; `workArea` leaves out the menu bar and the Dock (NSScreen visibleFrame).
+ *   `change` fires when a display is added, removed or rearranged, or its resolution or scale
+ *   changes. Showing or hiding the Dock may not send it; call getDisplays() again before placing
+ *   a window if that matters.
+ * - Web: one display, the screen the page is on, from `window.screen` (bounds at 0,0; workArea
+ *   from availLeft/availTop/availWidth/availHeight). `scale` is devicePixelRatio, which includes
+ *   the page zoom. getCursorPoint is UNSUPPORTED: a page only sees the mouse over itself.
+ * - Windows: TAO monitors; `workArea` leaves out the taskbar (GetMonitorInfo). `change` fires for
+ *   display and work area changes.
+ * - Linux: GDK monitors, in the space of the X screen (or the Wayland compositor), whose origin
+ *   is the top-left corner of the whole desktop, not always the primary display's. `workArea`
+ *   comes from the window manager and is exact for the primary display only. `change` fires when
+ *   a display is added, removed or resized, not for work area changes. getCursorPoint is
+ *   UNSUPPORTED on Wayland, which tells an app where the pointer is only over its own windows.
+ * - iOS and Android: UNSUPPORTED.
+ */
+export interface ScreenRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Display {
+    /** Stable while the display stays connected (macOS: CGDirectDisplayID). 0 on the web. */
+    id: number;
+    /** As the OS shows it, e.g. "Built-in Retina Display". "" on the web. */
+    name: string;
+    bounds: ScreenRect;
+    /** Where windows can go: bounds without the menu bar, Dock or taskbar. */
+    workArea: ScreenRect;
+    /** Device pixels per CSS pixel (2 on Retina displays). */
+    scale: number;
+    primary: boolean;
+}
+export interface ScreenApi {
+    /** The primary display first. */
+    getDisplays(): Promise<Display[]>;
+    /** Where the mouse pointer is, anywhere on the desktop (it may be over another app). */
+    getCursorPoint(): Promise<{
+        x: number;
+        y: number;
+    }>;
+}
+export interface ScreenEvents {
+    /** The displays changed; sent only when getDisplays() would answer differently. */
+    change: {
+        displays: Display[];
+    };
+}
+export declare const screen: import("../../../packages/core/src/plugin.ts").Plugin<ScreenApi, ScreenEvents>;
+/**
+ * The connected displays, primary first. Re-renders when they change. Before the first answer
+ * (and where the plugin is unsupported) it holds the web view of the page's own screen, or [].
+ */
+export declare function useDisplays(): Display[];
+/** The display that contains the point (e.g. getCursorPoint()), else the nearest one. */
+export declare function displayAt(point: {
+    x: number;
+    y: number;
+}, displays: Display[]): Display | undefined;

package/types/vendor/@akanjs/native/plugins/screen/src/web.d.ts

@@ -0,0 +1,18 @@
+import type { Display, ScreenApi, ScreenEvents } from "./index.ts";
+/** The parts of `window.screen` this reads (availLeft/availTop/left/top are non-standard). */
+export interface ScreenLike {
+    width: number;
+    height: number;
+    availWidth?: number;
+    availHeight?: number;
+    availLeft?: number;
+    availTop?: number;
+    left?: number;
+    top?: number;
+}
+export declare function webDisplay(s: ScreenLike, devicePixelRatio: number): Display;
+/** [] where there is no DOM (tests, the desktop plugin host). */
+export declare function readWebDisplays(): Display[];
+/** Displays are plain JSON; two lists are the same when they serialize the same. */
+export declare function sameDisplays(a: Display[], b: Display[]): boolean;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<ScreenApi, ScreenEvents>;

package/types/vendor/@akanjs/native/plugins/screen/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/screen-orientation/src/index.d.ts

@@ -0,0 +1,32 @@
+import type { OrientationLock, OrientationType } from "./types.ts";
+export { checkLock, ORIENTATION_LOCKS, ORIENTATION_TYPES, type OrientationLock, type OrientationType, } from "./types.ts";
+export interface OrientationState {
+    type: OrientationType;
+}
+/**
+ * Screen orientation (plugins.md §4.1): read it, follow it, lock it. Not available on desktop.
+ * The lock belongs to the app and outlives page reloads until unlock().
+ */
+export interface ScreenOrientationApi {
+    get(): Promise<OrientationState>;
+    /**
+     * Restricts the app to `orientation` and rotates to it if needed; resolves once the screen shows
+     * an allowed orientation (or after a moment, when the system rotates later).
+     * Rejects UNSUPPORTED where the lock is not honoured: an orientation the app does not support
+     * (portrait-secondary on iPhones), iPads with multitasking, Android 16+ screens 600 dp and wider
+     * (the system ignores locks there), and browsers without the API. Browsers that have it lock only
+     * in fullscreen or installed web apps: PERMISSION_DENIED otherwise.
+     */
+    lock(args: {
+        orientation: OrientationLock;
+    }): Promise<void>;
+    /** Lets the system rotate freely again (the app's supported orientations). */
+    unlock(): Promise<void>;
+}
+export interface ScreenOrientationEvents {
+    /** The screen orientation changed, including 180° turns (landscape-primary ↔ landscape-secondary). */
+    change: OrientationState;
+}
+export declare const screenOrientation: import("../../../packages/core/src/plugin.ts").Plugin<ScreenOrientationApi, ScreenOrientationEvents>;
+/** The current orientation type. Re-renders on every change. */
+export declare function useScreenOrientation(): OrientationState;

package/types/vendor/@akanjs/native/plugins/screen-orientation/src/types.d.ts

@@ -0,0 +1,8 @@
+/** W3C screen orientation types. "primary" is the device's usual way up for that shape. */
+export type OrientationType = "portrait-primary" | "portrait-secondary" | "landscape-primary" | "landscape-secondary";
+/** What lock() accepts: one type, either way up of a shape, or any orientation. */
+export type OrientationLock = "any" | "portrait" | "landscape" | OrientationType;
+export declare const ORIENTATION_TYPES: readonly OrientationType[];
+export declare const ORIENTATION_LOCKS: readonly OrientationLock[];
+/** Checks lock()'s argument; the native implementations check the same list. */
+export declare function checkLock(orientation: unknown): OrientationLock;

package/types/vendor/@akanjs/native/plugins/screen-orientation/src/web.d.ts

@@ -0,0 +1,3 @@
+import type { OrientationState, ScreenOrientationApi, ScreenOrientationEvents } from "./index.ts";
+export declare function readWebOrientation(): OrientationState;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<ScreenOrientationApi, ScreenOrientationEvents>;

package/types/vendor/@akanjs/native/plugins/screen-orientation/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/secure-storage/src/desktop.d.ts

@@ -0,0 +1,16 @@
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { SecureStorageApi } from "./index.ts";
+export interface DesktopSecureStorageOptions {
+    /** Keychain service of the data key. Default `<app id>.akan-native.secure-storage`. */
+    service?: (ctx: DesktopContext) => string;
+    /** The encrypted values. Default `<appDataDir>/secure-storage.json`. */
+    file?: (ctx: DesktopContext) => string;
+}
+/** A word for `security -i`, whose tokenizer takes "…" with \" and \\ escapes. Lines cannot hold control characters. */
+export declare function quoteForSecurity(text: string): string;
+export declare function encrypt(key: Buffer, name: string, value: string): string;
+/** null when the entry was written with another key, for another name, or is damaged. */
+export declare function decrypt(key: Buffer, name: string, blob: string): string | null;
+export declare function createDesktopSecureStorage(options?: DesktopSecureStorageOptions): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<SecureStorageApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<SecureStorageApi, {}>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/secure-storage/src/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Small secrets (tokens, keys, passwords) kept by the OS credential store, encrypted at rest.
+ * Same shape as @akanjs/native/plugins/preferences; store JSON yourself for structured data.
+ *
+ * - iOS: Keychain generic passwords, readable after the first unlock, never synced or restored
+ *   to another device. Keychain items survive uninstalling the app.
+ * - Android: values encrypted with an AES-256-GCM key that never leaves AndroidKeyStore.
+ *   Uninstalling deletes them; values whose key is gone (device transfer) read as null.
+ * - macOS: values encrypted with a key kept in the login Keychain (see src/desktop.ts for
+ *   what that protects against).
+ * - Windows: the same, with the key in the Credential Manager (a generic credential).
+ * - Linux: the same, with the key in the Secret Service (the login keyring of gnome-keyring,
+ *   KWallet or KeePassXC). UNSUPPORTED in a session without one.
+ * - Web: UNSUPPORTED. A browser has no secret store; do not fall back to localStorage.
+ *
+ * No hook on purpose: secrets are read where they are used (an API client), not rendered.
+ */
+export interface SecureStorageApi {
+    /** `{ value: null }` when the key is not stored. */
+    get(args: {
+        key: string;
+    }): Promise<{
+        value: string | null;
+    }>;
+    set(args: {
+        key: string;
+        value: string;
+    }): Promise<void>;
+    remove(args: {
+        key: string;
+    }): Promise<void>;
+    /** Stored keys, sorted. */
+    keys(): Promise<{
+        keys: string[];
+    }>;
+    /** Removes every key of this app. */
+    clear(): Promise<void>;
+}
+export declare const secureStorage: import("../../../packages/core/src/plugin.ts").Plugin<SecureStorageApi, {}>;

package/types/vendor/@akanjs/native/plugins/secure-storage/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/share/src/index.d.ts

@@ -0,0 +1,55 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+export interface ShareOptions {
+    /** Subject line for mail-like targets, preview title on Android. */
+    title?: string;
+    text?: string;
+    /** An absolute URL. On Android it is appended to the text (the intent has one text field). */
+    url?: string;
+    /**
+     * Files as FileRef URLs (`/__akan_native/file/<id>`) returned by other plugins, e.g. camera.takePhoto().
+     * On the web also blob: and same-origin URLs. Not yet on Android (see canShare).
+     */
+    files?: string[];
+}
+export interface ShareResult {
+    /** False when the user closed the share sheet without choosing a target. */
+    completed: boolean;
+    /**
+     * What received the share, when the platform tells: the package name on Android, the activity type
+     * on iOS (com.apple.UIKit.activity.Mail, …). Missing on the web and when unknown.
+     */
+    target?: string;
+}
+/**
+ * The system share sheet: UIActivityViewController (iOS), the Android chooser, navigator.share
+ * (web, and the desktop WebView: WKWebView on macOS, WebView2 on Windows). Linux has no share
+ * sheet (WebKitGTK has no navigator.share): canShare() answers false and share() rejects
+ * UNSUPPORTED. Closing the sheet resolves `{ completed: false }` rather than rejecting, as
+ * react-native Share does ("dismissedAction").
+ */
+export interface ShareApi {
+    /**
+     * Opens the share sheet. Needs a user gesture on the web (call it from a click, before any await).
+     * Rejects INVALID_ARGS without text, url or files, CANCELLED while another share sheet is open,
+     * UNSUPPORTED where sharing (or sharing these files) is not available.
+     */
+    share(options: ShareOptions): Promise<ShareResult>;
+    /**
+     * Whether share() would work for these options; without options (or with {}) whether a share sheet
+     * exists at all. Invalid options answer false instead of rejecting, as navigator.canShare does.
+     */
+    canShare(options?: ShareOptions): Promise<{
+        value: boolean;
+    }>;
+}
+export declare const share: import("../../../packages/core/src/plugin.ts").Plugin<ShareApi, {}>;
+export interface UseShare {
+    /** False where no share sheet exists (desktop Firefox, insecure origins): hide the share button. */
+    supported: boolean;
+    pending: boolean;
+    /** Last failure. Closing the sheet is not a failure. */
+    error: AkanNativeError | null;
+    /** Resolves null on failure (see `error`). */
+    share(options: ShareOptions): Promise<ShareResult | null>;
+}
+export declare function useShare(): UseShare;

package/types/vendor/@akanjs/native/plugins/share/src/options.d.ts

@@ -0,0 +1,6 @@
+import type { ShareOptions } from "./index.ts";
+/**
+ * Normalizes share() options the way the native implementations read them: empty strings and
+ * null count as missing, at least one of text, url or files is required, url is absolute.
+ */
+export declare function checkOptions(options: unknown): ShareOptions;

package/types/vendor/@akanjs/native/plugins/share/src/web.d.ts

@@ -0,0 +1,5 @@
+import type { ShareApi } from "./index.ts";
+export declare function webShareAvailable(): boolean;
+/** A file name for the share target: the URL's last path segment if it has an extension. */
+export declare function fileName(url: string, mime: string, index: number, base?: string): string;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<ShareApi, {}>;

package/types/vendor/@akanjs/native/plugins/share/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/single-instance/src/desktop.d.ts

@@ -0,0 +1,8 @@
+import type { SingleInstanceEvents } from "./index.ts";
+export declare function createDesktopSingleInstance(options?: {
+    path?: (appId: string) => string;
+    args?: () => string[];
+    cwd?: () => string;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<{}, SingleInstanceEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<{}, SingleInstanceEvents>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/single-instance/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One running instance per app on the desktop. Adding the plugin to akan-native.config.ts turns it on:
+ * a second launch hands its arguments to the running instance and exits before it creates a
+ * window; the running instance brings its window to the front and emits `secondInstance`.
+ *
+ * - macOS: launching from Finder, the Dock or `open` already reuses the running app; this
+ *   covers direct launches of the executable and `open -n`. Deep links reach the running app
+ *   through the `app` plugin's `urlOpen` either way.
+ * - Windows and Linux (later): deep links arrive as arguments, so this plugin is how they reach
+ *   the running instance (plugins.md §5).
+ * - Web, iOS and Android: UNSUPPORTED (the OS keeps one instance).
+ *
+ * Events that arrive before the page listens are kept (up to 16) and delivered to the first
+ * listener, like deep links (plugins.md C2).
+ */
+export interface SecondInstance {
+    /** The second launch's arguments, without the executable. */
+    args: string[];
+    /** Its working directory, for resolving relative paths in `args`. */
+    cwd: string;
+}
+export interface SingleInstanceEvents {
+    secondInstance: SecondInstance;
+}
+export declare const singleInstance: import("../../../packages/core/src/plugin.ts").Plugin<{}, SingleInstanceEvents>;

package/types/vendor/@akanjs/native/plugins/single-instance/src/socket.d.ts

@@ -0,0 +1,46 @@
+import type { SecondInstance } from "./index.ts";
+/**
+ * sun_path is 104 bytes on macOS, so the name is a short hash, not the app id. Windows pipe names
+ * are one namespace for the whole PC, so the user is part of the hash there; other users cannot
+ * write to a pipe they did not create (its default security), so they cannot pose as it either.
+ */
+export declare function socketPath(appId: string, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): string;
+export declare function encodeMessage(message: SecondInstance): string;
+export declare function decodeMessage(line: string): SecondInstance | null;
+export type Claim = {
+    kind: "primary";
+    close(): void;
+}
+/** Another instance runs: it got the message (or did not answer in time; this launch exits either way). */
+ | {
+    kind: "forwarded";
+}
+/** The lock file cannot be made (e.g. the folder is not writable): run without the lock. */
+ | {
+    kind: "failed";
+    error: Error;
+};
+type Lock = {
+    kind: "held";
+    fd: number;
+} | {
+    kind: "busy";
+} | {
+    kind: "unavailable";
+    error: Error;
+};
+/**
+ * flock(LOCK_EX | LOCK_NB) on `path`, opened with node:fs (open(2) is variadic, which bun:ffi
+ * cannot call portably); flock itself comes from the C library. The descriptor stays open for the
+ * process: closing it would release the lock. It is close-on-exec: a process the app starts with
+ * fork/exec (native code, xdg-open, a relaunch) would otherwise keep the lock after the app quit,
+ * and every later launch would hand its message to nobody and exit.
+ */
+export declare function lockFile(path: string): Lock;
+/**
+ * Becomes the running instance, or hands `message` to the one that is.
+ * A running instance that does not acknowledge within `timeoutMs` (hung) still counts:
+ * starting a second window next to it is what the plugin exists to prevent.
+ */
+export declare function claim(path: string, message: SecondInstance, onMessage: (m: SecondInstance) => void, timeoutMs?: number): Promise<Claim>;
+export {};

package/types/vendor/@akanjs/native/plugins/single-instance/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/splash-screen/src/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The launch screen (SH-6, plugins.md S2). The picture comes from `splash` in akan-native.config.ts;
+ * the shell shows it from launch until the first page load (`splash.autoHide`, the default) or
+ * until the app calls hide(), and at the latest until `splash.timeout`.
+ * iOS: the launch screen, then a matching cover over the WebView. Android: the system splash
+ * screen, kept up until hide. Web and desktop have no splash (desktop windows appear after the
+ * first page load instead), so hide() resolves right away there.
+ */
+export interface SplashScreenApi {
+    /**
+     * Hides the splash, fading out over `fadeOutDuration` ms (default 200). Resolves at once, also
+     * when the splash is already gone, so it is safe to call whenever the UI is ready. With
+     * `splash.autoHide: false`, call it once the first screen has rendered.
+     */
+    hide(options?: {
+        fadeOutDuration?: number;
+    }): Promise<void>;
+}
+export declare const splashScreen: import("../../../packages/core/src/plugin.ts").Plugin<SplashScreenApi, {}>;

package/types/vendor/@akanjs/native/plugins/splash-screen/src/web.d.ts

@@ -0,0 +1,4 @@
+import type { SplashScreenApi } from "./index.ts";
+/** Browsers and the desktop WebView have no splash to hide. Arguments are still checked. */
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<SplashScreenApi, {}>;
+export declare function checkFade(value: unknown): void;

package/types/vendor/@akanjs/native/plugins/splash-screen/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/sqlite/src/common.d.ts

@@ -0,0 +1,34 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+/** Largest integer a JS number holds exactly: bigger integers bind as REAL on every platform. */
+export declare const MAX_SAFE: number;
+/**
+ * A database file name, never a path: no separators or "..", and no name that would collide with
+ * another database's -journal, -wal or -shm file.
+ */
+export declare function checkName(name: unknown): string;
+export declare function checkDb(db: unknown): string;
+/**
+ * How many statements `sql` holds, finding their ends the way sqlite3_complete() does. Only
+ * whitespace, comments and ";" is 0. An unterminated quote or comment runs to the end of the text
+ * (the statement is then SQLite's syntax error to report).
+ */
+export declare function countStatements(sql: string): number;
+/**
+ * Statements that reach files outside the app's databases: ATTACH opens any SQLite file the app
+ * can read or write, VACUUM INTO writes one anywhere. The filesystem plugin's scopes do not apply
+ * to them, so they are refused (the same rule in ios/SqlitePlugin.swift and android/SqlStatements.kt).
+ */
+export declare function refusedStatement(sql: string): string | null;
+export declare function checkSql(sql: unknown): string;
+export declare function base64ToBytes(data: string): Uint8Array | null;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export type Bound = string | number | bigint | null | Uint8Array;
+/**
+ * params → values to bind: integers within ±(2^53 − 1) and booleans as bigint (bun:sqlite binds a
+ * number as INTEGER only below 2^52 and -0 as REAL: checked), other numbers as REAL, { base64 } as
+ * bytes.
+ */
+export declare function checkParams(params: unknown): Bound[];
+/** A column value as the bridge carries it (see SqlValue). */
+export declare function columnValue(value: unknown): unknown;
+export declare function sqliteCode(extended: number): AkanNativeError["code"];

package/types/vendor/@akanjs/native/plugins/sqlite/src/desktop.d.ts

@@ -0,0 +1,6 @@
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { SqliteSpec } from "./index.ts";
+/** `dir` is replaceable so tests can use a temporary folder. */
+export declare function createDesktopSqlite(dir?: (ctx: DesktopContext) => string): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<SqliteSpec, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<SqliteSpec, {}>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/sqlite/src/index.d.ts

@@ -0,0 +1,115 @@
+import { type Plugin } from "../../../packages/core/src/index.ts";
+/**
+ * A value bound to a `?` parameter or read from a column. The same rules hold on macOS, iOS and
+ * Android:
+ * - number: an integer within ±(2^53 − 1) binds as INTEGER, any other number as REAL (bun:sqlite's
+ *   rule). Columns come back as numbers; INTEGER values beyond 2^53 lose precision, as in JSON.
+ *   REAL infinities come back as null (JSON has no Infinity).
+ * - boolean: binds as 1 or 0 (SQLite has no boolean type) and reads back as a number.
+ * - BLOB: `{ base64 }` both ways (standard alphabet, padding optional when binding). An empty
+ *   `{ base64: "" }` is a zero-length BLOB, not NULL.
+ * - string: TEXT, UTF-8 in the file. NUL characters are kept.
+ */
+export type SqlValue = string | number | boolean | null | SqlBlob;
+export interface SqlBlob {
+    base64: string;
+}
+/** A result row: column name → value. Later columns with the same name replace earlier ones (alias them). */
+export type SqlRow = Record<string, SqlValue>;
+export interface SqlStatement {
+    /** A handle from open(). */
+    db: string;
+    /**
+     * One SQL statement; a trailing ";" and comments are fine. More than one statement rejects
+     * INVALID_ARGS instead of running only the first (what SQLite's prepare, Android and bun:sqlite
+     * would otherwise do silently): send them one call at a time.
+     */
+    sql: string;
+    /** Positional values for `?`, `?NNN`, `:name` parameters (by index). The count must match the statement's. */
+    params?: SqlValue[];
+}
+export interface ExecuteResult {
+    /**
+     * Rows inserted, updated or deleted by this statement, including rows changed by triggers and
+     * foreign key actions (the difference of sqlite3_total_changes()); 0 for other statements.
+     */
+    changes: number;
+    /** sqlite3_last_insert_rowid() of the connection after the statement: the rowid of the most recent successful INSERT, 0 if none. */
+    lastInsertId: number;
+}
+export interface QueryResult<T extends SqlRow = SqlRow> {
+    /** Result column names in order (also for an empty result; rows are objects, whose key order is not guaranteed on iOS). */
+    columns: string[];
+    rows: T[];
+}
+/**
+ * SQLite databases in the app's data folder, with the SQLite that ships with the OS: libsqlite3 on
+ * iOS, android.database.sqlite on Android, bun:sqlite on desktop. Not available on the web.
+ *
+ * - Files: `<name>` in Library/Application Support/databases (iOS), the app's databases folder
+ *   (Android, Context.getDatabasePath), `<app data>/databases` (desktop). Kept until the app is
+ *   removed.
+ * - A handle belongs to the page that opened it (architecture review, 2026-09-26): each page load
+ *   (and each desktop window) has its own connection, and when the page reloads, navigates or its
+ *   window closes, an open transaction is rolled back and the connection closed. Call open() after
+ *   every page load; open() of a name this page already opened returns it again.
+ * - Every database opens with `PRAGMA foreign_keys = ON` and a 5 s busy timeout. The journal is
+ *   WAL on the desktop and iOS, where several windows' connections may share a file; Android keeps
+ *   journal_mode DELETE (its WAL uses a pool of connections, and a statement's connection state
+ *   would depend on the connection it lands on; Android's windows never overlap in one process).
+ * - Calls run one at a time off the main thread, in call order, for all databases together.
+ *   Transactions: `execute({ sql: "BEGIN" })` … `"COMMIT"` / `"ROLLBACK"`. On Android BEGIN, COMMIT
+ *   and ROLLBACK must start the statement text (Android runs them itself), and SAVEPOINT works
+ *   only inside BEGIN … COMMIT.
+ * - Errors: INVALID_ARGS for bad arguments and for SQL errors (syntax, missing table, constraint
+ *   violations, with SQLite's message), NOT_FOUND for a db that is not open, INTERNAL for I/O and
+ *   other failures.
+ */
+export interface SqliteApi {
+    /**
+     * Opens (creating if needed) the database file `name`: letters, digits, ".", "_" and "-", up to
+     * 128 characters, starting with a letter or digit, not ending in -journal, -wal or -shm. The
+     * handle is the name.
+     */
+    open(args: {
+        name: string;
+    }): Promise<{
+        db: string;
+    }>;
+    /** Runs a statement and discards any rows it returns. */
+    execute(args: SqlStatement): Promise<ExecuteResult>;
+    /** Runs a statement and returns its rows (any statement: SELECT, `INSERT … RETURNING`, PRAGMA). */
+    query<T extends SqlRow = SqlRow>(args: SqlStatement): Promise<QueryResult<T>>;
+    /** Closes the database. Closing a database that is not open does nothing. */
+    close(args: {
+        db: string;
+    }): Promise<void>;
+}
+/** The arguments of execute and query as the host receives them. */
+export interface StatementArgs {
+    db: string;
+    sql: string;
+    /** SqlValue items; the hosts check them (the generator cannot express a union of primitives). */
+    params?: unknown[];
+}
+/**
+ * The bridge shape of SqliteApi, the spec the Swift and Kotlin bindings are generated from (PL-10):
+ * params and row values are `unknown` because a union of primitives has no generated form.
+ */
+export interface SqliteSpec {
+    open(args: {
+        name: string;
+    }): Promise<{
+        db: string;
+    }>;
+    execute(args: StatementArgs): Promise<ExecuteResult>;
+    query(args: StatementArgs): Promise<{
+        columns: string[];
+        rows: Record<string, unknown>[];
+    }>;
+    close(args: {
+        db: string;
+    }): Promise<void>;
+}
+/** The hosts return only SqlValue items, so the typed facade is the same object. */
+export declare const sqlite: Plugin<SqliteApi>;

package/types/vendor/@akanjs/native/plugins/sqlite/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/toast/src/index.d.ts

@@ -0,0 +1,30 @@
+export { checkShow, createToastQueue, MAX_QUEUED, TOAST_DURATION_MS, type ToastItem } from "./queue.ts";
+/** "short" shows the toast for 2 s, "long" for 3.5 s (Android's Toast.LENGTH_SHORT / LENGTH_LONG). */
+export type ToastDuration = "short" | "long";
+/** Where the toast appears. Android shows text toasts at the bottom whatever is asked (see show). */
+export type ToastPosition = "top" | "center" | "bottom";
+export interface ToastShowOptions {
+    /** The message, not empty. Android 12+ cuts text toasts to two lines. */
+    text: string;
+    /** Default "short". */
+    duration?: ToastDuration;
+    /** Default "bottom". Ignored on Android. */
+    position?: ToastPosition;
+}
+/**
+ * A short message that goes away by itself (plugins.md §4.2), with the options of
+ * capacitor-plugins/toast/src/definitions.ts. It does not take touches or focus.
+ *
+ * Android shows the system Toast. Web, macOS and iOS show the same in-page toast, which stays
+ * above the app's own layers (the top layer, also above open dialogs) and is read by screen
+ * readers through a live region. On every platform toasts queue up and show one after another,
+ * as Android's do; at most 5 wait at a time, more are dropped (Android drops them as well).
+ */
+export interface ToastApi {
+    /**
+     * Resolves once the toast is queued or shown, not when it goes away. Rejects INVALID_ARGS for
+     * empty text or an unknown duration or position.
+     */
+    show(options: ToastShowOptions): Promise<void>;
+}
+export declare const toast: import("../../../packages/core/src/plugin.ts").Plugin<ToastApi, {}>;

package/types/vendor/@akanjs/native/plugins/toast/src/queue.d.ts

@@ -0,0 +1,23 @@
+import type { ToastDuration, ToastPosition } from "./index.ts";
+/** Android's toast lengths (NotificationManagerService SHORT_DELAY / LONG_DELAY), also capacitor-plugins/toast/src/web.ts:8-10. */
+export declare const TOAST_DURATION_MS: Readonly<Record<ToastDuration, number>>;
+/** Toasts of one app that may be waiting or showing at once; Android drops more (MAX_PACKAGE_TOASTS). */
+export declare const MAX_QUEUED = 5;
+export interface ToastItem {
+    text: string;
+    duration: ToastDuration;
+    position: ToastPosition;
+    /** How long the toast stays fully visible. */
+    ms: number;
+}
+/** Checks show()'s options the way the Android plugin does (generated checks plus the empty text). */
+export declare function checkShow(options: unknown): ToastItem;
+/**
+ * One toast at a time, in order, like Android's toast queue. `display` resolves once its toast is
+ * gone. `push` returns false when MAX_QUEUED toasts are already waiting or showing (the toast is dropped).
+ */
+export declare function createToastQueue(display: (item: ToastItem) => Promise<void>, max?: number): {
+    push(item: ToastItem): boolean;
+    /** Waiting plus showing. */
+    readonly size: number;
+};

package/types/vendor/@akanjs/native/plugins/toast/src/web.d.ts

@@ -0,0 +1,2 @@
+import type { ToastApi } from "./index.ts";
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<ToastApi, {}>;

package/types/vendor/@akanjs/native/plugins/toast/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

package/types/vendor/@akanjs/native/plugins/tray/src/desktop.d.ts

@@ -0,0 +1,3 @@
+import type { TrayApi, TrayEvents } from "./index.ts";
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<TrayApi, TrayEvents>;
+export default _default;