akanjs 3.0.0-beta.9 → 3.0.0

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

@@ -0,0 +1,42 @@
+/** Soft (on-screen) keyboard state. `height` is in CSS pixels and covers the bottom of the page. */
+export interface KeyboardState {
+    visible: boolean;
+    height: number;
+}
+/**
+ * What the keyboard does to the page (akanjs readiness O6-1):
+ * - "resize" (default, or the app config's keyboard.resize): the page's viewport shrinks by the keyboard, so bottom-fixed UI stays above it
+ *   (Android pads the WebView's container, iOS shortens the web view with the keyboard's animation).
+ * - "none": the page keeps its full size and the keyboard covers its bottom; the app moves its UI
+ *   itself with the heights of the events. iOS still scrolls a focused field into view.
+ */
+export type KeyboardResizeMode = "resize" | "none";
+/** A keyboard transition: its height in CSS pixels once it ends (0 when hiding) and its animation length in ms. */
+export interface KeyboardTransition {
+    height: number;
+    duration: number;
+}
+export interface KeyboardApi {
+    getState(): Promise<KeyboardState>;
+    /** Dismisses the soft keyboard. */
+    hide(): Promise<void>;
+    /** "resize" or "none"; until the app ends (not stored). The app config's keyboard.resize is the mode at launch. */
+    setResizeMode(args: {
+        mode: KeyboardResizeMode;
+    }): Promise<void>;
+}
+export interface KeyboardEvents {
+    change: KeyboardState;
+    /** The keyboard starts to show (Android 11+ and iOS: before its animation; Android 10 and the web: together with didShow). */
+    willShow: KeyboardTransition;
+    didShow: KeyboardTransition;
+    willHide: KeyboardTransition;
+    didHide: KeyboardTransition;
+}
+export declare const keyboard: import("../../../packages/core/src/plugin.ts").Plugin<KeyboardApi, KeyboardEvents>;
+export interface UseKeyboard extends KeyboardState {
+    /** False where the platform has no soft keyboard support (desktop). */
+    supported: boolean;
+    hide(): Promise<void>;
+}
+export declare function useKeyboard(): UseKeyboard;

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

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

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

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

package/types/vendor/@akanjs/native/plugins/local-notifications/src/desktop.d.ts

@@ -0,0 +1,29 @@
+import type { LocalNotificationsApi, LocalNotificationsEvents, NotificationEvent, PendingNotification, PermissionState } from "./index.ts";
+/** A request as notify.rs reports it (pending, delivered, events). */
+export interface NativeRequest {
+    id: string | null;
+    title: string | null;
+    body: string | null;
+    /** userInfo data: JSON text. */
+    data: string | null;
+    /** userInfo target time, epoch ms. */
+    at: number | null;
+    every: string | null;
+    /** Next date of a calendar (repeating) trigger. */
+    next: number | null;
+    /** When it was shown (delivered list). */
+    date: number | null;
+    /** Carries this plugin's marker. */
+    ours: boolean;
+}
+/** UNAuthorizationStatus: 0 notDetermined, 1 denied, 2 authorized, 3 provisional, 4 ephemeral. */
+export declare function permissionState(status: number): PermissionState;
+export declare function eventOf(r: NativeRequest & {
+    id: string;
+}): NotificationEvent;
+export declare function pendingOf(r: NativeRequest & {
+    id: string;
+}): PendingNotification;
+export declare function createDesktopNotifications(): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<LocalNotificationsApi, LocalNotificationsEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<LocalNotificationsApi, LocalNotificationsEvents>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/local-notifications/src/index.d.ts

