akanjs 3.0.0-beta.8 → 3.0.0

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

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

package/types/vendor/@akanjs/native/plugins/app-state/src/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * - active: visible and receiving input
+ * - inactive: visible but not focused (another window, system overlay, app switcher)
+ * - background: not visible
+ */
+export type AppStateValue = "active" | "inactive" | "background";
+export interface AppStateApi {
+    getState(): Promise<{
+        state: AppStateValue;
+    }>;
+}
+/** moderate: the system is running low; critical: it is about to end processes, likely this one. */
+export type MemoryWarningLevel = "moderate" | "critical";
+export interface AppStateEvents {
+    change: {
+        state: AppStateValue;
+    };
+    /** The system asked the app to give memory back: iOS's memory warning, Android's onTrimMemory and onLowMemory. */
+    memoryWarning: {
+        level: MemoryWarningLevel;
+    };
+}
+export declare const appState: import("../../../packages/core/src/plugin.ts").Plugin<AppStateApi, AppStateEvents>;
+/** The current app state. Re-renders on every change (SH-1). */
+export declare function useAppState(): AppStateValue;

package/types/vendor/@akanjs/native/plugins/app-state/src/web.d.ts

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

package/types/vendor/@akanjs/native/plugins/app-state/src.d.ts

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

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

@@ -0,0 +1,9 @@
+import type { AppearanceApi, AppearanceEvents } from "./index.ts";
+export type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stdout: string;
+}>;
+/** `run` is replaceable so tests can check the commands and shell ops, `platform` to test the other OSes' fallback. */
+export declare function createDesktopAppearance(run?: Runner, platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AppearanceApi, AppearanceEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AppearanceApi, AppearanceEvents>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import type { AppearanceSetting, ColorScheme } from "./setting.ts";
+export { APPEARANCE_SETTINGS, type AppearanceSetting, type ColorScheme, checkSetting } from "./setting.ts";
+export interface AppearanceState {
+    /** The scheme the app is drawn in right now; the page's `prefers-color-scheme` matches it. */
+    mode: ColorScheme;
+    /** The app's setting. Always "system" on the web and until set() was called. */
+    setting: AppearanceSetting;
+}
+/**
+ * Light/dark appearance of the app (plugins.md §4.1). To only follow the OS, CSS
+ * `prefers-color-scheme` is enough; this plugin is for apps with their own theme switch.
+ */
+export interface AppearanceApi {
+    get(): Promise<AppearanceState>;
+    /**
+     * Forces light or dark for the whole app (WebView, system UI such as dialogs, keyboards and
+     * status bar icons), or goes back to the OS setting with "system". The setting is kept across
+     * launches and applied at start (on iOS and Android before the first paint), so call it when the
+     * user picks a theme, not at every start. The change event follows once the app redrew. Not
+     * available on the web (UNSUPPORTED): a page cannot change `prefers-color-scheme`.
+     */
+    set(args: {
+        mode: AppearanceSetting;
+    }): Promise<void>;
+}
+export interface AppearanceEvents {
+    /** `mode` or `setting` changed: an OS switch while following the system, or set(). */
+    change: AppearanceState;
+}
+export declare const appearance: import("../../../packages/core/src/plugin.ts").Plugin<AppearanceApi, AppearanceEvents>;
+/** The current appearance. Re-renders on every change. */
+export declare function useAppearance(): AppearanceState;

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

@@ -0,0 +1,6 @@
+export type ColorScheme = "light" | "dark";
+/** What the app asked for: a fixed scheme, or "system" to follow the OS setting. */
+export type AppearanceSetting = ColorScheme | "system";
+export declare const APPEARANCE_SETTINGS: readonly AppearanceSetting[];
+/** Checks set()'s argument; the native implementations check the same list. */
+export declare function checkSetting(mode: unknown): AppearanceSetting;

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

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

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

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

package/types/vendor/@akanjs/native/plugins/auth-session/src/args.d.ts

@@ -0,0 +1,18 @@
+export interface StartArgs {
+    url: URL;
+    callbackScheme: string;
+    ephemeral: boolean;
+}
+/** Checks start()'s arguments; the native implementations check the same rules. */
+export declare function checkStart(args: unknown): StartArgs;
+/** Whether `url` is a callback for `scheme` (schemes compare case-insensitively). */
+export declare function isCallback(url: string, scheme: string): boolean;
+/** The `state` parameter of a URL's query, or of its fragment (implicit flows), or null. */
+export declare function stateOf(url: string): string | null;
+/**
+ * Whether a link is the answer to this sign-in. Any app, or a web page linking to the scheme, can
+ * send a link of the callback scheme while start() waits; when the start URL carries OAuth's
+ * `state`, only a callback with the same `state` is taken (RFC 6749 §10.12) and others are left
+ * to the app plugin. PKCE is still the app's (RFC 8252 §8.1).
+ */
+export declare function isAnswer(url: string, scheme: string, state: string | null): boolean;

package/types/vendor/@akanjs/native/plugins/auth-session/src/desktop.d.ts

@@ -0,0 +1,17 @@
+import type { AuthSessionApi } from "./index.ts";
+export declare const TIMEOUT_MS: number;
+export type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stderr: string;
+}>;
+/** CFBundleURLSchemes of an XML Info.plist (the CLI writes XML), or null if there is none to read. */
+export declare function registeredSchemes(plist: string | null): string[] | null;
+/** Replaceable parts for tests: the command runner, the Info.plist text, the OS and the timeout. */
+export declare function createDesktopAuthSession(options?: {
+    run?: Runner;
+    plist?: () => string | null;
+    timeoutMs?: number;
+    platform?: NodeJS.Platform;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AuthSessionApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AuthSessionApi, {}>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/auth-session/src/index.d.ts

@@ -0,0 +1,41 @@
+export { checkStart, isCallback } from "./args.ts";
+/**
+ * OAuth / OpenID sign-in in the system browser (plugins.md §4.5, like Expo's
+ * WebBrowser.openAuthSessionAsync): shows the provider's page and returns the redirect to
+ * `callbackScheme` with the result (code, state, error) in its query or fragment. The app then
+ * exchanges the code itself (PKCE); this plugin does not parse or validate the result.
+ *
+ * The callback scheme must be one of the app's deep link schemes (akan-native.config.ts
+ * `deepLinks.schemes`): Android and macOS receive the redirect as a deep link, so the app's
+ * `urlOpen` listeners see it too there. iOS catches it inside the session.
+ *
+ * | host    | how                                              | cancel detection                         |
+ * |---------|--------------------------------------------------|------------------------------------------|
+ * | iOS     | ASWebAuthenticationSession                       | the user closed the sheet                |
+ * | Android | Custom Tab + deep link (plain browser if none)   | back in the app without the redirect     |
+ * | macOS   | default browser + deep link (TAO Event::Opened)  | none: a new start() or 10 minutes        |
+ * | web     | UNSUPPORTED                                      |                                          |
+ *
+ * The web has no custom-scheme callback to catch: web apps register an https redirect on their
+ * own origin and read the result on that route (full-page redirect, or a popup posting to its
+ * opener), which depends on the app's routing and is left to the app.
+ */
+export interface AuthSessionApi {
+    /**
+     * Resolves with the callback URL. Rejects CANCELLED when the user dismissed the page, came back
+     * without finishing (Android), or a newer start() replaced this one; INVALID_ARGS for a bad URL
+     * or scheme (Android also when the app does not handle the scheme). `ephemeral` (iOS) signs in
+     * without the browser's cookies and skips the "wants to use … to sign in" prompt.
+     * The callback that ends a start() is its result only: it does not also reach app.urlOpen, on any
+     * platform. A link of the scheme that arrives with no start() waiting (or with another state) is
+     * an ordinary deep link.
+     */
+    start(args: {
+        url: string;
+        callbackScheme: string;
+        ephemeral?: boolean;
+    }): Promise<{
+        url: string;
+    }>;
+}
+export declare const authSession: import("../../../packages/core/src/plugin.ts").Plugin<AuthSessionApi, {}>;

package/types/vendor/@akanjs/native/plugins/auth-session/src.d.ts

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

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

@@ -0,0 +1,44 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { AutostartApi, AutostartStatus } from "./index.ts";
+export interface ShellError {
+    reason: "alreadyRegistered" | "notRegistered" | "deniedByUser" | "invalidSignature" | "other";
+    code: number;
+    domain: string;
+    message: string;
+}
+export interface ShellAnswer {
+    status: AutostartStatus;
+    error?: ShellError | null;
+}
+/** The error an enable/disable answer stands for, or null when the app is where it was asked to be. */
+export declare function failure(op: "enable" | "disable", answer: ShellAnswer, platform?: NodeJS.Platform): AkanNativeError | null;
+type Env = Record<string, string | undefined>;
+/** $XDG_CONFIG_HOME/autostart; the base directory must be absolute (XDG Base Directory spec). */
+export declare function autostartDir(env?: Env, home?: string): string;
+/**
+ * The Exec= value that runs `path`: one quoted argument (Desktop Entry spec, "The Exec key").
+ * Inside quotes `"`, `` ` ``, `$` and `\` take a backslash; then the string escaping of values
+ * doubles every backslash, and a literal `%` is `%%` (field codes).
+ */
+export declare function desktopExec(path: string): string;
+export declare function desktopEntry(name: string, exec: string): string;
+/**
+ * The state an entry stands for. Hidden=true (the spec's "deleted") or
+ * X-GNOME-Autostart-enabled=false (GNOME's startup settings) is an entry the user switched off.
+ */
+export declare function entryStatus(text: string | null): AutostartStatus;
+/** `executable`: the file the entry starts; an AppImage's mount point changes at every start, $APPIMAGE does not. */
+export declare function linuxAutostart(dir?: () => string, executable?: () => string): {
+    status: (ctx: DesktopContext) => ShellAnswer;
+    enable(ctx: DesktopContext): ShellAnswer;
+    disable(ctx: DesktopContext): ShellAnswer;
+};
+/** `platform` and `linux` are replaceable so tests can check every OS's path on any OS. */
+export declare function createDesktopAutostart(platform?: NodeJS.Platform, linux?: {
+    status: (ctx: DesktopContext) => ShellAnswer;
+    enable(ctx: DesktopContext): ShellAnswer;
+    disable(ctx: DesktopContext): ShellAnswer;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AutostartApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AutostartApi, {}>;
+export default _default;

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

@@ -0,0 +1,44 @@
+/**
+ * Launch the app when the user logs in (plugins.md §5).
+ *
+ * - macOS 13+: SMAppService.mainApp. The app itself becomes a login item under System Settings ›
+ *   General › Login Items › "Open at Login"; no permission prompt, but macOS shows a "Login Item
+ *   Added" notification. The user can switch it off there: then `status` is "requiresApproval"
+ *   and enable() rejects with PERMISSION_DENIED; openSettings() takes the user to that page.
+ * - `status` is macOS's own (SMAppService.Status):
+ *     "enabled": registered and will launch at login.
+ *     "notRegistered": not registered (typically after disable()).
+ *     "requiresApproval": registered, but switched off by the user in System Settings.
+ *     "notFound": macOS has no login item record for this app, e.g. it never called enable().
+ *       Seen on macOS 26 for an ad-hoc signed bundle that never registered; not an error.
+ *   `enabled` is `status === "enabled"`.
+ * - The registration belongs to the app bundle: enable() it from the copy users run, normally
+ *   the one in /Applications. A bundle whose signature macOS does not accept is refused
+ *   (INTERNAL, "invalid signature").
+ * - enable() when enabled and disable() when not are no-ops that resolve.
+ * - Windows: a value named after the app id under HKCU\Software\Microsoft\Windows\CurrentVersion\Run
+ *   that starts this .exe. The user can switch it off in Settings › Apps › Startup or Task Manager:
+ *   then `status` is "requiresApproval" and enable() rejects with PERMISSION_DENIED; openSettings()
+ *   opens that page. disable() removes the value and that switch. Never "notFound".
+ * - Linux: an XDG autostart entry, ~/.config/autostart/<app id>.desktop, that starts this
+ *   executable ($APPIMAGE for an AppImage). An entry the user switched off (Hidden=true,
+ *   X-GNOME-Autostart-enabled=false) reads "requiresApproval", and enable() switches it on again:
+ *   Linux has no approval system. openSettings() is UNSUPPORTED (no common settings page). Never "notFound".
+ * - Web, iOS and Android: UNSUPPORTED.
+ */
+export type AutostartStatus = "enabled" | "notRegistered" | "requiresApproval" | "notFound";
+export interface AutostartState {
+    enabled: boolean;
+    status: AutostartStatus;
+}
+export interface AutostartApi {
+    /** Registers the app to open at login. */
+    enable(): Promise<AutostartState>;
+    /** Stops opening at login. The running app keeps running. */
+    disable(): Promise<AutostartState>;
+    /** Reads the state without changing it. */
+    isEnabled(): Promise<AutostartState>;
+    /** Opens System Settings at Login Items, or Settings › Apps › Startup on Windows (to switch a "requiresApproval" item back on). */
+    openSettings(): Promise<void>;
+}
+export declare const autostart: import("../../../packages/core/src/plugin.ts").Plugin<AutostartApi, {}>;

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

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

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

@@ -0,0 +1,4 @@
+/** The largest count: badges are 32-bit integers on iOS (UNUserNotificationCenter.setBadgeCount takes an NSInteger, tauri clamps to i32). */
+export declare const MAX_BADGE_COUNT = 2147483647;
+/** Checks set()'s count; the native implementation checks the same range. */
+export declare function checkCount(count: unknown): number;

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

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

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

@@ -0,0 +1,37 @@
+export { checkCount, MAX_BADGE_COUNT } from "./count.ts";
+export type PermissionState = "granted" | "denied" | "prompt";
+/**
+ * The number on the app icon (plugins.md §4.6).
+ *
+ * - iOS: UNUserNotificationCenter.setBadgeCount. Badges are part of the notification permission:
+ *   set() rejects PERMISSION_DENIED until requestPermission() was granted, or when the user
+ *   switched badges off for the app. The prompt asks for alerts, sounds and badges together
+ *   (one prompt per app), the same set as @akanjs/native/plugins/local-notifications.
+ * - Web: the Badging API (navigator.setAppBadge), shown for installed web apps (Chromium PWAs;
+ *   Safari home screen / Dock web apps, which also need the notification permission). Browsers
+ *   without it reject UNSUPPORTED. The API has no permission of its own, so the permission
+ *   methods answer "granted" there.
+ * - Desktop, through the dock plugin's badge (no permission, "granted"): the Dock tile's label on
+ *   macOS; on Windows the taskbar buttons' overlay icon (counts over 99 as "99+"); on Linux the
+ *   launcher entry's count, shown by docks that support it once the app is installed with its
+ *   desktop file (@akanjs/native/plugins/dock).
+ * - Android has no badge API (launchers draw dots for notifications): every method rejects
+ *   UNSUPPORTED there.
+ */
+export interface BadgeApi {
+    /** Shows `count` (an integer from 0 to 2147483647) on the app icon; 0 removes the badge. */
+    set(options: {
+        count: number;
+    }): Promise<void>;
+    /** Removes the badge. Resolves without the permission as well (no badge can be shown then). */
+    clear(): Promise<void>;
+    /** Never prompts. */
+    checkPermission(): Promise<{
+        badge: PermissionState;
+    }>;
+    /** Prompts when the state is "prompt"; otherwise answers like checkPermission. */
+    requestPermission(): Promise<{
+        badge: PermissionState;
+    }>;
+}
+export declare const badge: import("../../../packages/core/src/plugin.ts").Plugin<BadgeApi, {}>;

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

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

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

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

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

@@ -0,0 +1,53 @@
+/** The kind of biometric sensor. iOS Optic ID counts as "iris". */
+export type BiometryType = "face" | "fingerprint" | "iris" | "none";
+/**
+ * Why biometrics cannot be used right now.
+ * - noHardware: no sensor
+ * - notEnrolled: nothing enrolled, or (iOS) no passcode, which biometrics require
+ * - lockedOut: too many failed attempts; the passcode unlocks it again (allowDeviceCredential)
+ * - denied: the user turned biometrics off for this app (iOS Face ID setting, Android "use for apps")
+ * - notConfigured: the app lacks NSFaceIDUsageDescription (iOS; the manifest adds it)
+ * - unavailable: anything else (sensor busy, security update required)
+ */
+export type BiometricUnavailableReason = "noHardware" | "notEnrolled" | "lockedOut" | "denied" | "notConfigured" | "unavailable";
+export interface BiometricStatus {
+    /** Whether authenticate() can use biometrics now. */
+    available: boolean;
+    /** The sensor kind, also when nothing is enrolled. On Android with several sensors, the first of fingerprint, face, iris. */
+    type: BiometryType;
+    /** Set when not available. */
+    reason?: BiometricUnavailableReason;
+    /** Whether a passcode / PIN / pattern is set, i.e. whether allowDeviceCredential can succeed. */
+    deviceCredential: boolean;
+}
+export interface AuthenticateOptions {
+    /** Why the app asks. iOS shows it under "Face ID"; Android uses it as the title, or as the subtitle when `title` is set. */
+    reason: string;
+    /** Android: prompt title. */
+    title?: string;
+    /** Label of the cancel button. Android ignores it with allowDeviceCredential (the system prompt has its own). */
+    cancelTitle?: string;
+    /**
+     * Also accept the device passcode / PIN / pattern (iOS .deviceOwnerAuthentication, Android
+     * DEVICE_CREDENTIAL). Default false: biometrics only, and iOS hides its "Enter Password" button.
+     */
+    allowDeviceCredential?: boolean;
+}
+/**
+ * Local user verification (Face ID, Touch ID, fingerprint, face unlock). A successful
+ * authenticate() proves presence to this app only; it unlocks no key and must not replace a
+ * server-side login.
+ *
+ * authenticate() rejects with
+ * - CANCELLED: the user or the system cancelled (app sent to the background, another prompt)
+ * - PERMISSION_DENIED: not enrolled, locked out, turned off for the app, or (iOS) failed attempts
+ * - UNSUPPORTED: no sensor (and no allowed passcode fallback); every call on the web and macOS
+ * - INTERNAL: NSFaceIDUsageDescription missing (iOS) and other platform failures
+ */
+export interface BiometricApi {
+    isAvailable(): Promise<BiometricStatus>;
+    authenticate(options: AuthenticateOptions): Promise<void>;
+}
+export declare const biometric: import("../../../packages/core/src/plugin.ts").Plugin<BiometricApi, {}>;
+/** The biometric status, or null while it loads and where the platform has no biometric plugin (web, macOS). */
+export declare function useBiometricStatus(): BiometricStatus | null;

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * http and https only: SFSafariViewController takes nothing else (capacitor-plugins/browser/ios/
+ * Sources/BrowserPlugin/Browser.swift:19) and Custom Tabs are browser tabs. Other schemes belong
+ * to the opener plugin. The native implementations check the same rules.
+ */
+export declare function checkUrl(url: unknown): URL;
+/** "#rrggbb" or undefined. Capacitor logs and ignores a bad color; here it is INVALID_ARGS. */
+export declare function checkColor(color: unknown): string | undefined;

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

@@ -0,0 +1,9 @@
+import type { BrowserApi, BrowserEvents } from "./index.ts";
+export type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stderr: string;
+}>;
+/** `run` is replaceable so tests can check the command without opening a browser, `platform` to test the shell op path. */
+export declare function createDesktopBrowser(run?: Runner, platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<BrowserApi, BrowserEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<BrowserApi, BrowserEvents>;
+export default _default;

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

@@ -0,0 +1,36 @@
+export { checkColor, checkUrl } from "./args.ts";
+/**
+ * In-app browser (plugins.md §4.5): a system browser view over the app, sharing the browser's
+ * cookies and passwords, with the page's URL visible to the user. For signing in, use
+ * auth-session instead, which also returns the redirect.
+ *
+ * | host    | view                                   | close()     | finished                 |
+ * |---------|----------------------------------------|-------------|--------------------------|
+ * | iOS     | SFSafariViewController                 | ✓           | ✓                        |
+ * | Android | Custom Tab                             | ✓           | ✓                        |
+ * | Android | plain browser (no Custom Tabs browser) | UNSUPPORTED | never                    |
+ * | web     | new window (popup)                     | ✓           | ✓ (polled, ≤ 0.5 s late) |
+ * | desktop | the default browser                    | UNSUPPORTED | never                    |
+ */
+export interface BrowserApi {
+    /**
+     * Shows `url` (http or https) and resolves once the browser is up. One at a time: rejects
+     * INVALID_ARGS while a browser opened here is still showing. `toolbarColor` ("#rrggbb") colors the
+     * Custom Tab toolbar on Android; iOS 26 no longer tints Safari's bars and ignores it.
+     * PERMISSION_DENIED on the web when the popup was blocked (call it from a click) and on Android
+     * while the app is not in front (Android 15+ blocks activity starts from the background).
+     */
+    open(args: {
+        url: string;
+        toolbarColor?: string;
+    }): Promise<void>;
+    /** Closes the browser opened by open(). Resolves also when none is showing. Does not send `finished`. */
+    close(): Promise<void>;
+}
+export interface BrowserEvents {
+    /** The user closed the browser (Done, back, or closed the window). */
+    finished: Record<string, never>;
+}
+export declare const browser: import("../../../packages/core/src/plugin.ts").Plugin<BrowserApi, BrowserEvents>;
+/** Calls `handler` whenever the user closes the in-app browser, while mounted. */
+export declare function useBrowserFinished(handler: () => void): void;

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { CameraApi, PermissionState } from "./index.ts";
+/** AVAuthorizationStatus: 0 notDetermined, 1 restricted, 2 denied, 3 authorized. */
+export declare function permissionState(status: unknown): PermissionState;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<CameraApi, {}>;
+export default _default;

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

@@ -0,0 +1,55 @@
+import { AkanNativeError, type FileRef } from "../../../packages/core/src/index.ts";
+export type PermissionState = "granted" | "denied" | "prompt";
+export interface TakePhotoOptions {
+    /** "camera" (default) captures a new photo, "library" picks an existing one. */
+    source?: "camera" | "library";
+    direction?: "rear" | "front";
+    /** JPEG quality 1-100 when the photo is encoded. Default 90. */
+    quality?: number;
+    /** Largest width in pixels. Default: none. */
+    maxWidth?: number;
+    /** Largest height in pixels. Default: none. */
+    maxHeight?: number;
+}
+/** A photo served by the host (`/__akan_native/file/<id>`) or, on the web, a blob: URL. Always image/jpeg (see above). */
+export interface Photo extends FileRef {
+    width?: number;
+    height?: number;
+}
+export interface PickImagesOptions {
+    /** Maximum number of images, 1–20. Default 10. */
+    limit?: number;
+    /** JPEG quality 1-100 when a photo is encoded. Default 90. */
+    quality?: number;
+    /** Largest width in pixels. Default: none. */
+    maxWidth?: number;
+    /** Largest height in pixels. Default: none. */
+    maxHeight?: number;
+}
+export interface CameraApi {
+    takePhoto(options?: TakePhotoOptions): Promise<Photo>;
+    /** Picks existing images from the library; no permission needed on iOS and Android. */
+    pickImages(options?: PickImagesOptions): Promise<{
+        photos: Photo[];
+    }>;
+    /** Saves a photo (a FileRef URL from this app) to the device's photo library. */
+    saveToGallery(args: {
+        url: string;
+    }): Promise<void>;
+    checkPermission(): Promise<{
+        camera: PermissionState;
+    }>;
+    requestPermission(): Promise<{
+        camera: PermissionState;
+    }>;
+}
+export declare const camera: import("../../../packages/core/src/plugin.ts").Plugin<CameraApi, {}>;
+export interface UseCamera {
+    supported: boolean;
+    photo: Photo | null;
+    pending: boolean;
+    /** Last failure. A cancelled capture is not an error and leaves this null. */
+    error: AkanNativeError | null;
+    takePhoto(options?: TakePhotoOptions): Promise<Photo | null>;
+}
+export declare function useCamera(): UseCamera;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { ClipboardApi } from "./index.ts";
+/**
+ * `pasteboard` is a pbcopy -pboard name; tests use "ruler" to leave the user's clipboard alone.
+ * `platform` lets tests check the shell ops of Windows and Linux on any OS.
+ */
+export declare function createDesktopClipboard(pasteboard?: "general" | "ruler" | "find" | "font", platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<ClipboardApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<ClipboardApi, {}>;
+export default _default;

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

@@ -0,0 +1,40 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+/**
+ * Plain text on the system clipboard.
+ *
+ * readText resolves `{ text: "" }` when the clipboard holds no text. It may reject:
+ * - PERMISSION_DENIED
+ *   - iOS 16+: the user answered "Don't Allow" to the paste prompt, shown when another app copied the text
+ *   - Android 10+: the app does not have window focus
+ *   - web: the browser refused (Chrome asks for clipboard-read permission, Safari and Firefox show a
+ *     "Paste" button that must be clicked, both need a user gesture)
+ * - UNSUPPORTED on the web without `navigator.clipboard.readText` (insecure http:// origin, older browsers)
+ *
+ * writeText needs a user gesture on the web (and a focused document in Chrome); without
+ * `navigator.clipboard` it falls back to `execCommand("copy")`, which also needs the gesture.
+ */
+export interface ClipboardApi {
+    writeText(args: {
+        text: string;
+    }): Promise<void>;
+    readText(): Promise<{
+        text: string;
+    }>;
+}
+export declare const clipboard: import("../../../packages/core/src/plugin.ts").Plugin<ClipboardApi, {}>;
+export interface UseClipboard {
+    supported: boolean;
+    /** True for `resetAfter` ms after a successful copy, for "Copied" feedback next to the button. */
+    copied: boolean;
+    /** Last copy failure. */
+    error: AkanNativeError | null;
+    /** Copies text; resolves false (and sets `error`) instead of throwing. */
+    copy(text: string): Promise<boolean>;
+}
+/**
+ * Copy-button helper. Android 13+ already shows a system confirmation after copying, so show
+ * `copied` in place (e.g. the button label) rather than as an extra toast.
+ */
+export declare function useClipboard(options?: {
+    resetAfter?: number;
+}): UseClipboard;

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

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

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

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

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

@@ -0,0 +1,43 @@
+/** "prompt-with-rationale" is Android's: asked and refused once, so the app should explain before asking again. */
+export type PermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+export interface ContactPhone {
+    /** As the address book stores it: no normalization, so "010-1234-5678" and "+82 10 1234 5678" both occur. */
+    number: string;
+    /** The label shown in the system Contacts app ("mobile", "home", a custom one), localized; null when unlabeled. */
+    label: string | null;
+}
+export interface Contact {
+    /** Stable for this contact on this device only. */
+    id: string;
+    /** The display name the system Contacts app shows; null when not projected or the contact has none. */
+    name: string | null;
+    /** Empty when not projected. */
+    phones: ContactPhone[];
+}
+/** What to read for each contact. Both default to true; leave out what the screen does not need. */
+export interface GetContactsOptions {
+    projection?: {
+        name?: boolean;
+        phones?: boolean;
+    };
+}
+/**
+ * Reads the device's address book (iOS Contacts, Android ContactsContract); there is no web or desktop
+ * implementation, so every call there rejects with UNSUPPORTED.
+ * - "granted" on iOS 18 also covers limited access: getContacts returns only the contacts the user shared.
+ * - getContacts asks for permission first when it was never asked, and rejects with PERMISSION_DENIED when
+ *   denied. INTERNAL when NSContactsUsageDescription is missing (iOS kills an app that asks without it).
+ */
+export interface ContactsApi {
+    checkPermission(): Promise<{
+        contacts: PermissionState;
+    }>;
+    /** Shows the system prompt when the state is "prompt" or "prompt-with-rationale"; otherwise returns the state. */
+    requestPermission(): Promise<{
+        contacts: PermissionState;
+    }>;
+    getContacts(options?: GetContactsOptions): Promise<{
+        contacts: Contact[];
+    }>;
+}
+export declare const contacts: import("../../../packages/core/src/plugin.ts").Plugin<ContactsApi, {}>;