akanjs 3.0.0-beta.2 → 3.0.0-beta.21

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

@@ -0,0 +1,85 @@
+/**
+ * Desktop menus: the app menu bar and context menus (plugins.md §5).
+ *
+ * - macOS: the menu bar holds only submenus, and the first one is the app menu (macOS titles it
+ *   with the app's name). Until setAppMenu is called the app has the default menu: App, Edit and
+ *   Window (D1). Keep an Edit menu (role "editMenu" or its items): without it Cmd+C/V/X/A do
+ *   nothing in the page.
+ * - Windows and Linux: a menu bar in every window, from the same item tree (the bar holds only
+ *   submenus there too, so one tree fits every OS). No menu bar until setAppMenu, and
+ *   getAppMenu() is [] then: the webview handles Ctrl+C/V itself. CmdOrCtrl is Ctrl; Cmd is the
+ *   Windows (Super) key, which Windows menus show but cannot fire.
+ *   Roles: appMenu is a "File" menu with About and Exit (Windows) or Quit (Linux); editMenu,
+ *   windowMenu (Minimize, Maximize, Full Screen, Close) and helpMenu (only with items) are the
+ *   usual menus. about shows a small About box, quit asks the app to quit as Cmd+Q does, the
+ *   window roles act on the menu's window. The editing roles run the page's command; their keys
+ *   stay with the page (shown next to the item, not taken from text fields). hide, hideOthers,
+ *   showAll, bringAllToFront and services are macOS only and left out.
+ *   Context menus open at the page position or the mouse; on Linux (GTK) a Wayland session may
+ *   refuse a menu opened without a recent click.
+ * - Web, iOS and Android: UNSUPPORTED.
+ *
+ * Clicks arrive as `click` events: app menu clicks at the most recently focused window that
+ * listens, context menu clicks at the window that opened the menu.
+ */
+/** Standard items. Their action goes to the focused page or window and macOS enables them itself. */
+export type MenuItemRole = "about" | "hide" | "hideOthers" | "showAll" | "quit" | "undo" | "redo" | "cut" | "copy" | "paste" | "pasteAndMatchStyle" | "delete" | "selectAll" | "minimize" | "zoom" | "close" | "toggleFullScreen" | "bringAllToFront";
+/**
+ * Standard submenus. appMenu, editMenu and windowMenu bring their usual items unless `submenu`
+ * lists others; windowMenu also gets the window list, helpMenu the help search field and
+ * services the Services items from macOS.
+ */
+export type SubmenuRole = "appMenu" | "editMenu" | "windowMenu" | "helpMenu" | "services";
+export interface MenuItem {
+    /** Reported by `click`. Required for items you handle (not for roles, separators or submenus). */
+    id?: string;
+    label?: string;
+    /** e.g. "CmdOrCtrl+Shift+K" (CmdOrCtrl is Command on macOS). */
+    accelerator?: string;
+    /** Default true. */
+    enabled?: boolean;
+    /** Makes a check item; it toggles itself when chosen and `click` reports the new state. */
+    checked?: boolean;
+    submenu?: MenuItem[];
+    role?: MenuItemRole | SubmenuRole;
+    type?: "separator";
+}
+export interface MenuClick {
+    id: string;
+    source: "app" | "context";
+    /** Check items: the state after the click. */
+    checked?: boolean;
+}
+export interface MenuApi {
+    /** Replaces the app menu. */
+    setAppMenu(args: {
+        items: MenuItem[];
+    }): Promise<void>;
+    /** Back to the default menu (App, Edit, Window). */
+    resetAppMenu(): Promise<void>;
+    /** The current app menu in setAppMenu's shape (roles come back as roles). */
+    getAppMenu(): Promise<{
+        items: MenuItem[];
+    }>;
+    /**
+     * Opens a context menu in the calling window at a page position (CSS px), or at the mouse.
+     * Resolves when the menu closes; a chosen item has sent its `click` by then.
+     * `closeAfterMs` closes it unchosen, for automated tests.
+     */
+    popupContextMenu(args: {
+        items: MenuItem[];
+        x?: number;
+        y?: number;
+        closeAfterMs?: number;
+    }): Promise<void>;
+    /** Acts as if the user chose an app menu item (automated tests, where nobody can click). */
+    triggerItem(args: {
+        id: string;
+    }): Promise<void>;
+}
+export interface MenuEvents {
+    click: MenuClick;
+}
+export declare const menu: import("../../../packages/core/src/plugin.ts").Plugin<MenuApi, MenuEvents>;
+/** Menu clicks (app menu and context menus). Returns an unsubscribe function. */
+export declare function onMenuClick(handler: (click: MenuClick) => void): () => void;

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

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

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

