akanjs 3.0.0-beta.9 → 3.0.1

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

@@ -0,0 +1,93 @@
+import { AkanNativeError, type ErrorCode } from "../../../packages/core/src/index.ts";
+export type PermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+export interface LocationPermission {
+    /** "denied" also covers location services turned off system-wide (iOS reports it that way). */
+    location: PermissionState;
+    /**
+     * Whether positions are precise: iOS Precise Location on, Android ACCESS_FINE_LOCATION granted.
+     * false means approximate (a few km). null when location is not granted or the platform cannot tell (web).
+     */
+    precise: boolean | null;
+}
+/** A W3C GeolocationPosition, flattened. Distances in meters, angles in degrees, speed in m/s. */
+export interface Position {
+    latitude: number;
+    longitude: number;
+    /** Radius of 68% confidence around latitude/longitude. */
+    accuracy: number;
+    /** Height above the WGS84 ellipsoid (as W3C and Android report it; iOS converts from its mean-sea-level value). */
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    /** Direction of travel, clockwise from true north. null when unknown or not moving. */
+    heading: number | null;
+    speed: number | null;
+    /** When the fix was taken, ms since the Unix epoch. */
+    timestamp: number;
+}
+/**
+ * Numbers must be finite on iOS and Android: the bridge is JSON, where Infinity becomes null, i.e.
+ * the default. For "any cached fix" pass a large number such as 86_400_000 (a day).
+ */
+export interface PositionOptions {
+    /**
+     * Ask for the best accuracy (GPS) instead of a battery-friendly fix (~100 m). Default false.
+     * On Android a balanced request never turns on GPS: without network location (the emulator)
+     * it only gets a fix another request produced recently, or times out.
+     */
+    enableHighAccuracy?: boolean;
+    /** Give up after this many ms with NOT_FOUND, counted after the permission prompt. Default 30000; Android ends a single request after 30 s. */
+    timeout?: number;
+    /** Accept a cached fix up to this many ms old. Default 0 (always a new fix). */
+    maximumAge?: number;
+}
+/**
+ * getCurrentPosition() asks for permission first when it was never asked, like the W3C API.
+ * It rejects with
+ * - PERMISSION_DENIED: the user denied location (or turned it off, on iOS)
+ * - NOT_FOUND: no position: timeout, location turned off (Android, web), no provider
+ * - INTERNAL: NSLocationWhenInUseUsageDescription missing (iOS) and other failures
+ * - UNSUPPORTED: macOS (WKWebView has no public geolocation permission hook and CoreLocation
+ *   would need native desktop code) and browsers without navigator.geolocation (insecure context)
+ */
+export interface GeolocationApi {
+    getCurrentPosition(options?: PositionOptions): Promise<Position>;
+    checkPermission(): Promise<LocationPermission>;
+    /** Shows the system prompt when the state is "prompt" or "prompt-with-rationale"; otherwise returns the state. */
+    requestPermission(): Promise<LocationPermission>;
+}
+export interface GeolocationError {
+    code: ErrorCode;
+    message: string;
+}
+/**
+ * Position updates run while someone listens: "position" at balanced accuracy, and
+ * "highAccuracyPosition" with GPS. While both have listeners the host runs one high-accuracy
+ * watch and sends each fix to both. Updates stop while the app is in the background.
+ * "error" reports watch failures (permission denied or revoked, location turned off); it does not
+ * start a watch by itself.
+ */
+export interface GeolocationEvents {
+    position: Position;
+    highAccuracyPosition: Position;
+    error: GeolocationError;
+}
+export declare const geolocation: import("../../../packages/core/src/plugin.ts").Plugin<GeolocationApi, GeolocationEvents>;
+export interface WatchOptions {
+    enableHighAccuracy?: boolean;
+    onError?: (error: AkanNativeError) => void;
+}
+/**
+ * Calls `onPosition` for every new fix until the returned function is called. Like W3C
+ * watchPosition, it asks for permission first when it was never asked.
+ */
+export declare function watchPosition(onPosition: (position: Position) => void, options?: WatchOptions): () => void;
+export interface GeolocationState {
+    /** The latest fix, null until the first one. */
+    position: Position | null;
+    /** The latest failure; cleared by the next fix. */
+    error: AkanNativeError | null;
+}
+/** Watches the position while the component is mounted. Components with the same accuracy share one watch. */
+export declare function useGeolocation(options?: {
+    enableHighAccuracy?: boolean;
+}): GeolocationState;

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

