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

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

@@ -0,0 +1,104 @@
+import { type Plugin } from "../../../packages/core/src/index.ts";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+export type BodyEncoding = "utf8" | "base64";
+/** How the host hands the body over the bridge. "json" (below) is text parsed in the page. */
+export type NativeResponseType = "text" | "base64";
+export type ResponseType = NativeResponseType | "json";
+/** A request as the host receives it (the PL-10 spec types). */
+export interface NativeRequest {
+    /**
+     * Absolute http or https URL. The page sends it in canonical form (WHATWG-parsed, lowercase
+     * scheme and host, no default port or fragment): that is what the app's scope matches.
+     */
+    url: string;
+    /** Default GET. */
+    method?: HttpMethod;
+    /**
+     * Request headers, each name once (whatever its case). Host, Content-Length, Transfer-Encoding,
+     * Connection, Keep-Alive, Upgrade, TE, Trailer, Expect and Accept-Encoding belong to the HTTP
+     * stack and reject INVALID_ARGS. Nothing adds cookies: send a Cookie header yourself.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Text (sent as UTF-8) or, with bodyEncoding "base64", bytes. Without a Content-Type header one
+     * is added: text/plain;charset=UTF-8 or application/octet-stream. GET and HEAD cannot have one;
+     * POST, PUT and PATCH without one send an empty body.
+     */
+    body?: string;
+    /** Default utf8. */
+    bodyEncoding?: BodyEncoding;
+    /** Default text. */
+    responseType?: NativeResponseType;
+    /** Milliseconds for the whole request (redirects and body included). Default 60000. */
+    timeout?: number;
+}
+export interface NativeResponse {
+    status: number;
+    /**
+     * Lowercase names; a repeated header (Set-Cookie too) is joined with ", ". Content-Encoding and
+     * Content-Length are left out when the body came compressed (it is always decoded).
+     */
+    headers: Record<string, string>;
+    /** Text (UTF-8, BOM dropped, invalid bytes as U+FFFD) or base64. */
+    data: string;
+    /** The URL that answered, after redirects, in canonical form. */
+    url: string;
+}
+/** The bridge spec the Swift and Kotlin bindings are generated from (PL-10). */
+export interface HttpSpec {
+    request(options: NativeRequest): Promise<NativeResponse>;
+}
+export interface HttpRequestOptions extends Omit<NativeRequest, "responseType"> {
+    /** "json" parses the text in the page (an empty body is null); invalid JSON rejects INTERNAL. Default text. */
+    responseType?: ResponseType;
+}
+export interface HttpResponse<T = string> extends Omit<NativeResponse, "data"> {
+    data: T;
+}
+/**
+ * HTTP from the native side of the app (WV-5, Capacitor's CapacitorHttp approach): no CORS, since
+ * the request does not come from the page. iOS URLSession, Android HttpURLConnection, desktop
+ * Bun's fetch; the web falls back to the page's fetch, where CORS and the page's
+ * Content-Security-Policy (connect-src) apply as usual.
+ *
+ * - Any status resolves (404 and 500 too); network failures (DNS, refused, TLS, timeout) reject
+ *   INTERNAL, invalid options INVALID_ARGS.
+ * - Redirects are followed (at most 20) as fetch does: 301/302 POST and 303 become GET,
+ *   Authorization and Cookie are not sent to another origin, and every hop must be inside the
+ *   app's scope.
+ * - No cookie jar and no cache on any platform.
+ * - Plain http:// is refused by iOS App Transport Security and Android's cleartext policy unless
+ *   the app allows it (PERMISSION_DENIED); desktop allows it.
+ * - The app's capabilities (PL-11) limit URLs with scopes { url }: URL patterns whose scheme,
+ *   host, port and path are compared separately (urlMatch in @akanjs/native/core; no port = the default port
+ *   in allow, any port in deny), e.g. { identifier: "http:default", allow: [{ url: "https://api.example.com/*" }] }.
+ *   http:default allows no URL until the app lists them.
+ * - Bodies travel over the bridge as text or base64: fine for API calls, not for large downloads.
+ */
+export interface HttpApi {
+    request(options: HttpRequestOptions & {
+        responseType: "json";
+    }): Promise<HttpResponse<unknown>>;
+    request(options: HttpRequestOptions & {
+        responseType?: NativeResponseType;
+    }): Promise<HttpResponse<string>>;
+    request(options: HttpRequestOptions): Promise<HttpResponse<unknown>>;
+}
+export type Http = Plugin<HttpApi>;
+export declare const http: Http;
+export interface FetchOptions {
+    /** Default GET; any case. */
+    method?: string;
+    headers?: HeadersInit;
+    body?: string | ArrayBuffer | ArrayBufferView | URLSearchParams | null;
+    /** Milliseconds for the whole request. Default 60000. */
+    timeout?: number;
+    /** Stops the request (the host cancels it too); rejects with CANCELLED, or TIMEOUT for AbortSignal.timeout. */
+    signal?: AbortSignal;
+}
+/**
+ * A small fetch() over http.request, for code written against fetch: the Response is built from
+ * the native result (body as bytes, so text(), json(), arrayBuffer() and blob() work; `url` is the
+ * final URL). No streaming, no Request objects. `signal` cancels the request on the host too.
+ */
+export declare function fetch(input: string | URL, init?: FetchOptions): Promise<Response>;

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

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

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

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

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