@@ -0,0 +1,126 @@
+import { type Plugin } from "../../../packages/core/src/index.ts";
+/** C1 permission states. Android reports "prompt-with-rationale" after one refusal. */
+export type PermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+export type Repeat = "minute" | "hour" | "day" | "week";
+/** Android channel importance: "high" pops up (heads-up), "low" is silent, "min" is folded away. */
+export type Importance = "min" | "low" | "default" | "high";
+/** Any JSON object. It comes back unchanged in getPending, getDelivered and the events. */
+export type NotificationData = Record<string, unknown>;
+export interface NotificationRequest {
+    /** 32-bit integer, unique within the app. Scheduling an id again replaces the earlier one. */
+    id: number;
+    title: string;
+    body?: string;
+    /**
+     * When to show it: an ISO 8601 date-time (local time without an offset) or epoch milliseconds.
+     * Omitted or in the past: right away. With `every` it sets the time of the repeats and must be
+     * less than one interval from now.
+     */
+    at?: string | number;
+    /**
+     * Repeat until cancelled. Without `at` the first one comes one interval from now (2 s earlier:
+     * iOS calendar triggers work in whole seconds). day and week keep the local time of day across DST.
+     * Android without the exact-alarm permission delivers each one up to about 75% of the interval late.
+     */
+    every?: Repeat;
+    /**
+     * Android channel (createChannel); an unknown one is INVALID_ARGS there. Default: the plugin's
+     * "default" channel ("Notifications", default importance). Ignored elsewhere.
+     */
+    channelId?: string;
+    data?: NotificationData;
+}
+export interface PendingNotification {
+    id: number;
+    title: string;
+    body: string;
+    /** Next delivery, epoch ms. */
+    at: number;
+    every?: Repeat;
+    channelId?: string;
+    data?: NotificationData;
+}
+export interface DeliveredNotification {
+    id: number;
+    title: string;
+    body: string;
+    /** When it was shown, epoch ms, where the host knows it. */
+    at?: number;
+    data?: NotificationData;
+}
+export interface NotificationEvent {
+    id: number;
+    title: string;
+    body: string;
+    data?: NotificationData;
+}
+export interface ChannelOptions {
+    id: string;
+    /** Shown in the system settings. */
+    name: string;
+    description?: string;
+    /** Default "default". Android keeps the user's choice: importance cannot change after creation. */
+    importance?: Importance;
+}
+export interface LocalNotificationsApi {
+    /** Requires the display permission (PERMISSION_DENIED otherwise); it never prompts by itself. */
+    schedule(args: {
+        notifications: NotificationRequest[];
+    }): Promise<{
+        ids: number[];
+    }>;
+    /** Stops pending (future and repeating) notifications. Shown ones stay: see removeDelivered. */
+    cancel(args: {
+        ids: number[];
+    }): Promise<void>;
+    getPending(): Promise<{
+        notifications: PendingNotification[];
+    }>;
+    /** Notifications of this plugin still shown in the notification center / shade. */
+    getDelivered(): Promise<{
+        notifications: DeliveredNotification[];
+    }>;
+    removeDelivered(args: {
+        ids: number[];
+    }): Promise<void>;
+    /** Removes every shown notification of this plugin (push notifications are not touched). */
+    removeAllDelivered(): Promise<void>;
+    /** Android notification channel. Resolves without doing anything on other platforms. */
+    createChannel(args: ChannelOptions): Promise<void>;
+    checkPermission(): Promise<{
+        display: PermissionState;
+    }>;
+    /**
+     * Shows the system prompt when the state is "prompt" (web: call it from a click).
+     * iOS `provisional: true` grants quiet delivery (Notification Center only, no banner or sound)
+     * without a prompt; a later requestPermission() without it still shows the prompt. Ignored elsewhere.
+     */
+    requestPermission(args?: {
+        provisional?: boolean;
+    }): Promise<{
+        display: PermissionState;
+    }>;
+}
+export interface LocalNotificationsEvents {
+    /** A notification was shown while the app is in the foreground (web: while the page runs). */
+    received: NotificationEvent;
+    /**
+     * The user tapped a notification. A tap that launched or resumed the app before anything listened
+     * is delivered to the first listener (plugins.md C2).
+     */
+    action: NotificationEvent;
+}
+export declare const METHODS: readonly ["schedule", "cancel", "getPending", "getDelivered", "removeDelivered", "removeAllDelivered", "createChannel", "checkPermission", "requestPermission"];
+/**
+ * Local notifications: scheduled on the device, no server. The page resolves dates before calling
+ * the host (see schedule.ts), so every host gets the same arguments.
+ * Windows and Linux keep no schedule for apps: the app shows its pending notifications itself, so
+ * they are delivered only while it runs (the web: while the page is open), and taps arrive only
+ * then. A Linux session without a notification server is UNSUPPORTED.
+ */
+export declare const localNotifications: Plugin<LocalNotificationsApi, LocalNotificationsEvents>;
+/** Calls `handler` for every tapped notification while mounted, including the one that launched the app. */
+export declare function useNotificationAction(handler: (event: NotificationEvent) => void): void;
+/** Calls `handler` for every notification shown while the app is in the foreground. */
+export declare function useNotificationReceived(handler: (event: NotificationEvent) => void): void;
+export { addInterval, nextOccurrence, normalizeSchedule, type ScheduledNotification } from "./schedule.ts";

