@buoy-gg/permissions 7.0.44

package/lib/typescript/components/PermissionsToolView.d.ts

@@ -0,0 +1,10 @@
+import type { PermissionsSnapshot } from "../engine/store";
+export type PermissionsActionHandler = (action: string, params?: Record<string, unknown>) => Promise<unknown>;
+export interface PermissionsToolViewProps {
+    snapshot: PermissionsSnapshot | null;
+    onAction: PermissionsActionHandler;
+    /** Reload the app's JS so every screen asks again. Hidden when absent. */
+    onReload?: () => void;
+}
+export declare function PermissionsToolView({ snapshot, onAction, onReload }: PermissionsToolViewProps): import("react").JSX.Element;
+//# sourceMappingURL=PermissionsToolView.d.ts.map

package/lib/typescript/engine/adapters/android.d.ts

@@ -0,0 +1,13 @@
+/**
+ * React Native's PermissionsAndroid.
+ *
+ * It is one class instance shared by every import, and `check`, `request` and
+ * `requestMultiple` are prototype methods, so assigning them on the instance
+ * replaces them for every caller. On iOS the class only warns, so this runs
+ * on Android only.
+ */
+import { type PermissionId } from "../model";
+/** The permission id for an Android permission string. */
+export declare function androidPermissionId(permission: string): PermissionId;
+export declare function installAndroidAdapter(permissionsAndroid: object | null | undefined): boolean;
+//# sourceMappingURL=android.d.ts.map

package/lib/typescript/engine/adapters/expo.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Expo modules.
+ *
+ * Every Expo permission API ends in a native module method such as
+ * `ExpoLocation.getForegroundPermissionsAsync`. The JS wrappers
+ * (`Location.getForegroundPermissionsAsync`) and the `use…Permissions` hooks
+ * read that method at call time, so replacing it on the module object covers
+ * all of them. Nothing here imports an Expo package: modules are found by
+ * name on `globalThis.expo.modules`, and only the ones in the app's binary
+ * are touched.
+ *
+ * expo-maps and expo-calendar/next copy the method into their exports when
+ * they load, which is why the app should import `@buoy-gg/permissions`
+ * before its own code.
+ */
+import { type ExpoFlavor, type PermissionId } from "../model";
+interface PermissionMethod {
+    get: string;
+    request: string;
+    permission: PermissionId;
+    flavor: ExpoFlavor;
+    /** Arguments the JS wrapper passes when the app gives none (for the real prompt). */
+    defaultArgs?: (platform: "ios" | "android") => unknown[];
+}
+interface GatedMethod {
+    method: string;
+    permission: PermissionId;
+    /** Error the native module rejects with, per platform. Absent = not enforced there. */
+    ios?: {
+        code: string;
+        reason: string;
+    };
+    android?: {
+        code: string;
+        reason: string;
+    };
+}
+interface ExpoModuleSpec {
+    module: string;
+    library: string;
+    permissions: PermissionMethod[];
+    gated?: GatedMethod[];
+}
+/** Module names and methods, read from the Expo SDK 54/55 native sources. */
+export declare const EXPO_MODULES: ExpoModuleSpec[];
+/**
+ * Approximate location, the way iOS reduced accuracy reports it: the
+ * coordinate snapped to a grid about 2 km wide and an accuracy of 3 km.
+ */
+export declare function coarsenPosition<T>(position: T): T;
+/** Wrap every Expo permission API in the app's binary. Returns the libraries found. */
+export declare function installExpoAdapter(): string[];
+/**
+ * Ask each module for its real state (without prompting) so the tool shows
+ * what the OS says before the app has asked. Calls the originals, so it
+ * doesn't add entries to the call log.
+ */
+export declare function refreshExpoRealStates(): Promise<void>;
+export {};
+//# sourceMappingURL=expo.d.ts.map