@@ -0,0 +1,171 @@
+/**
+ * iOS knows the kind; Google Play only knows one-time products and subscriptions ("oneTime": whether it
+ * is consumed is the app's decision, made at finish()).
+ */
+export type IapProductType = "consumable" | "nonConsumable" | "subscription" | "nonRenewingSubscription" | "oneTime";
+export type IapPeriodUnit = "day" | "week" | "month" | "year";
+export interface IapPeriod {
+    unit: IapPeriodUnit;
+    value: number;
+}
+/** freeTrial: free for `cycles` periods; payAsYouGo: `price` per period for `cycles` periods; payUpFront: `price` once for the whole span; recurring: the regular price, until cancelled. */
+export type IapPaymentMode = "freeTrial" | "payAsYouGo" | "payUpFront" | "recurring";
+export interface IapPricingPhase {
+    displayPrice: string;
+    price: number;
+    currency: string;
+    /** Absent for a one-time price. */
+    period?: IapPeriod;
+    /** How many periods the phase lasts (0 for recurring). */
+    cycles: number;
+    mode: IapPaymentMode;
+}
+/** base: a subscription's regular plan or a one-time product's price. The others are discounts. */
+export type IapOfferKind = "base" | "introductory" | "promotional" | "winBack" | "oneTime";
+export interface IapOffer {
+    kind: IapOfferKind;
+    /** Android: pass as purchase({ offerToken }) to buy this offer. */
+    token?: string;
+    /** iOS: the promotional or win-back offer's id. Android: the offer id (absent for a base plan). */
+    id?: string;
+    /** Android subscriptions: the base plan this offer belongs to. */
+    basePlanId?: string;
+    /** Android: the tags set in Play Console. */
+    tags?: string[];
+    phases: IapPricingPhase[];
+}
+export interface IapProduct {
+    id: string;
+    type: IapProductType;
+    title: string;
+    description: string;
+    /** The regular price, formatted for the store's locale and currency. */
+    displayPrice: string;
+    price: number;
+    /** ISO 4217. */
+    currency: string;
+    /** Subscriptions: the regular billing period. */
+    subscriptionPeriod?: IapPeriod;
+    /** iOS subscriptions: the subscription group. */
+    subscriptionGroupId?: string;
+    /** iOS subscriptions: whether this account may still take the introductory offer. */
+    introOfferEligible?: boolean;
+    offers: IapOffer[];
+}
+export interface IapGetProductsArgs {
+    ids: string[];
+    /** Android: which kind to look up; both when absent (two queries). iOS ignores it. */
+    type?: "inapp" | "subs";
+}
+export interface IapGetProductsResult {
+    products: IapProduct[];
+    /** Ids the store did not return (unknown, not approved yet, or not available in this storefront). */
+    invalidIds: string[];
+}
+/** An iOS promotional offer: its id and the compact JWS your server signed (App Store Server Library). */
+export interface IapPromotionalOffer {
+    offerId: string;
+    jws: string;
+}
+export interface IapPurchaseArgs {
+    productId: string;
+    /** Android: the offer to buy (IapOffer.token). Default: a subscription's first base plan, a one-time product's first offer. */
+    offerToken?: string;
+    /** iOS: a promotional offer signed by your server. Introductory offers apply by themselves. */
+    promotionalOffer?: IapPromotionalOffer;
+    /**
+     * Ties the purchase to your user, so the server can check who bought it. iOS: appAccountToken, which
+     * must be a UUID. Android: obfuscatedAccountId (at most 64 characters; do not send personal data).
+     */
+    accountId?: string;
+    /** iOS consumables: how many (default 1). */
+    quantity?: number;
+}
+/** purchased: paid, verify and finish it. pending: waiting for payment or approval; it arrives later as a "transaction" event. revoked: refunded or taken away (iOS). */
+export type IapTransactionState = "purchased" | "pending" | "revoked";
+/** What your server checks. iOS: jws (App Store Server API) or, for old servers, appReceipt. Android: purchaseToken with packageName (Google Play Developer API). */
+export interface IapVerification {
+    /** iOS: the transaction's signed JWS. */
+    jws?: string;
+    transactionId?: string;
+    originalTransactionId?: string;
+    /** iOS: the app receipt (base64), for servers that still use verifyReceipt. Absent when the device has none. */
+    appReceipt?: string;
+    /** Android. */
+    purchaseToken?: string;
+    /** Android: absent while pending. */
+    orderId?: string;
+    packageName?: string;
+    /** Android: the purchase JSON and its signature (the app's license key checks it). */
+    originalJson?: string;
+    signature?: string;
+}
+export interface IapTransaction {
+    /** What finish() takes. iOS: the transaction id. Android: the purchase token. */
+    id: string;
+    productId: string;
+    state: IapTransactionState;
+    /** Milliseconds since the epoch. */
+    purchaseDate: number;
+    quantity: number;
+    /** iOS: the first transaction of this subscription or purchase. */
+    originalId?: string;
+    /** iOS subscriptions. */
+    expirationDate?: number;
+    /** iOS: when it was refunded or revoked. */
+    revocationDate?: number;
+    /** Android subscriptions. */
+    autoRenewing?: boolean;
+    /** Android: already acknowledged or consumed (finished). */
+    acknowledged?: boolean;
+    /** What purchase() was given as accountId. */
+    accountId?: string;
+    /** iOS: "Production", "Sandbox" or "Xcode". */
+    environment?: string;
+    /** iOS: StoreKit's own signature check passed. Your server must still check it. */
+    verified?: boolean;
+    verification: IapVerification;
+}
+export type IapPurchaseStatus = "purchased" | "pending";
+export interface IapPurchaseResult {
+    status: IapPurchaseStatus;
+    /** Present when purchased. */
+    transaction?: IapTransaction;
+}
+export interface IapFinishArgs {
+    /** IapTransaction.id. */
+    transactionId: string;
+    /** Android: consume it so it can be bought again (consumables). Otherwise it is acknowledged. iOS finishes either way. */
+    consume?: boolean;
+}
+export interface IapTransactionsResult {
+    transactions: IapTransaction[];
+}
+export interface IapApi {
+    /** False when purchases are turned off (iOS Screen Time) or Google Play billing is unavailable. */
+    canMakePayments(): Promise<{
+        value: boolean;
+    }>;
+    getProducts(args: IapGetProductsArgs): Promise<IapGetProductsResult>;
+    /** Shows the store's purchase sheet. Rejects with CANCELLED when the user closes it. */
+    purchase(args: IapPurchaseArgs): Promise<IapPurchaseResult>;
+    /** After your server verified it: finishes (iOS), consumes or acknowledges (Android) the transaction. */
+    finish(args: IapFinishArgs): Promise<void>;
+    /** Paid transactions that were not finished yet: verify and finish them at startup. */
+    getUnfinished(): Promise<IapTransactionsResult>;
+    /** What the user owns now: non-consumables, active subscriptions and (Android) unconsumed one-time products. */
+    getEntitlements(): Promise<IapTransactionsResult>;
+    /** A "Restore purchases" button: iOS syncs with the App Store (may ask to sign in), then answers like getEntitlements. */
+    restore(): Promise<IapTransactionsResult>;
+    /** Opens the store's subscription management (iOS sheet, Google Play page). */
+    manageSubscriptions(args: {
+        productId?: string;
+    }): Promise<void>;
+}
+export interface IapEvents {
+    /** A transaction that is not the answer to a purchase() call. Verify and finish it like one. */
+    transaction: IapTransaction;
+}
+export declare const iap: import("../../../packages/core/src/plugin.ts").Plugin<IapApi, IapEvents>;
+/** Subscribes to transactions for the component's lifetime. */
+export declare function useIapTransaction(handler: (transaction: IapTransaction) => void): void;

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

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