@@ -0,0 +1,11 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import type { GeolocationApi, GeolocationEvents, Position, PositionOptions } from "./index.ts";
+export declare const DEFAULT_TIMEOUT = 30000;
+export declare function toPosition(p: GeolocationPosition): Position;
+/** W3C GeolocationPositionError codes: 1 PERMISSION_DENIED, 2 POSITION_UNAVAILABLE, 3 TIMEOUT. */
+export declare function toError(error: {
+    code: number;
+    message?: string;
+}): AkanNativeError;
+export declare function positionOptions(options: PositionOptions | undefined): globalThis.PositionOptions;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<GeolocationApi, GeolocationEvents>;

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

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

package/types/vendor/@akanjs/native/plugins/global-shortcut/src/desktop.d.ts

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

package/types/vendor/@akanjs/native/plugins/global-shortcut/src/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * System-wide keyboard shortcuts that reach the app even when another app is in front
+ * (plugins.md §5).
+ *
+ * - Accelerators: modifiers plus one key joined by "+", e.g. "CmdOrCtrl+Shift+K", "Alt+F12".
+ *   Modifiers: Cmd, Ctrl, CmdOrCtrl (Command on macOS), Alt/Option, Shift. Keys: A–Z, 0–9,
+ *   F1–F20, punctuation, Space, Tab, Enter, Escape, Backspace, Delete, arrows, Home, End,
+ *   PageUp, PageDown, Num0–Num9.
+ * - macOS: Carbon hot keys, no permission needed. Keys are positions on the US layout. A
+ *   combination another app registered fails with an error; a system shortcut (Cmd+Space,
+ *   Cmd+Tab) may register and never fire.
+ * - Shortcuts belong to the app: they stay registered when the page reloads, and registering
+ *   one the app already has succeeds. `pressed` goes to the window the user was in last.
+ * - Windows: RegisterHotKey. CmdOrCtrl is Ctrl and Cmd the Windows key; some combinations
+ *   (Win+L, Ctrl+Alt+Del) never reach an app.
+ * - Linux: X11 only (XGrabKey), with the same rules. On Wayland register() rejects UNSUPPORTED:
+ *   GNOME and KDE offer global shortcuts there only through the GlobalShortcuts portal.
+ * - Web, iOS and Android: UNSUPPORTED.
+ */
+export interface GlobalShortcutApi {
+    /** Resolves with the canonical spelling ("CmdOrCtrl+Shift+K"). */
+    register(args: {
+        accelerator: string;
+    }): Promise<{
+        accelerator: string;
+    }>;
+    unregister(args: {
+        accelerator: string;
+    }): Promise<{
+        removed: boolean;
+    }>;
+    unregisterAll(): Promise<void>;
+    isRegistered(args: {
+        accelerator: string;
+    }): Promise<{
+        registered: boolean;
+    }>;
+    /** The registered accelerators, as they were written. */
+    list(): Promise<string[]>;
+}
+export interface GlobalShortcutEvents {
+    /** `accelerator` as it was registered. */
+    pressed: {
+        accelerator: string;
+    };
+}
+export declare const globalShortcut: import("../../../packages/core/src/plugin.ts").Plugin<GlobalShortcutApi, GlobalShortcutEvents>;
+/**
+ * Registers a shortcut and calls `handler` when it is pressed. The returned function stops
+ * listening and unregisters the shortcut.
+ */
+export declare function onShortcut(accelerator: string, handler: () => void): Promise<() => Promise<void>>;

package/types/vendor/@akanjs/native/plugins/global-shortcut/src.d.ts

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

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

@@ -0,0 +1,31 @@
+/** UIImpactFeedbackGenerator styles: light / medium / heavy by strength, soft is duller, rigid is crisper. */
+export type ImpactStyle = "light" | "medium" | "heavy" | "soft" | "rigid";
+export type NotificationType = "success" | "warning" | "error";
+/**
+ * Haptic feedback, with the four functions of tauri-plugins-workspace/plugins/haptics/guest-js/index.ts.
+ *
+ * A call resolves once the feedback was handed to the system. Devices without haptic hardware
+ * (iOS simulator, iPads, most Android tablets and desktop browsers) resolve and feel nothing.
+ * Hosts without any haptics API reject UNSUPPORTED: macOS, and browsers without navigator.vibrate
+ * (Safari, so every iOS browser).
+ *
+ * impact, notification and selection are UI feedback: on iOS and Android they follow the user's
+ * system haptics / touch feedback setting.
+ */
+export interface HapticsApi {
+    /** A collision between UI elements, e.g. something snapping into place. Default style "medium". */
+    impact(options?: {
+        style?: ImpactStyle;
+    }): Promise<void>;
+    /** The outcome of a task or action. Default type "success". */
+    notification(options?: {
+        type?: NotificationType;
+    }): Promise<void>;
+    /** A selection changed, e.g. a picker value while scrolling. */
+    selection(): Promise<void>;
+    /** A plain vibration, for alerts rather than UI feedback. `duration` in ms, 1-10000, default 300. */
+    vibrate(options?: {
+        duration?: number;
+    }): Promise<void>;
+}
+export declare const haptics: import("../../../packages/core/src/plugin.ts").Plugin<HapticsApi, {}>;

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

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

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

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

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