package/lib/typescript/engine/adapters/rnPermissions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * react-native-permissions (5.x).
+ *
+ * Its JS calls the `RNPermissions` TurboModule at call time
+ * (`NativeModule.check(permission)`), and bridgeless TurboModules are cached
+ * objects with writable methods, so the native module object is the seam.
+ * The library's JS itself is never imported.
+ *
+ * Vocabulary: `unavailable | denied | blocked | granted | limited`. On iOS
+ * "never asked" reads as `denied` and a refusal as `blocked`.
+ */
+import { type PermissionId } from "../model";
+/** The permission id for a react-native-permissions string, or null to pass it through. */
+export declare function rnpPermissionId(permission: string): PermissionId | null;
+export declare function installRnPermissionsAdapter(nativeModule: object | null | undefined): boolean;
+//# sourceMappingURL=rnPermissions.d.ts.map

package/lib/typescript/engine/adapters/wrap.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Replacing a method on a native module object, once.
+ *
+ * Expo modules (`globalThis.expo.modules.X`) and bridgeless TurboModules are
+ * cached per name, and their methods are ordinary writable properties, so a
+ * replacement is seen by every caller that reads the method at call time.
+ * The original is kept so a second install (Fast Refresh, a second import)
+ * wraps it again instead of wrapping the wrapper.
+ */
+declare const ORIGINAL = "__buoyPermissionsOriginal";
+type AnyFn = ((...args: unknown[]) => unknown) & {
+    [ORIGINAL]?: AnyFn;
+};
+export declare function originalOf(target: object, method: string): AnyFn | null;
+/**
+ * Replace `target[method]`. `make` gets the original, bound to the target.
+ * Returns false when the method is missing or the object refuses the write.
+ */
+export declare function wrapMethod(target: object, method: string, make: (original: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown): boolean;
+/** An error shaped like the ones Expo modules reject with. */
+export declare function codedError(code: string, message: string): Error & {
+    code: string;
+};
+export {};
+//# sourceMappingURL=wrap.d.ts.map

package/lib/typescript/engine/appSettings.d.ts

@@ -0,0 +1,32 @@
+import { type PermissionId } from "./model";
+import type { AlertLike } from "./prompt";
+type Emitter = {
+    emit(event: string, payload?: unknown): void;
+};
+export declare function configureAppSettings(options: {
+    emitter: Emitter | null;
+    alert: AlertLike | null;
+}): void;
+/** Leave for Settings, the way the platform reports it. */
+export declare function simulateLeaveApp(): void;
+/** Come back from Settings. iOS reports background (will-enter-foreground) then active. */
+export declare function simulateReturnToApp(): void;
+/**
+ * After a change from the tool: background → active, so screens that
+ * re-check permissions when the app comes back see the new state. Batched,
+ * so flipping several rows sends one round trip.
+ */
+export declare function notifyAppOfChange(): void;
+/** The permission the app most likely sent the user to Settings for. */
+export declare function settingsTarget(): PermissionId | null;
+/**
+ * Show Buoy's stand-in for the Settings app. Resolves once the app is
+ * "back" (after the user picks, or leaves it as is).
+ */
+export declare function openSettingsStandIn(id: PermissionId, via: string): Promise<void>;
+/** Intercept the ways an app opens its own Settings page. */
+export declare function installSettingsIntercept(linking: object | null | undefined): void;
+/** react-native-permissions' `openSettings(type)`. */
+export declare function installRnpSettingsIntercept(nativeModule: object | null | undefined): void;
+export {};
+//# sourceMappingURL=appSettings.d.ts.map

package/lib/typescript/engine/install.d.ts

@@ -0,0 +1,3 @@
+/** Install once per JS runtime. Returns false when already installed or not possible here. */
+export declare function installPermissions(): boolean;
+//# sourceMappingURL=install.d.ts.map

package/lib/typescript/engine/install.web.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Web and Buoy Desktop render the Permissions panel but never patch
+ * permission APIs: the browser has its own permission model, and Desktop
+ * shows a phone's state over the socket.
+ */
+export declare function installPermissions(): boolean;
+//# sourceMappingURL=install.web.d.ts.map

package/lib/typescript/engine/model.d.ts

@@ -0,0 +1,115 @@
+/**
+ * The permission model: one canonical state per permission, which states each
+ * platform can produce, what a permission request does from each state, and
+ * how a state reads in each library's vocabulary.
+ *
+ * Pure. No React Native imports, so every rule here is unit tested directly.
+ *
+ * Canonical states:
+ * - `undetermined`: never asked. A request shows the system prompt.
+ * - `granted`: full access.
+ * - `limited`: partial access (selected photos or contacts, approximate
+ *   location, provisional notifications).
+ * - `denied`: refused. On Android the app may ask once more. On iOS a refusal
+ *   is final, so iOS `denied` reads the same as `blocked`.
+ * - `blocked`: refused for good (Android "don't ask again"). Only Settings
+ *   can change it.
+ * - `restricted`: iOS parental controls or device management. The user can't
+ *   change it either.
+ */
+export type PermissionState = "undetermined" | "granted" | "limited" | "denied" | "blocked" | "restricted";
+export declare const PERMISSION_STATES: readonly PermissionState[];
+export type Platform = "ios" | "android";
+/** How the tool answers a request made from `undetermined` (or Android `denied`). */
+export type RequestAnswer = "ask" | "allow" | "limited" | "deny";
+export declare const REQUEST_ANSWERS: readonly RequestAnswer[];
+/**
+ * An answer to a prompt. `once` is "Allow Once" / "Only this time": allowed
+ * now, back to not asked after the app restarts.
+ */
+export type PromptAnswer = Exclude<RequestAnswer, "ask"> | "once";
+export type PermissionId = "location" | "locationBackground" | "camera" | "microphone" | "notifications" | "photos" | "contacts" | "calendar" | "reminders" | "tracking" | "motion" | "bluetooth" | `android:${string}`;
+export interface PermissionInfo {
+    id: PermissionId;
+    label: string;
+    /** What `limited` means for this permission, per platform. Absent = no limited state. */
+    limited?: Partial<Record<Platform, string>>;
+    /** Only exists on this platform. */
+    only?: Platform;
+    /** Words for the prompt: "use your location", "access your camera". */
+    purpose: string;
+}
+export declare const KNOWN_PERMISSION_IDS: PermissionId[];
+export declare function isPermissionId(value: unknown): value is PermissionId;
+export declare function permissionInfo(id: PermissionId): PermissionInfo;
+/** The states this permission can really be in on this platform, in picker order. */
+export declare function supportedStates(id: PermissionId, platform: Platform): PermissionState[];
+export declare function isSupported(id: PermissionId, platform: Platform, state: PermissionState): boolean;
+/**
+ * The state as the platform would really report it. iOS never reports
+ * "blocked" (a refusal is already final) and Android never reports
+ * "restricted". Unknown combinations fall back to the nearest real one.
+ */
+export declare function normalizeState(id: PermissionId, platform: Platform, state: PermissionState): PermissionState;
+/** Can a request from this state show a prompt? */
+export declare function canPrompt(platform: Platform, state: PermissionState): boolean;
+/**
+ * What a request does. Returns the state afterwards. `answer` is only used
+ * when a prompt would show; a `ask` answer must be resolved to a concrete one
+ * by the caller before calling this.
+ */
+export declare function stateAfterRequest(id: PermissionId, platform: Platform, state: PermissionState, answer: PromptAnswer): PermissionState;
+/** The prompt's buttons, in the platform's order. */
+export declare function promptChoices(id: PermissionId, platform: Platform): {
+    answer: PromptAnswer;
+    label: string;
+}[];
+/**
+ * The option names the Settings app uses for this permission, so Buoy's
+ * stand-in reads like the real page.
+ */
+export declare function settingsLabel(id: PermissionId, platform: Platform, state: PermissionState): string;
+/** One sentence on what a state means for this permission, for the picker. */
+export declare function stateDescription(id: PermissionId, platform: Platform, state: PermissionState): string;
+export interface ExpoPermissionResponse {
+    status: "granted" | "denied" | "undetermined" | string;
+    granted?: boolean;
+    canAskAgain?: boolean;
+    expires?: "never" | number;
+    accessPrivileges?: "all" | "limited" | "none";
+    scope?: string;
+    ios?: Record<string, unknown> & {
+        status?: number;
+        scope?: string;
+        accuracy?: string;
+    };
+    android?: Record<string, unknown> & {
+        accuracy?: string;
+        importance?: number;
+    };
+    [key: string]: unknown;
+}
+/** An Expo `PermissionResponse` as a canonical state. */
+export declare function fromExpo(response: unknown, platform: Platform): PermissionState | null;
+export type RnpResult = "unavailable" | "denied" | "blocked" | "granted" | "limited";
+/**
+ * A react-native-permissions result as a canonical state. The library reports
+ * "never asked" as `denied` on iOS, so `denied` there means undetermined.
+ */
+export declare function fromRnp(result: unknown, platform: Platform): PermissionState | null;
+/** Which extra fields a module's PermissionResponse carries. */
+export type ExpoFlavor = "plain" | "location" | "locationBackground" | "notifications" | "privileges";
+/**
+ * The PermissionResponse an Expo module would return in this state. `base` is
+ * the module's real response, so fields the override doesn't concern (and
+ * fields added in newer SDKs) survive.
+ */
+export declare function toExpo(state: PermissionState, platform: Platform, flavor: ExpoFlavor, base?: unknown): ExpoPermissionResponse;
+/** react-native-permissions' result for this state. */
+export declare function toRnp(state: PermissionState, platform: Platform): RnpResult;
+/** PermissionsAndroid.request's result for this state. */
+export declare function toAndroidRequestResult(state: PermissionState): "granted" | "denied" | "never_ask_again";
+/** PermissionsAndroid.check's result: is this exact Android permission held? */
+export declare function toAndroidCheck(state: PermissionState, androidPermission: string): boolean;
+export declare function stateLabel(id: PermissionId, platform: Platform, state: PermissionState): string;
+//# sourceMappingURL=model.d.ts.map

package/lib/typescript/engine/persistence.d.ts

@@ -0,0 +1,36 @@
+import { type PermissionId, type PermissionState, type RequestAnswer } from "./model";
+export { readSavedSync } from "./readSavedSync";
+export interface PermissionsSettings {
+    /** How a request from "not asked" is answered while overridden. */
+    requestAnswer: RequestAnswer;
+    /** Keep overrides across reloads and restarts. */
+    persist: boolean;
+    /** Show the floating chip while any override is on. */
+    showChip: boolean;
+    /**
+     * After a change from the tool, send the app a background → active
+     * AppState change, the same thing a real trip to Settings produces, so
+     * screens that re-check on return pick up the new state.
+     */
+    notifyApp: boolean;
+    /**
+     * Make calls that need a permission (current position, launch camera…)
+     * fail the way the native module fails when it is overridden to a refusal.
+     */
+    enforce: boolean;
+    /** While overridden, "Open Settings" shows Buoy's stand-in instead of leaving the app. */
+    interceptSettings: boolean;
+}
+export declare const DEFAULT_SETTINGS: PermissionsSettings;
+export interface SavedPermissions {
+    v: 1;
+    overrides: Partial<Record<PermissionId, PermissionState>>;
+    settings: PermissionsSettings;
+}
+export declare const PERMISSIONS_STORAGE_KEY: "@react_buoy_permissions_state";
+export declare function parseSettings(raw: unknown): PermissionsSettings;
+export declare function parseSaved(raw: string | null | undefined): SavedPermissions | null;
+export declare function readSavedAsync(): Promise<SavedPermissions | null>;
+/** Queue a write; the last call wins. */
+export declare function writeSaved(saved: SavedPermissions): Promise<void>;
+//# sourceMappingURL=persistence.d.ts.map

package/lib/typescript/engine/prompt.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Buoy's stand-in for the system permission prompt.
+ *
+ * While a permission is overridden, the real prompt must not show (it would
+ * change the device's real state), so a request from "not asked" shows this
+ * one instead: a native alert with the platform's own button labels. On iOS
+ * the message is the app's own purpose string when the Expo config has it,
+ * since that copy is part of what's being tested. A last line says the
+ * prompt is Buoy's, so nobody mistakes it for the real thing.
+ */
+import { type PermissionId, type PromptAnswer } from "./model";
+export interface AlertButton {
+    text: string;
+    onPress?: () => void;
+    style?: "default" | "cancel" | "destructive";
+}
+export interface AlertLike {
+    alert(title: string, message?: string, buttons?: AlertButton[], options?: {
+        cancelable?: boolean;
+        onDismiss?: () => void;
+    }): void;
+}
+/** The app's purpose string for this permission, when its Expo config says. */
+export declare function readPurposeString(id: PermissionId): string | null;
+export declare function createAlertPrompter(alert: AlertLike): (id: PermissionId) => Promise<PromptAnswer>;
+//# sourceMappingURL=prompt.d.ts.map

package/lib/typescript/engine/readSavedSync.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read the saved permission overrides synchronously, from the file persistentStorage
+ * writes under Documents/react-buoy/, via expo-file-system's `File.textSync()`
+ * (SDK 54+). `undefined` means a synchronous read isn't possible here.
+ */
+import { type SavedPermissions } from "./persistence";
+/** The saved permission overrides, read synchronously, or `undefined` if that's impossible here. */
+export declare function readSavedSync(): SavedPermissions | null | undefined;
+//# sourceMappingURL=readSavedSync.d.ts.map

package/lib/typescript/engine/readSavedSync.web.d.ts

@@ -0,0 +1,4 @@
+import type { SavedPermissions } from "./persistence";
+/** Web and Buoy Desktop never patch permission APIs, so there is nothing to read early. */
+export declare function readSavedSync(): SavedPermissions | null | undefined;
+//# sourceMappingURL=readSavedSync.web.d.ts.map

package/lib/typescript/engine/store.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The permissions store: which permissions are overridden and to what, the
+ * settings, what the app has asked for, and a log of every call.
+ *
+ * Adapters (Expo, PermissionsAndroid, react-native-permissions) report calls
+ * here and ask it for the state to return. The tool screen, the sync adapter
+ * (Desktop, MCP, Ask Buoy) and the chip read the same snapshot.
+ */
+import { type PermissionId, type PermissionState, type Platform, type PromptAnswer } from "./model";
+import { type PermissionsSettings } from "./persistence";
+export type CallKind = "check" | "request" | "settings" | "gated";
+export interface CallLogEntry {
+    id: number;
+    at: number;
+    /** "expo-location", "PermissionsAndroid", "react-native-permissions"… */
+    source: string;
+    method: string;
+    permission: PermissionId | null;
+    kind: CallKind;
+    /** What the OS said, when it was asked. */
+    real: PermissionState | null;
+    /** What the app received. */
+    returned: PermissionState | null;
+    overridden: boolean;
+    /** For a request that prompted: the answer given. */
+    answer?: PromptAnswer;
+    /** A gated call Buoy failed, or a call that threw. */
+    error?: string;
+}
+export interface PermissionRow {
+    id: PermissionId;
+    label: string;
+    /** States the picker offers on this platform. */
+    states: PermissionState[];
+    override: PermissionState | null;
+    /** The OS's answer the last time anything asked. */
+    real: PermissionState | null;
+    /** What the app sees now: the override, else the real state. */
+    effective: PermissionState | null;
+    /** Libraries that can reach this permission in this app. */
+    sources: string[];
+    calls: number;
+    lastCallAt: number | null;
+    /** When the app last checked or requested it (not Settings trips or gated calls). */
+    lastReadAt: number | null;
+    /** When the tool last changed what the app sees (set or cleared). */
+    changedAt: number | null;
+    /**
+     * The app read this permission before the last change and hasn't read it
+     * since, so a screen may still show the old answer.
+     */
+    stale: boolean;
+    /** Granted with "Allow Once": back to not asked after the app restarts. */
+    once: boolean;
+    /** The override grants access the OS hasn't: native calls can still fail. */
+    warning: string | null;
+    /** An installed library can show the real system prompt for this permission. */
+    canRequestReal: boolean;
+}
+/** Where the app runs, so a host (MCP, Desktop) can change the real OS state. */
+export interface HostInfo {
+    isSimulator: boolean | null;
+    deviceName: string | null;
+    bundleId: string | null;
+}
+export interface PermissionsSnapshot {
+    platform: Platform;
+    host: HostInfo;
+    /** Adapters installed on this runtime, by library name. */
+    libraries: string[];
+    permissions: PermissionRow[];
+    overriddenCount: number;
+    settings: PermissionsSettings;
+    /** Newest first. */
+    log: CallLogEntry[];
+}
+type Prompter = (id: PermissionId) => Promise<PromptAnswer>;
+type ChangeHook = (change: {
+    id: PermissionId | null;
+    from: "tool" | "request";
+}) => void;
+type RealRequester = () => Promise<PermissionState | null>;
+/** Set the platform and host (install does this). */
+export declare function configurePermissions(options: {
+    platform: Platform;
+    host?: HostInfo;
+}): void;
+/**
+ * Restore saved overrides. Synchronous when expo-file-system allows it, so a
+ * launch-time permission check already sees them. Idempotent.
+ */
+export declare function bootPermissions(): void;
+/** Adapters register how to show the real system prompt for a permission. First one wins. */
+export declare function registerRealRequester(id: PermissionId, fn: RealRequester): void;
+export declare function canRequestReal(id: PermissionId): boolean;
+/**
+ * Show the real system prompt, whatever the override says, so the device
+ * grants what the override pretends. The system only prompts from "not
+ * asked"; after that it returns its answer without a prompt.
+ */
+export declare function requestRealPermission(idInput: unknown): Promise<PermissionsSnapshot>;
+export declare function setPrompter(fn: Prompter | null): void;
+export declare function onPermissionChange(hook: ChangeHook): () => void;
+/** Adapters announce which libraries they found and which permissions each can reach. */
+export declare function registerLibrary(library: string, permissions: PermissionId[]): void;
+export declare function getPlatform(): Platform;
+export declare function getSettings(): PermissionsSettings;
+export declare function getOverride(id: PermissionId): PermissionState | null;
+export declare function isOverridden(id: PermissionId): boolean;
+export declare function anyOverride(): boolean;
+/** Remember what the OS reported. */
+export declare function noteReal(id: PermissionId, real: PermissionState | null, source?: string): void;
+export declare function recordCall(entry: Omit<CallLogEntry, "id" | "at">): CallLogEntry;
+/**
+ * A request for an overridden permission. Shows Buoy's prompt (or uses the
+ * preset answer) when the state allows a prompt, moves the override the way
+ * the OS would, and returns the new state.
+ */
+export declare function resolveRequest(id: PermissionId): Promise<{
+    state: PermissionState;
+    answer?: PromptAnswer;
+}>;
+/** Override a permission. The state must exist on this platform. */
+export declare function setOverride(idInput: unknown, stateInput: unknown): PermissionsSnapshot;
+/** Stop overriding one permission: the app sees the OS's answer again. */
+export declare function clearOverride(idInput: unknown): PermissionsSnapshot;
+/** Stop every override. */
+export declare function resetPermissions(): PermissionsSnapshot;
+/** The overrides as they are now, for putting them back after a reset (undo). */
+export declare function getOverrides(): Partial<Record<PermissionId, PermissionState>>;
+/** Replace every override at once: undo for a reset. */
+export declare function restoreOverrides(overrides: Partial<Record<PermissionId, PermissionState>>): PermissionsSnapshot;
+export declare function updatePermissionSettings(patch: Partial<Record<keyof PermissionsSettings, unknown>>): PermissionsSnapshot;
+export declare function clearPermissionLog(): PermissionsSnapshot;
+export declare function getPermissionsSnapshot(): PermissionsSnapshot;
+export declare function subscribePermissions(listener: () => void): () => void;
+/** For tests: forget everything. */
+export declare function __resetPermissionsForTests(platform?: Platform): void;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/index.d.ts

@@ -0,0 +1,13 @@
+export { permissionsToolPreset, createPermissionsTool } from "./preset";
+export { PermissionsBody } from "./components/PermissionsBody";
+export { PermissionsToolView } from "./components/PermissionsToolView";
+export type { PermissionsToolViewProps, PermissionsActionHandler, } from "./components/PermissionsToolView";
+export { PermissionsChip, openPermissionsChip, PERMISSIONS_CHIP_ID, } from "./components/PermissionsChip";
+export { PermissionsIcon, PERMISSIONS_ICON_COLOR } from "@buoy-gg/shared-ui";
+export { permissionsSyncAdapter } from "./sync/permissionsSyncAdapter";
+export { installPermissions } from "./engine/install";
+export { setOverride as setPermissionOverride, clearOverride as clearPermissionOverride, resetPermissions, updatePermissionSettings, getPermissionsSnapshot, subscribePermissions, isOverridden as isPermissionOverridden, getOverride as getPermissionOverride, } from "./engine/store";
+export type { PermissionsSnapshot, PermissionRow, CallLogEntry, } from "./engine/store";
+export type { PermissionsSettings } from "./engine/persistence";
+export { supportedStates, stateLabel, permissionInfo, PERMISSION_STATES, KNOWN_PERMISSION_IDS, type PermissionId, type PermissionState, type RequestAnswer, } from "./engine/model";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/preset.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pre-configured Permissions tool for FloatingDevTools.
+ *
+ * @example
+ * ```tsx
+ * import { permissionsToolPreset } from '@buoy-gg/permissions';
+ *
+ * <FloatingDevTools apps={[permissionsToolPreset]} />
+ * ```
+ */
+import { PermissionsBody } from "./components/PermissionsBody";
+export declare const permissionsToolPreset: {
+    id: string;
+    name: string;
+    description: string;
+    slot: "both";
+    color: string;
+    icon: ({ size, color }: {
+        size: number;
+        color?: string;
+        slot?: string;
+    }) => import("react").JSX.Element;
+    component: typeof PermissionsBody;
+    modal: {
+        subtitle: string;
+    };
+};
+/** Create a custom Permissions tool configuration. */
+export declare const createPermissionsTool: (options?: (Record<never, never> & import("@buoy-gg/shared-ui").ToolPresetOverrides) | undefined) => {
+    id: string;
+    name: string;
+    description: string;
+    slot: "both";
+    color: string;
+    icon: ({ size, color }: {
+        size: number;
+        color?: string;
+        slot?: string;
+    }) => import("react").JSX.Element;
+    component: typeof PermissionsBody;
+    modal: {
+        subtitle: string;
+    };
+};
+//# sourceMappingURL=preset.d.ts.map

package/lib/typescript/sync/permissionsSyncAdapter.d.ts

@@ -0,0 +1,19 @@
+import { type PermissionsSnapshot } from "../engine/store";
+export declare const permissionsSyncAdapter: import("@buoy-gg/shared-ui").SyncAdapter<PermissionsSnapshot, {
+    /** Current overrides, what the OS says, and the recent calls. Re-reads the OS first. */
+    getState(): Promise<PermissionsSnapshot>;
+    setOverride(params: unknown): PermissionsSnapshot;
+    clearOverride(params: unknown): PermissionsSnapshot;
+    /**
+     * Show the real system prompt for a permission, ignoring the override, so
+     * the device grants what the override pretends. Only prompts from "not asked".
+     */
+    requestReal(params: unknown): Promise<PermissionsSnapshot>;
+    resetAll(): PermissionsSnapshot;
+    updateSettings(params: unknown): PermissionsSnapshot;
+    clearLog(): PermissionsSnapshot;
+    /** Send the app background → active, as a real return from Settings does. */
+    simulateReturnFromSettings(): PermissionsSnapshot;
+}>;
+export type PermissionsAction = keyof NonNullable<typeof permissionsSyncAdapter.actions>;
+//# sourceMappingURL=permissionsSyncAdapter.d.ts.map