package/types/vendor/@akanjs/native/plugins/keep-awake/src/desktop.d.ts

@@ -0,0 +1,15 @@
+import type { KeepAwakeApi } from "./index.ts";
+export declare const CAFFEINATE = "/usr/bin/caffeinate";
+export interface Child {
+    readonly exitCode: number | null;
+    kill(): void;
+    readonly exited: Promise<number>;
+}
+export type Spawner = (argv: string[]) => Child;
+/**
+ * `spawn` is replaceable so tests can check the command without keeping the Mac awake, `platform`
+ * so they can check the shell ops of Windows and Linux on any OS.
+ */
+export declare function createDesktopKeepAwake(spawn?: Spawner, pid?: number, platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<KeepAwakeApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<KeepAwakeApi, {}>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/keep-awake/src/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Keeps the screen on (plugins.md §4.1). The state belongs to the page, like the web's Screen Wake
+ * Lock (architecture review, 2026-09-26): a reload, a navigation or the window closing lets the
+ * display sleep again on every platform. On the desktop each window's page holds its own request;
+ * the display stays on while one holds it. Idempotent: calling keepAwake twice needs one allowSleep.
+ */
+export interface KeepAwakeApi {
+    /**
+     * Stops the display from dimming and sleeping while the app is in front. Rejects UNSUPPORTED
+     * on browsers without the Screen Wake Lock API and on Linux sessions without an inhibit service
+     * (xdg-desktop-portal or org.freedesktop.ScreenSaver, which GNOME and KDE provide), and
+     * PERMISSION_DENIED when the browser refuses it (e.g. a Permissions-Policy, or low battery mode).
+     */
+    keepAwake(): Promise<void>;
+    /** Lets the display sleep again. Always resolves, also when keepAwake was never called. */
+    allowSleep(): Promise<void>;
+    /**
+     * Whether keepAwake is in effect. On the web it stays true while the page is hidden: the browser
+     * releases the lock then and it is requested again when the page becomes visible.
+     */
+    isKeptAwake(): Promise<{
+        value: boolean;
+    }>;
+}
+export declare const keepAwake: import("../../../packages/core/src/plugin.ts").Plugin<KeepAwakeApi, {}>;
+/**
+ * Keeps the screen on until the returned function is called (once per holder). The first holder
+ * calls keepAwake, the last release calls allowSleep. Do not mix with direct keepAwake()/allowSleep()
+ * calls: holders only know about each other. Resolves when the host has applied the change.
+ */
+export declare function holdKeepAwake(): () => Promise<void>;
+/** Keeps the screen on while the component is mounted and `enabled` (a holder, see holdKeepAwake). */
+export declare function useKeepAwake(enabled?: boolean): void;

package/types/vendor/@akanjs/native/plugins/keep-awake/src/web.d.ts

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

package/types/vendor/@akanjs/native/plugins/keep-awake/src.d.ts

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

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;