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

package/types/vendor/@akanjs/native/plugins/file-picker/src/index.d.ts

@@ -0,0 +1,84 @@
+import { AkanNativeError, type FileRef, type Plugin } from "../../../packages/core/src/index.ts";
+/** A file the user picked: a copy served by the host (web: a blob: URL of the browser's File). */
+export interface PickedFile extends FileRef {
+    /** The file's name as the user saw it, e.g. "Invoice.pdf". Never a path. */
+    name: string;
+}
+export interface DirectoryFile extends PickedFile {
+    /** Relative to the picked folder, "/"-separated, e.g. "2026/March/receipt.pdf". */
+    path: string;
+}
+export interface PickFilesOptions {
+    /**
+     * Allowed types: MIME types ("application/pdf", "image/*") or extensions ("pdf", ".csv").
+     * Omitted, empty or "*\/*": any file. A type the platform cannot map turns the filter off rather
+     * than hide files the user may be looking for.
+     */
+    types?: string[];
+    /** Let the user pick more than one file. Default false. */
+    multiple?: boolean;
+}
+export interface SaveFileOptions {
+    /** Suggested file name; the user can change it (the result says what was chosen, where known). */
+    name: string;
+    /** Text, or base64 with encoding: "base64". */
+    data?: string;
+    /** Default "utf8". */
+    encoding?: "utf8" | "base64";
+    /** Instead of data: a FileRef of this session (camera, filesystem.readFile, pickFiles) or a blob:/data:/same-origin URL. */
+    url?: string;
+    /** MIME type of the content (Android files the document under it). Default: from the name's extension. */
+    mime?: string;
+}
+export interface SaveFileResult {
+    /** False when the user closed the dialog. On the web without showSaveFilePicker this is true once the download started. */
+    saved: boolean;
+    /** The name the file was saved under, when the platform tells (it may differ from the suggestion). */
+    name?: string;
+}
+export interface PickDirectoryOptions {
+    /** Most files to return (1–10000, default 1000); `truncated` tells whether there were more. */
+    limit?: number;
+}
+export interface PickDirectoryResult {
+    /** The folder's name; null when the user closed the dialog. */
+    name: string | null;
+    /** Every file inside, recursively, as copies; hidden files and folders (".*") are left out. */
+    files: DirectoryFile[];
+    truncated: boolean;
+}
+/**
+ * System file dialogs.
+ * - pickFiles: UIDocumentPickerViewController (iOS, as copies), ACTION_OPEN_DOCUMENT (Android, copied
+ *   into the app cache), an NSOpenPanel sheet on the calling window (macOS), <input type=file> (web).
+ * - saveFile: the export picker (iOS), ACTION_CREATE_DOCUMENT (Android), an NSSavePanel sheet
+ *   (macOS), showSaveFilePicker or a download (web).
+ * - pickDirectory: a read-only snapshot of a folder the user picks: its files, copied like pickFiles.
+ * Results are copies registered as FileRefs; no absolute path reaches the page. Closing a dialog
+ * resolves (`files: []`, `saved: false`, `name: null`); a second dialog while one is open rejects
+ * CANCELLED. On the web call these from a click handler, before any await (user activation).
+ */
+export interface FilePickerApi {
+    pickFiles(options?: PickFilesOptions): Promise<{
+        files: PickedFile[];
+    }>;
+    saveFile(options: SaveFileOptions): Promise<SaveFileResult>;
+    pickDirectory(options?: PickDirectoryOptions): Promise<PickDirectoryResult>;
+}
+export type FilePicker = Plugin<FilePickerApi>;
+export declare const filePicker: FilePicker;
+export interface UseFilePicker {
+    supported: {
+        pickFiles: boolean;
+        saveFile: boolean;
+        pickDirectory: boolean;
+    };
+    pending: boolean;
+    /** Last failure. Closing a dialog is not a failure. */
+    error: AkanNativeError | null;
+    /** These resolve null on failure (see `error`). */
+    pickFiles(options?: PickFilesOptions): Promise<PickedFile[] | null>;
+    saveFile(options: SaveFileOptions): Promise<SaveFileResult | null>;
+    pickDirectory(options?: PickDirectoryOptions): Promise<PickDirectoryResult | null>;
+}
+export declare function useFilePicker(): UseFilePicker;

package/types/vendor/@akanjs/native/plugins/file-picker/src/web.d.ts

@@ -0,0 +1,6 @@
+import type { FilePickerApi, PickDirectoryResult } from "./index.ts";
+/** The accept attribute: MIME types as they are, extensions with a dot. */
+export declare function acceptAttribute(types: string[]): string;
+/** What pickDirectory makes of the files an <input webkitdirectory> returns. */
+export declare function directoryResult(files: File[], limit: number): PickDirectoryResult;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<FilePickerApi, {}>;