package/types/vendor/@akanjs/native/plugins/local-notifications/src/schedule.d.ts

@@ -0,0 +1,38 @@
+import type { NotificationData, Repeat } from "./index.ts";
+export declare const REPEATS: readonly Repeat[];
+/** How much earlier than "one interval from now" a repeating series starts at the latest. */
+export declare const REPEAT_MARGIN = 2000;
+/** What schedule() sends to the host: `at` is always the first delivery time in epoch ms. */
+export interface ScheduledNotification {
+    id: number;
+    title: string;
+    body: string;
+    at: number;
+    every?: Repeat;
+    channelId?: string;
+    data?: NotificationData;
+}
+export declare function isInt32(value: unknown): value is number;
+/** A list of notification ids (32-bit integers, the Android notification id range). */
+export declare function checkIds(args: unknown, method: string): number[];
+/**
+ * The same wall-clock time `count` intervals after `at`. day and week keep the local time of day
+ * across DST changes (09:00 stays 09:00), like iOS calendar triggers; minute and hour are fixed lengths.
+ */
+export declare function addInterval(at: number, every: Repeat, count?: number): number;
+/** The first occurrence of the series (at, at + 1 interval, ...) that is later than `after`. */
+export declare function nextOccurrence(at: number, every: Repeat, after: number): number;
+/** For hosts in JS (web, desktop): the arguments normalizeSchedule produced, checked again at the bridge. */
+export declare function checkScheduled(args: unknown): ScheduledNotification[];
+/**
+ * Checks schedule() arguments and resolves the first delivery time of each notification:
+ * - no at, no every: now (shown right away)
+ * - at only: that time; a time in the past means now
+ * - every only: one interval from now (2 s earlier, see REPEAT_MARGIN)
+ * - at + every: at sets the phase (09:00 for a daily reminder) and must be less than one interval
+ *   away, because an iOS repeating trigger cannot start later than its next matching time.
+ *   A past at continues the series at its next occurrence.
+ */
+export declare function normalizeSchedule(args: unknown, now: number): {
+    notifications: ScheduledNotification[];
+};

package/types/vendor/@akanjs/native/plugins/local-notifications/src/timers.d.ts

@@ -0,0 +1,25 @@
+import type { PendingNotification } from "./index.ts";
+import { type ScheduledNotification } from "./schedule.ts";
+export interface TimerHost {
+    now(): number;
+    setTimer(fn: () => void, ms: number): unknown;
+    clearTimer(handle: unknown): void;
+    /** Shows the notification. Called for every delivery, repeats included. */
+    show(notification: ScheduledNotification): void;
+}
+export declare const systemTimers: {
+    now: () => number;
+    setTimer: (fn: () => void, ms: number) => NodeJS.Timeout;
+    clearTimer: (handle: unknown) => void;
+};
+export declare class NotificationTimers {
+    private readonly host;
+    private readonly pending;
+    constructor(host: TimerHost);
+    /** Same id again replaces the earlier one. Due notifications are shown right away. */
+    schedule(notifications: ScheduledNotification[]): number[];
+    cancel(ids: number[]): void;
+    list(): PendingNotification[];
+    private arm;
+    private fire;
+}

package/types/vendor/@akanjs/native/plugins/local-notifications/src/web.d.ts

@@ -0,0 +1,4 @@
+import type { LocalNotificationsApi, LocalNotificationsEvents } from "./index.ts";
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<LocalNotificationsApi, LocalNotificationsEvents>;
+/** For tests: forget everything this module keeps. */
+export declare function resetWebState(): void;

package/types/vendor/@akanjs/native/plugins/local-notifications/src.d.ts

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

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

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

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,66 @@
+/** 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;
+    /**
+     * Not shown when its `data[key]` is one of `values`, e.g. the chat room on screen: `{ key: "url", values: [path] }`.
+     * It still arrives as "received".
+     */
+    except?: PushPresentationExcept;
+}
+export interface PushPresentationExcept {
+    key: string;
+    values: string[];
+}
+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;