akanjs 3.0.0-beta.20 → 3.0.0-beta.21

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

@@ -0,0 +1,113 @@
+/**
+ * Tray icons: macOS menu bar extras, Windows notification area icons, Linux status notifier items
+ * (plugins.md §5).
+ *
+ * - `click` fires for every left and right click. If the tray has a menu, a right click then
+ *   opens it, and so does a left click unless `menuOnLeftClick` is false (as in Tauri).
+ * - Menu items send `menuClick` with their id. Roles such as "quit" work as in the app menu.
+ * - Icons are PNG files: a path in the app's public/ folder ("/tray.png") or a FileRef URL
+ *   ("/__akan_native/file/…"). They are drawn 18 pt high; `iconAsTemplate` makes macOS tint them for
+ *   light and dark menu bars (draw them black on transparent).
+ * - A tray belongs to the app, not to a page: it stays when the page reloads, and `create` with
+ *   the same id updates it instead of adding another.
+ * - Windows: `click` and menus as on macOS. There is no title next to the icon: `title` is the
+ *   tooltip while `tooltip` is not set. Icons are drawn at the small-icon size.
+ * - Linux: a StatusNotifierItem over D-Bus, which KDE, GNOME with the AppIndicator extension and
+ *   most panels show (plain GNOME shows none: the tray exists, unseen). `click` "left" when the
+ *   panel activates the icon, "right" for its context menu when the tray has no menu or opens it
+ *   on the right button only; the panel draws the menu itself. `title` is the item's name.
+ * - `iconAsTemplate` only matters on macOS. Without an icon, Windows and Linux show the generic
+ *   application icon.
+ * - Web, iOS and Android: UNSUPPORTED.
+ */
+/** Same shape as @akanjs/native/plugins/menu items. */
+export interface TrayMenuItem {
+    id?: string;
+    label?: string;
+    accelerator?: string;
+    enabled?: boolean;
+    checked?: boolean;
+    submenu?: TrayMenuItem[];
+    role?: string;
+    type?: "separator";
+}
+export interface TrayOptions {
+    /** Default: a new id ("tray-1", …). */
+    id?: string;
+    icon?: string | null;
+    iconAsTemplate?: boolean;
+    title?: string;
+    tooltip?: string | null;
+    menu?: TrayMenuItem[] | null;
+    /** Default true. */
+    menuOnLeftClick?: boolean;
+}
+export interface TrayInfo {
+    id: string;
+    title: string;
+    tooltip: string | null;
+    icon: boolean;
+    iconAsTemplate: boolean;
+    menu: boolean;
+    menuOnLeftClick: boolean;
+}
+export interface TrayApi {
+    /** Adds a tray (it needs an icon or a title), or updates the tray with this id. */
+    create(args: TrayOptions): Promise<TrayInfo>;
+    /** Changes the given fields only. */
+    update(args: TrayOptions & {
+        id: string;
+    }): Promise<TrayInfo>;
+    setIcon(args: {
+        id: string;
+        icon: string | null;
+        iconAsTemplate?: boolean;
+    }): Promise<TrayInfo>;
+    setTitle(args: {
+        id: string;
+        title: string;
+    }): Promise<TrayInfo>;
+    setTooltip(args: {
+        id: string;
+        tooltip: string | null;
+    }): Promise<TrayInfo>;
+    setMenu(args: {
+        id: string;
+        menu: TrayMenuItem[] | null;
+        menuOnLeftClick?: boolean;
+    }): Promise<TrayInfo>;
+    remove(args: {
+        id: string;
+    }): Promise<void>;
+    list(): Promise<TrayInfo[]>;
+    /** Sends a `click` as if the user clicked (automated tests). Does not open the menu. */
+    trigger(args: {
+        id: string;
+        button?: "left" | "right";
+    }): Promise<void>;
+}
+export interface TrayEvents {
+    click: {
+        id: string;
+        button: "left" | "right";
+    };
+    menuClick: {
+        id: string;
+        item: string;
+    };
+}
+export declare const tray: import("../../../packages/core/src/plugin.ts").Plugin<TrayApi, TrayEvents>;
+export interface TrayHandle {
+    readonly id: string;
+    setIcon(icon: string | null, iconAsTemplate?: boolean): Promise<TrayInfo>;
+    setTitle(title: string): Promise<TrayInfo>;
+    setTooltip(tooltip: string | null): Promise<TrayInfo>;
+    setMenu(menu: TrayMenuItem[] | null): Promise<TrayInfo>;
+    /** Clicks on this tray. Returns an unsubscribe function. */
+    onClick(handler: (button: "left" | "right") => void): () => void;
+    /** Menu choices of this tray. Returns an unsubscribe function. */
+    onMenuClick(handler: (item: string) => void): () => void;
+    remove(): Promise<void>;
+}
+/** Creates (or updates) a tray and returns a handle to it. */
+export declare function createTray(options: TrayOptions): Promise<TrayHandle>;

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

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

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

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

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