package/types/vendor/@akanjs/native/plugins/file-picker/src.d.ts

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

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

@@ -0,0 +1,49 @@
+import { AkanNativeError, type CallScope } from "../../../packages/core/src/index.ts";
+import type { BaseDirectory, Encoding, EntryType } from "./index.ts";
+export declare const BASES: readonly BaseDirectory[];
+export declare const invalid: (message: string) => AkanNativeError;
+export declare function checkObject(args: unknown, what?: string): Record<string, unknown>;
+export declare function checkBase(base: unknown, key?: string): BaseDirectory;
+/**
+ * A path relative to a base directory, as segments. Only "/" separates segments; "" and "."
+ * segments are dropped. Rejected: absolute paths, "..", backslashes and NUL, so a path can never
+ * leave its base by its spelling (tauri/crates/tauri/src/path/mod.rs:47 SafePathBuf rejects any
+ * ParentDir component the same way). Symbolic links are checked separately, after resolving.
+ * `allowRoot`: whether "" (the base itself) is acceptable, e.g. for readDir.
+ */
+export declare function checkPath(path: unknown, allowRoot: boolean, key?: string): string[];
+/**
+ * PL-11: the app's capabilities may limit filesystem calls to scopes { base?, path? } (globs; the
+ * path is relative to the base with "/" separators; an allowed wildcard never matches a dot file).
+ * `fold`: the base is on a case-insensitive volume. Throws NOT_ALLOWED outside the call's scope.
+ */
+export declare function checkScope(scope: CallScope | undefined, base: BaseDirectory, segments: string[], fold?: boolean): void;
+export declare function checkEncoding(encoding: unknown, allowNone: boolean): Encoding | undefined;
+export declare function checkFlag(value: unknown, key: string): boolean;
+/**
+ * A FileRef served by the host: "/__akan_native/file/<id>", absolute on the app origin, or null. The origin
+ * is the shell's (`__AKAN_NATIVE__.origin`); without one (the desktop plugin host, tests) either shell origin.
+ */
+export declare function fileRefId(url: string, origin?: string | undefined): string | null;
+export declare function checkBase64(data: string): void;
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function base64ToBytes(data: string): Uint8Array;
+export declare const decodeUtf8: (bytes: Uint8Array) => string;
+export declare const encodeUtf8: (text: string) => Uint8Array<ArrayBuffer>;
+/** Content to write: text or base64 `data`, or a `url` to copy from. Exactly one. */
+export type WriteSource = {
+    kind: "data";
+    data: string;
+    encoding: Encoding;
+} | {
+    kind: "url";
+    url: string;
+};
+export declare function checkWriteSource(args: Record<string, unknown>): WriteSource;
+export { mimeFor } from "../../../packages/core/src/index.ts";
+export declare function sortEntries<T extends {
+    name: string;
+}>(entries: T[]): T[];
+/** Runs tasks one after another in call order, so un-awaited calls (e.g. append chunks) land in order. */
+export declare function serialQueue(): <T>(task: () => Promise<T> | T) => Promise<T>;
+export type { EntryType };

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

@@ -0,0 +1,8 @@
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { BaseDirectory, FilesystemApi } from "./index.ts";
+type Dirs = Record<BaseDirectory, string>;
+/** The base folders for an app. Windows and Linux are unverified until those milestones. */
+export declare function baseDirs(ctx: Pick<DesktopContext, "app" | "appDataDir">, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, home?: string, tmp?: string): Dirs;
+export declare function createDesktopFilesystem(dirsFor?: (ctx: DesktopContext) => Dirs): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<FilesystemApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<FilesystemApi, {}>;
+export default _default;

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