@@ -0,0 +1,22 @@
+/** The medium of the active network. "unknown" for others (VPN only, Bluetooth, USB) or where the host cannot tell. */
+export type ConnectionType = "wifi" | "cellular" | "ethernet" | "none" | "unknown";
+export interface NetworkStatus {
+    /**
+     * Whether the active network can reach the internet, as far as the OS knows. Android requires a
+     * validated connection, so a captive portal Wi-Fi is not connected there. iOS and browsers only
+     * know that a route exists.
+     */
+    connected: boolean;
+    /** "none" only when there is no network at all; a Wi-Fi without internet is { connected: false, type: "wifi" }. */
+    type: ConnectionType;
+}
+export interface NetworkApi {
+    getStatus(): Promise<NetworkStatus>;
+}
+export interface NetworkEvents {
+    /** Sent when `connected` or `type` changes. */
+    change: NetworkStatus;
+}
+export declare const network: import("../../../packages/core/src/plugin.ts").Plugin<NetworkApi, NetworkEvents>;
+/** The current network status. Re-renders on every change. */
+export declare function useNetwork(): NetworkStatus;

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

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

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

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

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

@@ -0,0 +1,14 @@
+import type { OpenerApi } from "./index.ts";
+export interface Command {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export type Runner = (argv: string[]) => Promise<Command>;
+/**
+ * `run` is replaceable so tests can check the commands without opening anything, `platform` so
+ * they can check the Windows and Linux paths (shell ops) on any OS.
+ */
+export declare function createDesktopOpener(run?: Runner, platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<OpenerApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<OpenerApi, {}>;
+export default _default;

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

@@ -0,0 +1,33 @@
+export { OPENER_SCHEMES } from "./url.ts";
+/**
+ * Opens URLs in other apps (browser, mail, phone) and the app's system settings. This is the
+ * explicit API; links the page follows leave the WebView on their own (shell SH-4).
+ * Only http, https, mailto and tel URLs are accepted; others reject INVALID_ARGS.
+ */
+export interface OpenerApi {
+    /**
+     * Opens the URL with the app the system picks. Rejects NOT_FOUND when no app handles it (e.g. tel:
+     * on a simulator), PERMISSION_DENIED on iOS while the app is not in the foreground and on the web
+     * when the browser blocked the new window (call it from a click).
+     */
+    openUrl(args: {
+        url: string;
+    }): Promise<void>;
+    /**
+     * Whether an installed app handles the URL. iOS, macOS, Windows and Linux ask the system (tel: is
+     * false on iPad and the simulator, and wherever no phone app is registered); the web cannot tell
+     * and answers true. Not available on Android, where apps are
+     * invisible to the query unless the manifest lists them in <queries>.
+     */
+    canOpenUrl(args: {
+        url: string;
+    }): Promise<{
+        value: boolean;
+    }>;
+    /**
+     * Opens this app's page in Settings (iOS, Android), Privacy & Security in System Settings (macOS)
+     * or Settings › Privacy & security (Windows). UNSUPPORTED on Linux, whose desktops have no common page.
+     */
+    openSettings(): Promise<void>;
+}
+export declare const opener: import("../../../packages/core/src/plugin.ts").Plugin<OpenerApi, {}>;

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

@@ -0,0 +1,16 @@
+import { type CallScope } from "../../../packages/core/src/index.ts";
+/**
+ * Schemes the opener hands to the system by default: the shell's external list (contract.json;
+ * tauri-plugins-workspace/plugins/opener allows the same, permissions/allow-default-urls.toml). An
+ * app adds others with security.shell.externalSchemes. Anything else (file:, javascript:, other
+ * apps' schemes) is INVALID_ARGS on every platform; the native implementations check the same list.
+ */
+export declare const OPENER_SCHEMES: readonly string[];
+/** Parses and checks a URL for openUrl/canOpenUrl. Scheme case is normalized by URL (as Android normalizeScheme). */
+export declare function checkUrl(url: unknown, schemes?: readonly string[]): URL;
+/**
+ * PL-11: the app's capabilities may limit openUrl to scopes { url } (URL patterns, urlMatch in
+ * @akanjs/native/core), matched against the normalized URL, e.g. { url: "https://*.example.com/*" }.
+ * Throws NOT_ALLOWED outside the call's scope.
+ */
+export declare function checkUrlScope(scope: CallScope | undefined, url: URL): void;

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+/** String key-value storage that survives app restarts. Store JSON yourself for structured data. */
+export interface PreferencesApi {
+    get(args: {
+        key: string;
+    }): Promise<{
+        value: string | null;
+    }>;
+    set(args: {
+        key: string;
+        value: string;
+    }): Promise<void>;
+    remove(args: {
+        key: string;
+    }): Promise<void>;
+    keys(): Promise<{
+        keys: string[];
+    }>;
+    clear(): Promise<void>;
+}
+export declare const preferences: import("../../../packages/core/src/plugin.ts").Plugin<PreferencesApi, {}>;
+export type PreferenceSetter = (value: string | null) => Promise<void>;
+/**
+ * Reads and writes one key. `ready` is false until the stored value has loaded.
+ * Setting null removes the key.
+ */
+export declare function usePreference(key: string): [value: string | null, set: PreferenceSetter, ready: boolean];

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

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

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

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

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

@@ -0,0 +1,57 @@
+/** C1 permission states. Android reports "prompt-with-rationale" after one refusal. */
+export type PushPermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+export type PushProvider = "apns" | "fcm";
+/** Where the server sends: an APNs device token (hex) or an FCM registration token. */
+export interface PushToken {
+    token: string;
+    provider: PushProvider;
+    platform: "ios" | "android";
+}
+export interface PushMessage {
+    /** APNs: the notification's request identifier. FCM: the message id. */
+    id?: string;
+    title?: string;
+    body?: string;
+    /** The payload's own keys: APNs userInfo without "aps", FCM data. */
+    data: Record<string, unknown>;
+}
+export interface PushAction {
+    /** "tap" for the notification itself, else the action's identifier. */
+    actionId: string;
+    message: PushMessage;
+}
+/** How a push that arrives while the app is in front is shown. Default: not shown (the page gets "received"). */
+export interface PushPresentation {
+    banner?: boolean;
+    list?: boolean;
+    sound?: boolean;
+    badge?: boolean;
+}
+export interface PushApi {
+    checkPermission(): Promise<{
+        display: PushPermissionState;
+    }>;
+    /** Asks for permission to show notifications (Android 13+ and iOS; granted earlier on older Android). */
+    requestPermission(): Promise<{
+        display: PushPermissionState;
+    }>;
+    /** Registers with APNs or FCM; resolves with the token. A later change arrives as "token". */
+    register(): Promise<PushToken>;
+    /** Stops pushes to this installation (APNs unregister; FCM deletes the token). */
+    unregister(): Promise<void>;
+    setForegroundPresentation(args: PushPresentation): Promise<void>;
+}
+export interface PushEvents {
+    /**
+     * The token changed (FCM refreshes it; APNs after a restore). Send it to the server again. A change
+     * while no page listened is kept (the latest) and goes to the first listener.
+     */
+    token: PushToken;
+    /** A push arrived while the app runs (shown or not, per setForegroundPresentation). */
+    received: PushMessage;
+    /** The user tapped a push. The tap that launched the app is kept until the first listener. */
+    action: PushAction;
+}
+export declare const push: import("../../../packages/core/src/plugin.ts").Plugin<PushApi, PushEvents>;
+/** Subscribes to a push event for the component's lifetime. */
+export declare function usePushEvent<E extends keyof PushEvents & string>(event: E, handler: (data: PushEvents[E]) => void): void;

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

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

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

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

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>;