@@ -0,0 +1,71 @@
+import { AkanNativeError, type CallScope } from "../../../packages/core/src/index.ts";
+import type { HttpMethod, NativeResponseType } from "./index.ts";
+export declare const METHODS: readonly HttpMethod[];
+/** Whole request, redirects and body included. */
+export declare const DEFAULT_TIMEOUT = 60000;
+/** Android takes timeouts as int milliseconds. */
+export declare const MAX_TIMEOUT = 2147483647;
+/** The fetch standard's limit. */
+export declare const MAX_REDIRECTS = 20;
+export declare const REDIRECTS: Set<number>;
+/**
+ * Headers the HTTP stack owns: it frames the body, the connection and compression itself (every
+ * platform decodes gzip on its own, and Android stops doing so once the app sets Accept-Encoding).
+ */
+export declare const RESERVED_HEADERS: Set<string>;
+/**
+ * The form a URL is matched against the app's scope in and sent in, the same on every platform:
+ * lowercase scheme and host, no default port, "/" for an empty path, no fragment, and the path and
+ * query percent-encoded where RFC 3986 needs it (UTF-8; valid %XX kept). null for anything that is
+ * not an absolute http(s) URL, has credentials or a malformed host or port, or still has dot
+ * segments (they must be resolved before a scope can be checked).
+ */
+export declare function canonicalUrl(text: string): string | null;
+/** A URL as the page gives it → the canonical form, after WHATWG parsing (new URL) resolves dots, IDN hosts and escapes. */
+export declare function normalizeUrl(url: unknown): string;
+/** The origin of a canonical URL (whose path always starts with "/"): scheme, host and port. */
+export declare function originOf(url: string): string;
+/** PL-11: the app's capabilities may limit requests to scopes { url } (URL patterns, urlMatch in @akanjs/native/core). */
+export declare function checkScope(scope: CallScope | undefined, url: string, what?: string): void;
+export interface Prepared {
+    url: string;
+    method: HttpMethod;
+    /** Names as given; unique regardless of case. */
+    headers: [string, string][];
+    body: Uint8Array | null;
+    responseType: NativeResponseType;
+    timeout: number;
+}
+export declare function base64ToBytes(data: string): Uint8Array | null;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Checks a request as the host receives it (the page wrapper already made url canonical). */
+export declare function prepare(args: unknown): Prepared;
+/** Methods that get an empty body (Content-Length: 0) when none is given. */
+export declare const BODY_METHODS: Set<string>;
+/**
+ * The next hop of a redirect, per the fetch standard (HTTP-redirect fetch, steps 12-13 and the
+ * cross-origin Authorization rule): 301/302 turn POST into GET, 303 turns everything but GET/HEAD
+ * into GET, both dropping the body and its headers; 307/308 keep method and body. Credentials
+ * (Authorization, Cookie, Proxy-Authorization) do not follow to another origin.
+ */
+export declare function redirected(status: number, request: {
+    method: HttpMethod;
+    headers: [string, string][];
+    body: Uint8Array | null;
+}, from: string, to: string): {
+    method: HttpMethod;
+    headers: [string, string][];
+    body: Uint8Array | null;
+};
+/** A redirect target: Location resolved against the current URL, in canonical form. */
+export declare function redirectTarget(location: string, current: string): string;
+/**
+ * Response headers: lowercase names, repeated headers joined with ", " (Set-Cookie too, as
+ * iOS and Android give them). Content-Encoding and Content-Length describe the encoded body,
+ * which every platform has already decoded, so they are left out then (Android drops them too).
+ */
+export declare function responseHeaders(headers: Headers): Record<string, string>;
+/** The body for the bridge: UTF-8 text (BOM dropped, bad bytes as U+FFFD, as fetch's text()) or base64. */
+export declare function encodeBody(bytes: Uint8Array, type: NativeResponseType): string;
+/** Any failure of the transfer itself (DNS, connect, TLS, reset, timeout): INTERNAL. */
+export declare function networkError(error: unknown, request: Prepared, hint?: string): AkanNativeError;

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

@@ -0,0 +1,5 @@
+import type { HttpSpec } from "./index.ts";
+/** `send` is replaceable for tests; the default is Bun's fetch. */
+export declare function createDesktopHttp(send?: typeof fetch): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<HttpSpec, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<HttpSpec, {}>;
+export default _default;

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