@@ -0,0 +1,123 @@
+import { type FileRef, type Plugin } from "../../../packages/core/src/index.ts";
+/**
+ * Where a path lives. Paths are always relative to one of these; absolute paths and ".." are
+ * rejected with INVALID_ARGS, and symbolic links that lead outside the base with PERMISSION_DENIED.
+ *
+ * | base      | macOS                                   | iOS                                | Android                                        | web (OPFS) |
+ * |-----------|-----------------------------------------|------------------------------------|------------------------------------------------|------------|
+ * | data      | ~/Library/Application Support/<id>/files | Library/Application Support/files | files/ (Context.filesDir)                      | /data      |
+ * | cache     | ~/Library/Caches/<id>/files             | Library/Caches/files               | cache/files                                    | /cache     |
+ * | documents | ~/Documents                             | Documents                          | Android/data/<id>/files/Documents (external)   | /documents |
+ * | temp      | $TMPDIR/<id>/files                      | tmp/files                          | cache/temp                                     | /temp      |
+ *
+ * - data: kept until the app is removed, included in device backups.
+ * - cache, temp: the OS may delete them when storage runs low (iOS, Android) or at any time the app
+ *   is not running (iOS tmp). Not backed up.
+ * - documents: user-visible documents. On macOS the first access asks the user for the Documents
+ *   folder (TCC). On iOS the Files app shows it only if the app's Info.plist sets
+ *   UIFileSharingEnabled and LSSupportsOpeningDocumentsInPlace. On Android it is the app's own
+ *   external folder: no permission, removed with the app.
+ * - web: the origin private file system (navigator.storage.getDirectory()), one folder per base.
+ */
+export type BaseDirectory = "data" | "cache" | "documents" | "temp";
+export type Encoding = "utf8" | "base64";
+export type EntryType = "file" | "directory" | "symlink" | "other";
+export interface PathOptions {
+    /** Relative to `base`, "/"-separated, e.g. "notes/today.txt". */
+    path: string;
+    base: BaseDirectory;
+}
+export interface ReadFileOptions extends PathOptions {
+    /**
+     * "utf8" returns the text, "base64" the bytes as base64. Without an encoding the file is not
+     * sent over the bridge at all: the result is a FileRef whose `url` serves the file (fetch it,
+     * or use it as an <img>/<video> src), which is the way to read large or binary files.
+     */
+    encoding?: Encoding;
+}
+export type WriteFileOptions = PathOptions & {
+    /** Add to the end of the file instead of replacing it. Replacing writes are atomic (temp file + rename). */
+    append?: boolean;
+    /** Create missing parent folders. Without it a missing parent rejects NOT_FOUND. */
+    recursive?: boolean;
+} & ({
+    /** Text, or base64 with encoding: "base64". For large binary content write base64 chunks with append. */
+    data: string;
+    /** Default "utf8". */
+    encoding?: Encoding;
+    url?: never;
+} | {
+    /**
+     * Copy the content of this URL: a FileRef of this session (camera.takePhoto, file-picker,
+     * readFile), or a blob:, data: or same-origin URL, which the page fetches first.
+     */
+    url: string;
+    data?: never;
+    encoding?: never;
+});
+export interface FileInfo {
+    /** Symbolic links are followed by stat and reported as "symlink" by readDir. */
+    type: EntryType;
+    /** Bytes; 0 for folders. */
+    size: number;
+    /** Last modification, ms since the epoch (like Date.now()). 0 where unknown (OPFS folders). */
+    mtime: number;
+}
+export interface DirEntry extends FileInfo {
+    name: string;
+}
+export interface MoveOptions {
+    from: string;
+    to: string;
+    /** Base of `from`, and of `to` unless `toBase` is given. */
+    base: BaseDirectory;
+    toBase?: BaseDirectory;
+}
+export interface FilesystemApi {
+    readFile(options: PathOptions & {
+        encoding: Encoding;
+    }): Promise<{
+        data: string;
+    }>;
+    readFile(options: PathOptions & {
+        encoding?: undefined;
+    }): Promise<FileRef>;
+    readFile(options: ReadFileOptions): Promise<{
+        data: string;
+    } | FileRef>;
+    /** Creates or replaces the file (or appends to it). Parent folders must exist unless `recursive`. */
+    writeFile(options: WriteFileOptions): Promise<void>;
+    /** Entries of a folder ("" is the base itself), sorted by name. */
+    readDir(options: PathOptions): Promise<{
+        entries: DirEntry[];
+    }>;
+    stat(options: PathOptions): Promise<FileInfo>;
+    exists(options: PathOptions): Promise<{
+        value: boolean;
+    }>;
+    /** Without `recursive` the parent must exist and the folder must not (INVALID_ARGS). */
+    mkdir(options: PathOptions & {
+        recursive?: boolean;
+    }): Promise<void>;
+    /** Removes a file, a symbolic link (not its target) or a folder; non-empty folders need `recursive`. */
+    remove(options: PathOptions & {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Moves a file or folder, also across bases (copy + remove where the bases are on different
+     * volumes). An existing file at `to` is replaced; an existing folder rejects INVALID_ARGS.
+     */
+    rename(options: MoveOptions): Promise<void>;
+    /** Copies a file, or a folder with everything in it. Same rules for `to` as rename. */
+    copy(options: MoveOptions): Promise<void>;
+    /** Absolute locations of the bases, for display and logs only; other methods take relative paths. */
+    paths(): Promise<Record<BaseDirectory, string>>;
+}
+/**
+ * The iOS bridge parses requests with JSONSerialization, which drops a U+FEFF (byte order mark) at
+ * the start of any string value (verified). Such text goes as base64 there, so the bytes on disk are
+ * the ones written everywhere.
+ */
+export declare function protectLeadingBom(options: WriteFileOptions): WriteFileOptions;
+export type Filesystem = Plugin<FilesystemApi>;
+export declare const filesystem: Filesystem;

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

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

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

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

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;