@@ -0,0 +1,68 @@
+/**
+ * Over-the-air updates. On iOS and Android they replace the web bundle (UP-2); the native code
+ * stays, so a bundle only runs in a binary with the same native API (UP-3, `nativeApi`). Releases
+ * are made with `akan-native update publish <platform>` and signed with the key of `akan-native update keygen`.
+ *
+ * A new bundle first runs on trial: the app calls notifyReady() once it works. A trial that does
+ * not confirm within `updates.readyTimeout` (akan-native.config.ts, default 10 s), or that crashes and is
+ * launched again, is rolled back to the previous bundle.
+ */
+export interface UpdateState {
+    /** The downloaded bundle running now; null = the one inside the app. */
+    bundle: string | null;
+    /** Its sequence (publish time, seconds); 0 for the app's own bundle. */
+    sequence: number;
+    /** Downloaded and verified, runs at the next launch or after apply(). */
+    pending: string | null;
+    /** Running for the first time: call notifyReady() once the app works, or it is rolled back. */
+    trial: boolean;
+    /** The last bundle that was rolled back, if any. */
+    rolledBack: string | null;
+    /** The manifest channel (akan-native.config.ts `updates.channel`). */
+    channel: string;
+    /** What this binary provides natively (UP-3); bundles for another value are ignored. */
+    nativeApi: string | null;
+}
+export interface UpdateCheck {
+    /** A newer bundle for this binary exists (not rolled back before). */
+    available: boolean;
+    bundle: string | null;
+    /** The app version it was published with. */
+    version: string | null;
+    sequence: number | null;
+    /** Bytes still to download; files the running bundle already has are copied. */
+    downloadSize: number | null;
+}
+export interface UpdateProgress {
+    received: number;
+    total: number;
+}
+export interface UpdatesApi {
+    getState(): Promise<UpdateState>;
+    /** Fetches and verifies the signed manifest. Rejects NOT_FOUND when nothing is published, INTERNAL for a bad signature. */
+    check(): Promise<UpdateCheck>;
+    /** Downloads and verifies the latest bundle; it runs at the next launch (or apply()). */
+    download(): Promise<{
+        bundle: string;
+    }>;
+    /** Reloads the page into the downloaded bundle now (on trial). Rejects NOT_FOUND without one. */
+    apply(): Promise<void>;
+    /** The running bundle works: keep it. Call it once the app has started; harmless otherwise. */
+    notifyReady(): Promise<void>;
+    /** Back to the app's own bundle from the next launch on. */
+    reset(): Promise<void>;
+}
+export interface UpdatesEvents {
+    progress: UpdateProgress;
+}
+export declare const updates: import("../../../packages/core/src/plugin.ts").Plugin<UpdatesApi, UpdatesEvents>;
+/**
+ * notifyReady() where updates exist, nothing elsewhere (web, apps without updates configured).
+ * Call it once the app has rendered.
+ */
+export declare function markReady(): Promise<void>;
+/** The update state, refreshed after download/apply through `refresh()`. null where updates do not exist. */
+export declare function useUpdateState(): {
+    state: UpdateState | null;
+    refresh: () => Promise<void>;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { DragDropEvent, WindowApi, WindowEvents } from "./index.ts";
+/** Regular files among the dropped paths, served at /__akan_native/file/<id>; folders and unreadable paths are left out. */
+export declare function droppedFiles(ctx: Pick<DesktopContext, "registerFile">, paths: string[]): NonNullable<DragDropEvent["files"]>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<WindowApi, WindowEvents>;
+export default _default;

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

@@ -0,0 +1,185 @@
+import { type FileRef, type VetoHandler } from "../../../packages/core/src/index.ts";
+/** The app window (desktop). Sizes and positions are logical pixels (CSS px). */
+export interface WindowState {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    maximized: boolean;
+    minimized: boolean;
+    fullscreen: boolean;
+    focused: boolean;
+    visible: boolean;
+    title: string;
+}
+/** A window and its id (SH-6: 1 is the window the app opened; others come from createWindow). */
+export interface WindowInfo extends WindowState {
+    id: number;
+}
+/** Where a new window opens. Sizes and positions are logical pixels; x and y are the frame's top-left corner. */
+export interface CreateWindowOptions {
+    /** App path the window loads, e.g. "/settings" (the SPA router sees it). Default "/". */
+    path?: string;
+    /** Default: the app name. */
+    title?: string;
+    width?: number;
+    height?: number;
+    /** Default: offset from the focused window, like new documents on macOS. */
+    x?: number;
+    y?: number;
+}
+/** `window`: which window an op acts on. Default: the window of the page that calls. */
+type On = {
+    window?: number;
+};
+export interface WindowApi {
+    getState(args?: On): Promise<WindowState>;
+    setTitle(args: {
+        title: string;
+    } & On): Promise<WindowState>;
+    setSize(args: {
+        width: number;
+        height: number;
+    } & On): Promise<WindowState>;
+    setPosition(args: {
+        x: number;
+        y: number;
+    } & On): Promise<WindowState>;
+    center(args?: On): Promise<WindowState>;
+    minimize(args?: On): Promise<WindowState>;
+    maximize(args?: On): Promise<WindowState>;
+    unmaximize(args?: On): Promise<WindowState>;
+    /** Un-minimize, un-maximize and focus. */
+    restore(args?: On): Promise<WindowState>;
+    setFullscreen(args: {
+        value: boolean;
+    } & On): Promise<WindowState>;
+    setAlwaysOnTop(args: {
+        value: boolean;
+    } & On): Promise<WindowState>;
+    show(args?: On): Promise<WindowState>;
+    hide(args?: On): Promise<WindowState>;
+    focus(args?: On): Promise<WindowState>;
+    /**
+     * Closes the window without asking onCloseRequested handlers. While another window exists it
+     * is destroyed; the last window makes the app quit (asking app.onBeforeQuit handlers), or only
+     * hides if desktop.quitOnLastWindowClosed is false.
+     */
+    close(args?: On): Promise<void>;
+    /** Moves the window with the mouse; call it from a mousedown on a custom title bar. */
+    startDragging(args?: On): Promise<void>;
+    toggleMaximize(args?: On): Promise<WindowState>;
+    /** Opens another window (desktop). Use createWindow(). */
+    create(args?: CreateWindowOptions): Promise<WindowInfo>;
+    /** Every window, hidden ones included, by id. Use getAllWindows(). */
+    list(): Promise<WindowInfo[]>;
+    /** Internal: the page's answer to a closeRequested event. Use onCloseRequested(). */
+    answerCloseRequested(args: {
+        id: number;
+        allow?: boolean;
+    }): Promise<void>;
+}
+export interface WindowEvents {
+    /** This window's inner size changed. */
+    resize: {
+        width: number;
+        height: number;
+    };
+    /** This window moved. */
+    move: {
+        x: number;
+        y: number;
+    };
+    /** This window gained or lost focus. */
+    focus: {
+        focused: boolean;
+    };
+    /** Internal: the close button or Cmd+W on this window. Use onCloseRequested(). */
+    closeRequested: {
+        id: number;
+    };
+    /** A window was opened (any window). */
+    created: {
+        id: number;
+    };
+    /** A window was destroyed (any window). */
+    destroyed: {
+        id: number;
+    };
+    /** Files dragged over this window from Finder or another app (desktop, plugins.md D9). Use onDragDrop(). */
+    dragDrop: DragDropEvent;
+}
+/**
+ * A file drag over the window (desktop). Only drags that carry files are reported. The page's own
+ * HTML5 drop events keep working next to it (dataTransfer.files, without paths).
+ */
+export interface DragDropEvent {
+    type: "enter" | "over" | "drop" | "leave";
+    /** Absolute paths of the dragged files and folders (enter and drop). */
+    paths?: string[];
+    /** Pointer position in CSS px from the page's top-left corner (not on leave). */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** On drop: every regular file, served by the host for this session so the page can fetch() it. */
+    files?: (FileRef & {
+        path: string;
+        name: string;
+    })[];
+}
+/** The window plugin. Its ops act on this page's window unless `window` says otherwise. */
+export declare const appWindow: import("../../../packages/core/src/plugin.ts").Plugin<WindowApi, WindowEvents>;
+/** One window, by id. Its methods act on that window from any page. */
+export interface WindowHandle {
+    readonly id: number;
+    /** True for the window this page runs in. */
+    readonly isCurrent: boolean;
+    getState(): Promise<WindowState>;
+    setTitle(title: string): Promise<WindowState>;
+    setSize(width: number, height: number): Promise<WindowState>;
+    setPosition(x: number, y: number): Promise<WindowState>;
+    center(): Promise<WindowState>;
+    minimize(): Promise<WindowState>;
+    maximize(): Promise<WindowState>;
+    unmaximize(): Promise<WindowState>;
+    restore(): Promise<WindowState>;
+    toggleMaximize(): Promise<WindowState>;
+    setFullscreen(value: boolean): Promise<WindowState>;
+    setAlwaysOnTop(value: boolean): Promise<WindowState>;
+    show(): Promise<WindowState>;
+    hide(): Promise<WindowState>;
+    focus(): Promise<WindowState>;
+    /** Closes it without asking its onCloseRequested handlers (see appWindow.close). */
+    close(): Promise<void>;
+    /** Calls `fn` once the window is destroyed. Returns an unregister function. */
+    onDestroyed(fn: () => void): () => void;
+}
+/** This page's window id: 1 for the window the app opened. 1 where there is only one window. */
+export declare const currentWindowId: number;
+export declare function windowHandle(id: number): WindowHandle;
+/** The window this page runs in. */
+export declare function getCurrentWindow(): WindowHandle;
+/**
+ * Opens another window that loads `path` of this app (desktop). It stays hidden until its page
+ * has loaded, like the first window. UNSUPPORTED on web, iOS and Android. Pages of different
+ * windows share storage (localStorage, IndexedDB) and can talk through BroadcastChannel.
+ */
+export declare function createWindow(options?: CreateWindowOptions): Promise<WindowHandle>;
+/** Every window of the app, hidden ones included, by id. Only the current one where there is one window. */
+export declare function getAllWindows(): Promise<WindowHandle[]>;
+export declare function isDragRegion(path: EventTarget[]): boolean;
+/** The window state, kept up to date from resize/move/focus events. null until known or where unsupported. */
+export declare function useWindowState(): WindowState | null;
+/**
+ * Runs `handler` when the user asks to close this page's window (close button, Cmd+W). Call
+ * `event.preventDefault()` to keep it open, e.g. after asking to save. Without handlers, or if
+ * none prevents it, the window closes as usual. Desktop only: elsewhere it never fires
+ * (`appWindow.eventImplementation("closeRequested")` tells). Returns an unregister function.
+ */
+export declare const onCloseRequested: (handler: VetoHandler<{}>) => () => void;
+/** onCloseRequested while mounted; always calls the latest handler. */
+export declare function useCloseRequested(handler: VetoHandler<{}>): void;
+/** Files dragged over this window (desktop). Returns an unsubscribe function; never fires on web or mobile. */
+export declare function onDragDrop(handler: (event: DragDropEvent) => void): () => void;
+export {};

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

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

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

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

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

@@ -0,0 +1,7 @@
+import type { WindowStateApi } from "./index.ts";
+export declare const STATE_FILE = "window-state.json";
+export declare function createDesktopWindowState(options?: {
+    delay?: number;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<WindowStateApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<WindowStateApi, {}>;
+export default _default;

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

@@ -0,0 +1,33 @@
+/**
+ * Remembers the desktop window's position, size and maximized state across launches.
+ * Adding the plugin to akan-native.config.ts is all it takes: bounds are saved while the user moves
+ * or resizes the window and restored before the window is first shown (no visible jump).
+ *
+ * - Bounds are logical points of the normal (not maximized, not minimized, not full-screen)
+ *   window, like Tauri's window-state; `maximized` is kept separately so un-maximizing after a
+ *   restart returns to the last normal bounds.
+ * - A saved position whose title bar would be off every connected display is dropped, and the
+ *   window opens at the default place (a display was unplugged).
+ * - Full screen is not restored: on macOS it would open a new Space at launch.
+ * - Web, iOS and Android: UNSUPPORTED (the OS owns the window there).
+ */
+export interface SavedWindowState {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    maximized: boolean;
+}
+export interface WindowStateApi {
+    /** What the next launch will restore, or null when nothing is saved yet. */
+    getSaved(): Promise<{
+        state: SavedWindowState | null;
+    }>;
+    /** Saves the current bounds now instead of after the next move or resize settles. */
+    save(): Promise<{
+        state: SavedWindowState | null;
+    }>;
+    /** Forgets the saved state: the next launch uses the configured size again. */
+    clear(): Promise<void>;
+}
+export declare const windowState: import("../../../packages/core/src/plugin.ts").Plugin<WindowStateApi, {}>;

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

@@ -0,0 +1,39 @@
+import type { SavedWindowState } from "./index.ts";
+/** The part of window.getState this plugin reads. */
+export interface WindowSnapshot {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    maximized: boolean;
+    minimized: boolean;
+    fullscreen: boolean;
+    visible: boolean;
+}
+/** The saved file's contents, or null when it is missing, corrupt or from another format version. */
+export declare function parseSaved(text: string | null): SavedWindowState | null;
+export declare function serialize(state: SavedWindowState): string;
+/**
+ * The state to save after `snap`. Only a normal window says where it is; a maximized one only
+ * flips the flag, so un-maximizing after a restart returns to the last normal bounds (Tauri
+ * window-state keeps prev_x/prev_y for the same reason). Minimized, hidden or full-screen
+ * windows change nothing.
+ */
+export declare function nextState(prev: SavedWindowState | null, snap: WindowSnapshot): SavedWindowState | null;
+export interface Tracker {
+    readonly saved: SavedWindowState | null;
+    /** A move or resize happened: capture once things settle. */
+    changed(): void;
+    /** Captures now (and waits for a capture in flight). */
+    flush(): Promise<SavedWindowState | null>;
+    /** Forgets the saved state; the next capture starts over. */
+    clear(): void;
+    stop(): void;
+}
+export declare function createTracker(options: {
+    initial: SavedWindowState | null;
+    read(): Promise<WindowSnapshot>;
+    write(state: SavedWindowState): void;
+    /** Debounce for move/resize bursts, ms. Also lets the maximize animation finish. */
+    delay?: number;
+}): Tracker;

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

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

package/types/webkit/index.d.ts

@@ -4,8 +4,6 @@ export { createRobotPage, createSitemapPage } from "./seoPages.d.ts";
 export type * from "./types.d.ts";
 export { useBodyScrollLock } from "./useBodyScrollLock.d.ts";
 export { useCamera } from "./useCamera.d.ts";
-export { useCodepush } from "./useCodepush.d.ts";
-export { useContact } from "./useContact.d.ts";
 export { useCsrValues } from "./useCsrValues.d.ts";
 export { useDebounce } from "./useDebounce.d.ts";
 export { useEscapeKey } from "./useEscapeKey.d.ts";

package/types/webkit/nativeNavigation.d.ts

@@ -0,0 +1,25 @@
+export interface NativeBackState {
+    path: string;
+    keyboardHeight: number;
+    keyboardVisible: boolean;
+    router: {
+        back: () => void;
+    };
+}
+interface NativeNavigationOptions {
+    historyIdx: () => number;
+    backState: () => NativeBackState;
+    /** A back press while the keyboard is up only puts it away. */
+    dismissKeyboard: () => unknown;
+}
+/** A native shell's deep links, push taps and Android back button, for the CSR frame that owns the history. */
+export declare class NativeNavigation {
+    #private;
+    readonly options: NativeNavigationOptions;
+    constructor(options: NativeNavigationOptions);
+    listen(): () => void;
+    openDeepLink(url: string): void;
+    openPushLink(url: unknown): void;
+    back(): void;
+}
+export {};

package/types/webkit/nativePurchase.d.ts

@@ -0,0 +1,37 @@
+import { type IapTransaction } from "akanjs/client/native";
+export type PurchaseProductType = "consumable" | "nonConsumable" | "subscription";
+export interface PurchaseProductInfo {
+    id: string;
+    type: PurchaseProductType;
+}
+export interface BillingVerification {
+    platform: "apple" | "google";
+    packageName: string;
+    productId: string;
+    receipt: string;
+    transactionId: string;
+}
+export type PurchaseCallback = (transaction: IapTransaction, verified: unknown) => void | Promise<void>;
+export interface NativePurchaseOptions {
+    productInfo: PurchaseProductInfo[];
+    /** The verification server's origin; it answers `POST <url>/billing/verifyBilling`. */
+    url: string;
+    onPay?: PurchaseCallback;
+    onSubscribe?: PurchaseCallback;
+}
+export type SettleResult = "finished" | "unverified" | "skipped";
+/** One transaction's way from the store to the app: verified by the server, handed to the app, then finished. */
+export declare class NativePurchase {
+    #private;
+    readonly options: NativePurchaseOptions;
+    constructor(options: NativePurchaseOptions);
+    typeOf(productId: string): PurchaseProductType;
+    verificationOf({ id, productId, verification }: IapTransaction): Promise<BillingVerification | null>;
+    verify(transaction: IapTransaction): Promise<{
+        ok: true;
+        body: unknown;
+    } | {
+        ok: false;
+    }>;
+    settle(transaction: IapTransaction): Promise<SettleResult>;
+}

package/types/webkit/useCamera.d.ts

@@ -1,28 +1,26 @@
-import { type CapacitorPermissionState } from "akanjs/client/capacitor";
-type PermissionStatus = {
-    camera: CapacitorPermissionState;
-    photos: CapacitorPermissionState;
-};
-/** The four strings the native picker shows. Omitted ones come from the `base` dictionary. */
+type PermissionState = "granted" | "denied" | "prompt";
+/** The four strings the camera-or-library sheet shows. Omitted ones come from the `base` dictionary. */
 export interface CameraPromptLabels {
     header?: string;
     photo?: string;
     picture?: string;
     cancel?: string;
 }
-/** `checkPermission` opens the app settings when camera or photo access is denied. */
+/** Photos arrive as upright JPEG data URLs; a denied camera opens the app settings instead of resolving. */
 export declare const useCamera: ({ promptLabels }?: {
     promptLabels?: CameraPromptLabels;
 }) => {
-    permissions: PermissionStatus;
+    permissions: {
+        camera: PermissionState;
+    };
     getPhoto: (src?: "prompt" | "camera" | "photos") => Promise<{
-        [key: string]: unknown;
-        dataUrl?: string;
+        dataUrl: string;
     } | undefined>;
-    pickImage: () => Promise<{
-        [key: string]: unknown;
-        photos: unknown[];
-    }>;
-    checkPermission: (type: "photos" | "camera" | "all") => Promise<void>;
+    pickImage: ({ limit }?: {
+        limit?: number;
+    }) => Promise<{
+        dataUrl: string;
+    }[] | undefined>;
+    checkPermission: () => Promise<"prompt" | "denied" | "granted">;
 };
 export {};

package/types/webkit/useGeoLocation.d.ts

@@ -1,8 +1,7 @@
 /** `getPosition` opens the app settings instead of resolving when location permission is denied. */
 export declare const useGeoLocation: () => {
-    checkPermission: () => Promise<{
-        geolocation: string;
-        coarseLocation: string;
-    }>;
-    getPosition: () => Promise<unknown>;
+    checkPermission: () => Promise<import("../vendor/@akanjs/native/plugins/geolocation/src/index.d.ts").LocationPermission>;
+    getPosition: (options?: {
+        enableHighAccuracy?: boolean;
+    }) => Promise<import("akanjs/client/native").Position | undefined>;
 };

package/types/webkit/usePurchase.d.ts

@@ -1,20 +1,16 @@
-import "cordova-plugin-purchase/www/store";
+import { type IapProduct, type IapTransaction } from "akanjs/client/native";
+import { type NativePurchaseOptions } from "./nativePurchase.d.ts";
+export type { BillingVerification, PurchaseCallback, PurchaseProductInfo, PurchaseProductType, } from "./nativePurchase.d.ts";
 export type PlatformType = "android" | "ios" | "all";
-export interface ProductType {
-    id: string;
-    type: keyof typeof CdvPurchase.ProductType;
-}
-export type CdvProductType = CdvPurchase.ProductType;
-/** @deprecated Needs `cordova-plugin-purchase`, a package-wide peer dependency; use `@revenuecat/purchases-capacitor`. */
-export declare const usePurchase: ({ platform, productInfo, url, onPay, onSubscribe, }: {
+export type PurchaseResult = "purchased" | "pending" | "cancelled" | "unverified";
+interface UsePurchaseOptions extends NativePurchaseOptions {
+    /** The stores this app sells in; a native shell on another platform shows no products. */
     platform: PlatformType;
-    productInfo: ProductType[];
-    url: string;
-    onPay?: (transaction: CdvPurchase.Transaction) => void | Promise<void>;
-    onSubscribe?: (transaction: CdvPurchase.Transaction) => void | Promise<void>;
-}) => {
+}
+/** In-app purchase on the native iap plugin: StoreKit 2 on iOS, Play Billing on Android. The web sells nothing. */
+export declare const usePurchase: ({ platform, ...options }: UsePurchaseOptions) => {
     isLoading: boolean;
-    products: CdvPurchase.Product[];
-    purchaseProduct: (product: CdvPurchase.Product) => Promise<void>;
-    restorePurchases: () => Promise<void>;
+    products: IapProduct[];
+    purchaseProduct: (product: IapProduct | string, offerToken?: string) => Promise<PurchaseResult>;
+    restorePurchases: () => Promise<IapTransaction[]>;
 };