@marktiderman/genesis-native 0.1.0 → 0.3.0

package/dist/blocks-a1YQ1Elf.d.ts

@@ -0,0 +1,1540 @@
+import * as react from 'react';
+import { ReactNode, ComponentType, Component, ErrorInfo } from 'react';
+import { Slots, SlotPropsFor } from '@marktiderman/genesis-core/slots';
+import { BlockDef, Contributed, BlockSettingsRow, ResolvedBlocks } from '@marktiderman/genesis-features/blocks';
+import { QueryClient, QueryClientConfig } from '@tanstack/react-query';
+import { CanonicalBrand } from '@marktiderman/genesis-design-system';
+import { SupabaseClientInput, DataProvider } from '@marktiderman/genesis-core/provider';
+import { KeyboardScrollProps, KeyboardToolbarProps } from '@marktiderman/genesis-ui-native/layouts';
+import { GenesisModules, NativeSheetLibrary, NativeToastProviderProps } from '@marktiderman/genesis-ui-native/components';
+import { b as QueryPersistence, Q as QueryLifecycleOptions } from './query-DUmVAfsF.js';
+
+interface BootStepContext {
+    /**
+     * Aborted when the step times out. Stop work when it fires: a retry waits
+     * for a timed-out run to settle before running the step again.
+     */
+    signal: AbortSignal;
+}
+interface BootStep {
+    /** Unique within the list; names the step in errors. */
+    id: string;
+    run: (context: BootStepContext) => Promise<unknown> | unknown;
+    /** Overrides the boot's `timeoutMs` for this step. */
+    timeoutMs?: number;
+}
+type BootStatus = "idle" | "booting" | "ready" | "failed";
+interface BootState {
+    status: BootStatus;
+    /** Set when `status` is `"failed"`. */
+    error: Error | null;
+    /** The id of the step that failed. */
+    failedStep: string | null;
+    /** Ids of the steps that have finished, in order. */
+    completed: readonly string[];
+}
+interface BootOptions {
+    /** Shortest time the boot takes, so the splash doesn't flash. Default 0. */
+    minimumMs?: number;
+    /** Longest time one step may take. Default 10 000. */
+    timeoutMs?: number;
+}
+interface BootController {
+    getState(): BootState;
+    subscribe(listener: () => void): () => void;
+    /** Run the steps not yet finished. Calling it while a run is in flight returns that run. */
+    start(): Promise<void>;
+    /** After a failure: run again from the step that failed. */
+    retry(): Promise<void>;
+}
+/** Thrown when a step takes longer than its timeout. */
+declare class BootTimeoutError extends Error {
+    readonly step: string;
+    constructor(step: string, ms: number, reason?: string);
+}
+/** The boot controller: runs `steps` once each, in order, with a timeout per step. */
+declare function createBoot(steps: readonly BootStep[], options?: BootOptions): BootController;
+/** Makes a boot readable with `useBoot()`. */
+declare function BootProvider({ boot, children }: {
+    boot: BootController;
+    children: ReactNode;
+}): react.JSX.Element;
+interface UseBootReturn extends BootState {
+    retry: () => void;
+}
+/** The boot's status, and `retry` after a failure. Inside `GenesisNativeApp` or a `BootProvider`. */
+declare function useBoot(): UseBootReturn;
+
+interface FatalScreenProps {
+    error: Error;
+    /** Clears the error and remounts the app below the shell (and re-runs a failed boot). */
+    retry: () => void;
+}
+/** The default fatal screen: what went wrong and "Try again". */
+declare function FatalScreen({ error, retry }: FatalScreenProps): react.JSX.Element;
+/**
+ * The last-resort fatal screen: React Native primitives only, no theme, no
+ * context, nothing that can itself fail. Shown when the providers could not
+ * start, or when the `fatal` slot threw.
+ */
+declare function PlainFatalScreen({ error, retry }: FatalScreenProps): react.JSX.Element;
+interface ErrorReport {
+    /** True when the app could not go on (a render error, a failed boot, a fatal global error). */
+    fatal: boolean;
+    source: "boundary" | "global" | "boot" | "rejection";
+    componentStack?: string;
+}
+type OnError = (error: Error, report: ErrorReport) => void;
+interface GenesisErrorBoundaryProps {
+    children?: ReactNode;
+    /** What to render instead of the tree that threw. */
+    fallback: ComponentType<FatalScreenProps>;
+    onError?: OnError;
+    /** Change it to clear a caught error (the tree remounts). */
+    resetKey?: unknown;
+    /** Called by the fallback's retry, after the error is cleared. */
+    onRetry?: () => void;
+}
+interface BoundaryState {
+    error: Error | null;
+}
+/** An error boundary whose fallback gets `{ error, retry }`. */
+declare class GenesisErrorBoundary extends Component<GenesisErrorBoundaryProps, BoundaryState> {
+    state: BoundaryState;
+    static getDerivedStateFromError(error: unknown): BoundaryState;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    componentDidUpdate(previous: GenesisErrorBoundaryProps): void;
+    retry: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react.JSX.Element | null;
+}
+/** React Native's `ErrorUtils` (a global in every RN app), or a stand-in. */
+interface ErrorUtilsLike {
+    getGlobalHandler(): ((error: unknown, isFatal?: boolean) => void) | undefined;
+    setGlobalHandler(handler: (error: unknown, isFatal?: boolean) => void): void;
+}
+interface GlobalErrorHandlerOptions {
+    errorUtils: ErrorUtilsLike;
+    onError?: OnError;
+    /** A fatal error: show the fatal screen. The previous handler (which would end the app) is not called. */
+    onFatal: (error: Error) => void;
+    /**
+     * True while a fatal screen is already up. Another fatal error then goes to
+     * the previous handler, which ends the app (it restarts clean) rather than
+     * leaving it stuck behind a screen that may itself be broken.
+     */
+    alreadyFatal?: () => boolean;
+}
+/**
+ * Route global errors to `onError`. A fatal one goes to `onFatal` instead of
+ * React Native's default handler, which would close the app; a non-fatal one
+ * still reaches the previous handler (LogBox in development). Returns a
+ * function that puts the previous handler back.
+ */
+declare function installGlobalErrorHandler({ errorUtils, onError, onFatal, alreadyFatal }: GlobalErrorHandlerOptions): () => void;
+/** `globalThis.ErrorUtils` in a React Native runtime, undefined elsewhere. */
+declare function defaultErrorUtils(): ErrorUtilsLike | undefined;
+/** Hermes's `HermesInternal.enablePromiseRejectionTracker`, or a stand-in. */
+type EnableRejectionTracker = (options: {
+    allRejections: boolean;
+    onUnhandled: (id: number, rejection: unknown) => void;
+    onHandled: (id: number) => void;
+}) => void;
+/**
+ * Hermes's rejection tracker, when the app runs on Hermes. React Native sends
+ * unhandled rejections to `ExceptionsManager` (LogBox in development), never
+ * to `ErrorUtils`' global handler, so without this they never reach `onError`.
+ */
+declare function defaultRejectionTracker(): EnableRejectionTracker | undefined;
+/**
+ * Report unhandled promise rejections to `onError` (non-fatal). This replaces
+ * React Native's own tracker, so each rejection is also written with
+ * `console.warn`, which LogBox shows in development as before.
+ */
+declare function installRejectionTracker({ enable, onError }: {
+    enable: EnableRejectionTracker;
+    onError: OnError;
+}): void;
+
+/** The parts of a Supabase client the gate uses; a `SupabaseClient` fits. */
+interface AuthClientLike<S = unknown> {
+    auth: {
+        getSession(): Promise<{
+            data: {
+                session: S | null;
+            };
+            error?: unknown;
+        }>;
+        onAuthStateChange(callback: (event: string, session: S | null) => void): {
+            data: {
+                subscription: {
+                    unsubscribe(): void;
+                };
+            };
+        };
+    };
+}
+type SessionStatus = "loading" | "signedIn" | "signedOut";
+interface SessionState<S = unknown> {
+    status: SessionStatus;
+    session: S | null;
+    /** The signed-in user's id, or null. */
+    userId: string | null;
+    /** True when the session came from the phone because Supabase couldn't be reached. */
+    offline: boolean;
+}
+interface SessionStore<S = unknown> {
+    getState(): SessionState<S>;
+    subscribe(listener: () => void): () => void;
+    /** Read the current session (the boot step). Throws only on a non-network error. */
+    load(): Promise<void>;
+    /** Follow sign-in and sign-out; returns the unsubscribe. */
+    start(): () => void;
+}
+interface SessionStoreOptions<S = unknown> {
+    /**
+     * The signed-in user changed after the session was first known: signed
+     * out, signed in, or switched account. `previous` and `next` are user ids
+     * (null when nobody). Clear caches here.
+     */
+    onUserChange?: (previous: string | null, next: string | null) => void;
+    /** Longest wait for `getSession()` before using the stored session. Default 5000 ms. */
+    waitMs?: number;
+    /**
+     * Read the session saved on the phone without refreshing it. Default: from
+     * the Supabase client's own storage (`auth.storage` under `auth.storageKey`).
+     */
+    readStoredSession?: () => Promise<S | null>;
+    /** The user id in a session. Default `session.user.id`. */
+    userIdOf?: (session: S) => string | null;
+}
+/** The Supabase session as a store: `load` reads it once, `start` follows auth events. */
+declare function createSessionStore<S = unknown>(client: AuthClientLike<S>, options?: SessionStoreOptions<S>): SessionStore<S>;
+/** Makes a session store readable with `useSession()`. */
+declare function SessionProvider({ store, children }: {
+    store: SessionStore;
+    children: ReactNode;
+}): react.JSX.Element;
+/** The session and whether it is known yet. Inside `GenesisNativeApp` or a `SessionProvider`. */
+declare function useSession<S = unknown>(): SessionState<S>;
+interface AuthGateProps {
+    signedIn: ReactNode;
+    signedOut: ReactNode;
+    /** While the session is still being read. Default nothing (the splash is up). */
+    loading?: ReactNode;
+}
+/** Render one tree for a signed-in user and another for everyone else. */
+declare function AuthGate({ signedIn, signedOut, loading }: AuthGateProps): react.JSX.Element;
+
+interface LinkHold {
+    /** Hold `path`, replacing any held one. */
+    hold(path: string): void;
+    peek(): string | null;
+    /** Return the held path and forget it. */
+    take(): string | null;
+    clear(): void;
+    subscribe(listener: () => void): () => void;
+}
+/** A place to hold one deep link until sign-in completes; lives outside React. */
+declare function createLinkHold(): LinkHold;
+/** `"pending"` while booting or reading the session. */
+type HeldLinkAuth = "pending" | "signedOut" | "signedIn";
+interface UseHeldLinkOptions {
+    auth: HeldLinkAuth;
+    /** Go there, e.g. `(path) => router.replace(path)`. Called once per link held across a sign-in. */
+    onRelease: (path: string) => void;
+}
+/** Follow the held link after a sign-in, drop it otherwise; returns the link still held. */
+declare function useHeldLink(hold: LinkHold, { auth, onRelease }: UseHeldLinkOptions): string | null;
+
+/**
+ * The devtools overlay's slot on `GenesisNativeApp`. Types only, so the
+ * shell can name it without bundling the overlay.
+ */
+/** What the `devtoolsFeedback` slot is given: the support block's "send feedback" fills it. */
+interface DevtoolsFeedbackProps {
+    /** The overlay's debug report (version signature, user id, blocks, recent activity). */
+    debugInfo: string;
+    /**
+     * Closes the overlay (before a screenshot, say). Resolves once the sheet has finished sliding
+     * away, so a capture after it shows the app, not the closing sheet.
+     */
+    close: () => Promise<void> | void;
+}
+type DevtoolsSlots = {
+    /** A "send feedback" action in the devtools overlay. Default nothing; the support block fills it. */
+    devtoolsFeedback: DevtoolsFeedbackProps;
+};
+
+/** A tiny external store for `useSyncExternalStore`: immutable state, one notify per change. */
+interface Store<T> {
+    getState(): T;
+    setState(next: Partial<T>): void;
+    subscribe(listener: () => void): () => void;
+}
+
+/**
+ * The native modules the updates block reads, as the shapes it needs. Pass
+ * the real ones (`import * as Updates from "expo-updates"`,
+ * `import * as Application from "expo-application"`); tests pass fakes.
+ * Both are optional peers: without `expo-updates` there is no update banner
+ * and no channel switching, and without `expo-application` no force upgrade.
+ */
+/** `expo-updates` (SDK 58): the constants and calls this block uses. */
+interface UpdatesModuleLike {
+    /** False in development, Expo Go, or a build without updates configured. */
+    readonly isEnabled: boolean;
+    /** The running update's id; `null` when updates are off. */
+    readonly updateId: string | null;
+    /** The build's channel; `null` in development builds and Expo Go. */
+    readonly channel: string | null;
+    readonly runtimeVersion: string | null;
+    /** True when the code that shipped in the binary is running, not a downloaded update. */
+    readonly isEmbeddedLaunch: boolean;
+    /** True when expo-updates fell back to the embedded update after a failed launch. */
+    readonly isEmergencyLaunch?: boolean;
+    readonly emergencyLaunchReason?: string | null;
+    checkForUpdateAsync(): Promise<{
+        isAvailable: boolean;
+        isRollBackToEmbedded?: boolean;
+        manifest?: unknown;
+    }>;
+    fetchUpdateAsync(): Promise<{
+        isNew: boolean;
+        isRollBackToEmbedded?: boolean;
+        manifest?: unknown;
+    }>;
+    reloadAsync(options?: {
+        reloadScreenOptions?: object;
+    }): Promise<void>;
+    /** Overrides the `expo-channel-name` header (persists on the device); `null` removes the override. */
+    setUpdateRequestHeadersOverride?(requestHeaders: Record<string, string> | null): void;
+}
+/** `expo-application`: the installed store version and build number. */
+interface ApplicationLike {
+    /** `CFBundleShortVersionString` / `versionName`, e.g. `"1.4.0"`. */
+    readonly nativeApplicationVersion: string | null;
+    /** `CFBundleVersion` / `versionCode`, e.g. `"37"`. */
+    readonly nativeBuildVersion: string | null;
+}
+/** AsyncStorage, MMKV's async adapter, or a stand-in. */
+interface UpdatesStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem?(key: string): Promise<void>;
+}
+/** React Native's `AppState`. */
+interface UpdatesAppStateLike {
+    addEventListener(type: "change", listener: (state: string) => void): {
+        remove(): void;
+    };
+}
+/** Where a reported error came from. */
+type UpdatesErrorSource = "policy" | "check" | "reload" | "storage" | "channel";
+type UpdatesOnError = (error: Error, source: UpdatesErrorSource) => void;
+
+/**
+ * The update banner's engine: ask expo-updates for a newer update, download
+ * it, and reload only when the person taps and nothing is mid-edit.
+ *
+ * - It never reloads on its own. A downloaded update also applies on the next
+ *   cold start, so dismissing the banner loses nothing.
+ * - The reload guard says no while any `useBlockReload(true)` is mounted (a
+ *   form with unsaved changes) or your `canReload()` returns false (or
+ *   throws). The banner then asks the person to finish first.
+ * - expo-updates only serves updates built for this binary's runtime
+ *   version; an update whose manifest names another runtime is ignored too.
+ */
+
+interface ReloadGuard {
+    /** Hold reloads off until the returned function is called. */
+    block(): () => void;
+    /** True when nothing blocks and your `canReload` agrees. */
+    canReload(): boolean;
+    /** Fires when a block starts or ends. */
+    subscribe(listener: () => void): () => void;
+}
+declare function createReloadGuard(canReload?: () => boolean): ReloadGuard;
+type UpdateCheckStatus = "disabled" | "idle" | "checking" | "downloading" | "ready" | "reloading" | "error";
+interface UpdateCheckState {
+    status: UpdateCheckStatus;
+    /** The downloaded update's id, when the manifest has one. */
+    updateId: string | null;
+    /** The person closed the banner; the update still applies on the next cold start. */
+    dismissed: boolean;
+    /** The last tap was refused by the reload guard; cleared when the guard opens. */
+    blocked: boolean;
+    error: Error | null;
+}
+interface UpdateCheckerOptions {
+    updates?: UpdatesModuleLike;
+    guard: ReloadGuard;
+    /** Passed to `reloadAsync` (a branded reload screen). */
+    reloadScreenOptions?: object;
+    now?: () => number;
+    onError?: UpdatesOnError;
+}
+interface UpdateChecker extends Pick<Store<UpdateCheckState>, "getState" | "subscribe"> {
+    /** Check and download. Never rejects; does nothing while one is in flight or an update is ready. */
+    check(): Promise<void>;
+    /** `check()` unless the last one started less than `minIntervalMs` ago. */
+    checkIfDue(minIntervalMs: number): Promise<void>;
+    /** Reload into the downloaded update. Resolves false when there is none or the guard refuses. */
+    reload(): Promise<boolean>;
+    dismiss(): void;
+    /** Stop following the guard. */
+    dispose(): void;
+}
+declare function createUpdateChecker(options: UpdateCheckerOptions): UpdateChecker;
+
+/**
+ * Switching a test build to another update channel (EAS "channel surfing"):
+ * override the `expo-channel-name` header, check, fetch, reload. The
+ * override persists on the device until it is reset or the app is removed.
+ *
+ * Off unless you turn it on, and turn it on only in development and preview
+ * builds (`enabled: __DEV__ || isPreviewBuild`): a store build that can be
+ * pointed at any channel can be pointed at an unreviewed one. Going back
+ * (`reset`) always works, for everyone, because it only removes the
+ * override.
+ *
+ * Switching reloads, so it respects the reload guard: with unsaved changes
+ * it sets the channel and says `blocked`; the channel applies on the next
+ * launch.
+ */
+
+type ChannelSwitchResult = 
+/** The reload was sent; JS may stop at any moment. */
+{
+    kind: "reloading";
+}
+/** The channel is set, but something is mid-edit: it applies on the next launch. */
+ | {
+    kind: "blocked";
+}
+/** expo-updates is off or too old here (development, Expo Go). Nothing changed. */
+ | {
+    kind: "unavailable";
+    reason: string;
+}
+/** The channel is set but checking, fetching or reloading failed. */
+ | {
+    kind: "error";
+    error: Error;
+};
+interface ChannelSwitcher {
+    /** True when this build may switch channels (`channels.enabled`). */
+    readonly enabled: boolean;
+    /** Switch to `channel` and reload. Throws when switching is off. */
+    switchTo(channel: string): Promise<ChannelSwitchResult>;
+    /** Back to the build's own channel. Always allowed. */
+    reset(): Promise<ChannelSwitchResult>;
+    /** The channel picked on this device, or `null` when it follows the build. */
+    requested(): Promise<string | null>;
+}
+interface ChannelSwitcherOptions {
+    updates?: UpdatesModuleLike;
+    /** Must be explicitly true (development and preview builds only). */
+    enabled: boolean;
+    guard: ReloadGuard;
+    /** Remembers the picked channel, for the version signature. */
+    storage?: UpdatesStorageLike;
+    /** Default `"genesis:updates:channel"`. */
+    storageKey?: string;
+    reloadScreenOptions?: object;
+    onError?: UpdatesOnError;
+}
+declare function createChannelSwitcher(options: ChannelSwitcherOptions): ChannelSwitcher;
+
+/**
+ * The release policy: the oldest store version each platform may run, a
+ * maintenance switch, and release notes. It comes from an
+ * `UpdatePolicySource` (a static object, Supabase, or your own), is cached on
+ * the phone, and **fails open**: no answer, a timeout, a malformed value or
+ * an untrusted cache never blocks anyone.
+ *
+ * What may block, and from where:
+ * - Force upgrade: a policy fetched this session, or a cached one no older
+ *   than `cacheMaxAgeMs` (7 days) by the phone's clock. A cache whose time is
+ *   in the future (the clock moved back) is not trusted. A minimum without a
+ *   store link for the platform forces nothing (there would be no way out).
+ * - Maintenance: only a policy fetched from the network this session. A
+ *   cached maintenance flag never blocks a cold start.
+ */
+
+type UpdatePlatform = "ios" | "android";
+interface ReleaseNote {
+    /** The store version these notes describe, e.g. `"1.4.0"`. */
+    version: string;
+    title?: string;
+    body: string;
+}
+interface UpdatePolicy {
+    /** The oldest store version still supported, per platform. Missing or malformed: no minimum. */
+    minimumVersion?: Partial<Record<UpdatePlatform, string>>;
+    /** Where "Update" goes (`https://apps.apple.com/…`, `itms-apps://…`, `market://…`, `https://play.google.com/…`). */
+    storeUrl?: Partial<Record<UpdatePlatform, string>>;
+    maintenance?: {
+        active: boolean;
+        message: string | null;
+    };
+    notes?: readonly ReleaseNote[];
+}
+/** Where the policy comes from. `load` throws (or rejects) when it can't answer; resolving `null` means "no policy". */
+interface UpdatePolicySource {
+    load(): Promise<UpdatePolicy | null | undefined>;
+}
+/** A policy written in the app (or a test). */
+declare function staticPolicySource(policy: UpdatePolicy): UpdatePolicySource;
+/** A Supabase client: anything with `from(table)` (a real `SupabaseClient` fits without a cast). */
+interface PolicyClientLike {
+    from(table: string): unknown;
+}
+interface SupabasePolicySourceOptions {
+    /** The `app_id` row to read. Default `"default"`. */
+    appId?: string;
+    /** Default `"app_release_policy"` (migration `0002_genesis_app_release_policy.sql` in `@marktiderman/genesis-supabase`). */
+    table?: string;
+}
+/**
+ * Reads one row of `public.app_release_policy` (readable by anon and
+ * authenticated, written only with the service role). No row is no policy.
+ */
+declare function supabasePolicySource(client: PolicyClientLike, options?: SupabasePolicySourceOptions): UpdatePolicySource;
+/** Keeps only well-formed fields; throws when `raw` isn't an object at all (so the cache answers instead). */
+declare function sanitizePolicy(raw: unknown): UpdatePolicy;
+type PolicyOrigin = "network" | "cache" | "none";
+interface PolicyState {
+    /** `loading` until the first answer (or the timeout); then `ready`, with or without a policy. */
+    status: "loading" | "ready";
+    policy: UpdatePolicy | null;
+    /** `network`: fetched this session. `cache`: read from the phone. `none`: no answer yet (fail open). */
+    origin: PolicyOrigin;
+    /** When it was fetched, by the phone's clock (ms). */
+    fetchedAt: number | null;
+    /** The last failed fetch, if the most recent one failed. */
+    error: Error | null;
+    /** A fetch is in flight. */
+    refreshing: boolean;
+}
+interface PolicyStoreOptions {
+    source: UpdatePolicySource;
+    storage?: UpdatesStorageLike;
+    /** Default `"genesis:updates:policy"`. */
+    cacheKey?: string;
+    /** The longest `load()` waits before carrying on without an answer. Default 3000 ms. */
+    timeoutMs?: number;
+    now?: () => number;
+    onError?: UpdatesOnError;
+}
+interface PolicyStore extends Pick<Store<PolicyState>, "getState" | "subscribe"> {
+    /** The first load: the cache and the network together, for at most `timeoutMs`. Never rejects; runs once. */
+    load(): Promise<void>;
+    /** Fetch again (maintenance "Try again", the app coming to the front). Never rejects; resolves true on an answer. */
+    refresh(): Promise<boolean>;
+    /** `refresh()` unless one ran less than `minIntervalMs` ago. */
+    refreshIfDue(minIntervalMs: number): Promise<boolean>;
+}
+declare function createPolicyStore(options: PolicyStoreOptions): PolicyStore;
+/** What the policy says this install must do. */
+type UpdateVerdict = {
+    kind: "ok";
+} | {
+    kind: "forceUpgrade";
+    minimumVersion: string;
+    installedVersion: string;
+    storeUrl: string;
+} | {
+    kind: "maintenance";
+    message: string | null;
+};
+interface EvaluatePolicyOptions {
+    /** `Platform.OS`. Only `ios` and `android` can be forced to upgrade. */
+    platform: string;
+    /** The installed store version (`Application.nativeApplicationVersion`). `null`: never forced. */
+    installedVersion: string | null;
+    now: number;
+    /** How old a cached policy may be and still force an upgrade. Default 7 days. */
+    cacheMaxAgeMs?: number;
+}
+/** How far in the future a cache's time may be (clocks drift) before it isn't trusted. */
+declare const CLOCK_SKEW_MS: number;
+declare const WEEK_MS: number;
+/** Force upgrade first (the store is the way out), then maintenance, else ok. Fails open. */
+declare function evaluatePolicy(state: PolicyState, options: EvaluatePolicyOptions): UpdateVerdict;
+
+/**
+ * The version signature: which binary and which update this is, in one
+ * line for Settings "About" and in a few lines for a support report.
+ *
+ *   1.4.0 (37) · preview · 3f2a9c1b
+ *   1.4.0 (37) · production · embedded
+ *   1.4.0 (37) · updates off
+ *
+ * A value the modules can't give is printed as `unknown`, never left out
+ * (an empty string counts as not given: expo-updates gives `""` for the
+ * runtime version in a development build); one that doesn't apply, with
+ * updates off, as `none`.
+ */
+
+interface VersionSignature {
+    version: string | null;
+    build: string | null;
+    platform: string;
+    /** The build's channel (expo-updates). */
+    channel: string | null;
+    /** A channel picked on this device (a test build switched channels); `null` when it follows the build. */
+    requestedChannel: string | null;
+    runtimeVersion: string | null;
+    updateId: string | null;
+    /** `update`: a downloaded update runs. `embedded`: the binary's own code. `off`: updates are off (development, Expo Go). */
+    launch: "update" | "embedded" | "off";
+    /** expo-updates fell back to the embedded code after a failed launch. */
+    emergency: boolean;
+    /** One line, for an About row. */
+    short: string;
+    /** Several lines, for a support report. */
+    text: string;
+}
+interface VersionSignatureInput {
+    application?: ApplicationLike;
+    updates?: UpdatesModuleLike;
+    /** `Platform.OS`. */
+    platform: string;
+    requestedChannel?: string | null;
+}
+declare function versionSignature({ application, updates, platform, requestedChannel }: VersionSignatureInput): VersionSignature;
+
+/**
+ * What's new: release notes shown once per version, remembered in storage.
+ *
+ * - First launch after an install (nothing stored): nothing shows; the
+ *   version is remembered, so a new install never opens on a sheet.
+ * - A newer version than the one remembered: the notes for every version
+ *   after it, up to this one, newest first. Closing them remembers this
+ *   version. With no notes for it, the version is remembered once the policy
+ *   has answered from the network (or there is no policy source), so notes
+ *   that arrive late still show.
+ * - Storage that can't be read shows nothing (rather than every launch).
+ */
+
+interface WhatsNewState {
+    status: "loading" | "hidden" | "showing";
+    notes: readonly ReleaseNote[];
+}
+interface WhatsNewOptions {
+    storage?: UpdatesStorageLike;
+    /** The installed version notes are matched against. `null`: never shows. */
+    version: string | null;
+    /** Default `"genesis:updates:seen-version"`. */
+    storageKey?: string;
+    onError?: UpdatesOnError;
+}
+interface WhatsNewStore extends Pick<Store<WhatsNewState>, "getState" | "subscribe"> {
+    /** Read the remembered version. Never rejects; runs once. */
+    load(): Promise<void>;
+    /** Recompute with the notes known now; `final` once no more notes can arrive. */
+    update(notes: readonly ReleaseNote[], final: boolean): void;
+    /** Close the notes and remember this version. */
+    dismiss(): void;
+}
+/** The notes after `seen`, up to `version`, newest first. */
+declare function notesSince(notes: readonly ReleaseNote[], seen: string, version: string): ReleaseNote[];
+declare function createWhatsNewStore(options: WhatsNewOptions): WhatsNewStore;
+
+interface ForceUpgradeProps {
+    minimumVersion: string;
+    installedVersion: string;
+    /** The policy's store link for this platform (a minimum without one forces nothing). */
+    storeUrl: string;
+    /** Opens `storeUrl`. */
+    openStore: () => void;
+    /** Ask the policy again (it may have been lowered). */
+    retry: () => void;
+    checking: boolean;
+}
+/** Blocking: this version is below the minimum. "Update" opens the store. */
+declare function ForceUpgradeScreen({ minimumVersion, installedVersion, openStore, retry, checking }: ForceUpgradeProps): react.JSX.Element;
+interface MaintenanceProps {
+    /** The policy's message, or `null` for the default copy. */
+    message: string | null;
+    retry: () => void;
+    retrying: boolean;
+}
+/** Blocking: the policy says maintenance is on. "Try again" asks again. */
+declare function MaintenanceScreen({ message, retry, retrying }: MaintenanceProps): react.JSX.Element;
+interface UpdateBannerProps {
+    /** Reload into the downloaded update (refused while `canReload` is false). */
+    reload: () => void;
+    /** Hide the banner; the update still applies on the next cold start. */
+    dismiss: () => void;
+    /** False while something is mid-edit (`useBlockReload`) or your `canReload` says no. */
+    canReload: boolean;
+    /** The last tap was refused because something is mid-edit. */
+    blocked: boolean;
+    reloading: boolean;
+}
+/**
+ * Non-blocking: floats over the top of the screens while an update is
+ * downloaded. Liquid Glass on iOS 26 when the app passed expo-glass-effect
+ * (`modules.glass`); the solid secondary surface otherwise.
+ */
+declare function UpdateBanner({ reload, dismiss, canReload, blocked, reloading }: UpdateBannerProps): react.JSX.Element;
+interface WhatsNewProps {
+    /** Newest first. */
+    notes: readonly ReleaseNote[];
+    /** The installed version. */
+    version: string | null;
+    /** Close and remember this version. */
+    dismiss: () => void;
+}
+/** The release notes for this version, once, in a sheet. */
+declare function WhatsNewSheet({ notes, dismiss }: WhatsNewProps): react.JSX.Element;
+
+type UpdatesSlots = {
+    /** Blocking. Default `ForceUpgradeScreen`. */
+    forceUpgrade: ForceUpgradeProps;
+    /** Blocking. Default `MaintenanceScreen`. */
+    maintenance: MaintenanceProps;
+    /** Over your screens while an update is downloaded. Default `UpdateBanner`. */
+    updateBanner: UpdateBannerProps;
+    /** Once per version. Default `WhatsNewSheet`. */
+    whatsNew: WhatsNewProps;
+};
+interface UpdatesOptions {
+    /** `Platform.OS`. Force upgrade applies to `ios` and `android` only. */
+    platform: string;
+    /** `expo-application`: the installed version. Without it, nothing is ever forced and notes never show. */
+    application?: ApplicationLike;
+    /** `expo-updates`. Without it (or with updates off), no banner and no channel switching. */
+    updates?: UpdatesModuleLike;
+    /** Min versions, maintenance and notes. Without it, only `notes` and the banner. */
+    policy?: UpdatePolicySource;
+    /** AsyncStorage: the policy cache, the version whose notes were seen, the picked channel. */
+    storage?: UpdatesStorageLike;
+    /** `AppState`: ask again when the app comes to the front. */
+    appState?: UpdatesAppStateLike;
+    /** `Linking.openURL`, for the store link. */
+    openURL?: (url: string) => unknown;
+    /** Extra say over reloading (return false to hold it off); `useBlockReload` covers forms. */
+    canReload?: () => boolean;
+    /** Release notes written in the app, merged with the policy's. */
+    notes?: readonly ReleaseNote[];
+    /** `false` turns what's new off. */
+    whatsNew?: boolean;
+    /** Channel switching, for development and preview builds only: `{ enabled: __DEV__ || isPreview }`. */
+    channels?: {
+        enabled: boolean;
+    };
+    /** The longest the first policy load holds the splash. Default 3000 ms. */
+    policyTimeoutMs?: number;
+    /** How old a cached policy may be and still force an upgrade. Default 7 days. */
+    cacheMaxAgeMs?: number;
+    /** Ask for the policy again on coming to the front at most this often. Default 5 minutes. */
+    policyRefreshMs?: number;
+    /** Check for an update on coming to the front at most this often. Default 15 minutes. */
+    checkIntervalMs?: number;
+    /** `reloadAsync`'s reload screen (background color, spinner). */
+    reloadScreenOptions?: object;
+    /**
+     * The Settings row with the version signature the block contributes
+     * (`useBlockSettings`): its title and section, or `false` for none.
+     * Default `{ title: "Version", section: "about" }`.
+     */
+    versionRow?: false | {
+        title?: string;
+        section?: string;
+    };
+    /** Storage key prefix. Default `"genesis:updates"`. */
+    storageKeyPrefix?: string;
+    /** Every caught error, for reporting. None of them blocks anyone. */
+    onError?: UpdatesOnError;
+    now?: () => number;
+}
+/** The FeatureId of the updates block. */
+declare const UPDATES_BLOCK_ID = "app-updates";
+interface UpdatesBlock extends NativeBlock<typeof UPDATES_BLOCK_ID> {
+    readonly options: UpdatesOptions;
+    readonly policy: PolicyStore;
+    readonly checker: UpdateChecker;
+    readonly guard: ReloadGuard;
+    readonly whatsNew: WhatsNewStore;
+    /** Channel switching: `switchTo` throws unless `channels.enabled` was passed; `reset` always works. */
+    readonly channels: ChannelSwitcher;
+    /** The signature from the modules, without the picked channel (see `useVersionSignature`). */
+    readonly signature: VersionSignature;
+    /** Loads the policy and the seen version behind the splash; never fails, done within `policyTimeoutMs`. */
+    readonly bootStep: {
+        id: string;
+        run: () => Promise<void>;
+        timeoutMs: number;
+    };
+    /** `[bootStep]`, for a shell that runs blocks. */
+    readonly bootSteps: readonly {
+        id: string;
+        run: () => Promise<void>;
+        timeoutMs: number;
+    }[];
+    /** Start following the app's state; returns the stop. `UpdatesRoot` calls it. */
+    start(): () => void;
+    /** The block's root, for `GenesisNativeApp`. */
+    readonly Root: ComponentType<Omit<UpdatesRootProps, "block">>;
+}
+/** Build the block once, at module scope, next to your Supabase client. */
+declare function createUpdates(options: UpdatesOptions): UpdatesBlock;
+/** Provides the block to the hooks, without rendering any of its parts (rung 4). */
+declare function UpdatesProvider({ block, children }: {
+    block: UpdatesBlock;
+    children?: ReactNode;
+}): react.JSX.Element;
+/** The block from `UpdatesProvider` / `UpdatesRoot` / `GenesisNativeApp`. Throws outside one. */
+declare function useUpdates(): UpdatesBlock;
+/**
+ * Hold reloads off while `active` (a form with unsaved changes):
+ * `useBlockReload(form.formState.isDirty)`. Does nothing without an updates
+ * block, so a screen can call it whether or not the block is on.
+ */
+declare function useBlockReload(active: boolean): void;
+declare function useUpdatePolicy(): PolicyState;
+/** What the policy says now: `ok`, `forceUpgrade` or `maintenance`. */
+declare function useUpdateVerdict(): UpdateVerdict;
+/** The force-upgrade screen's props, or `null` when this version is supported. */
+declare function useForceUpgrade(): ForceUpgradeProps | null;
+/** The maintenance screen's props, or `null` when maintenance is off (or not known live). */
+declare function useMaintenance(): MaintenanceProps | null;
+declare function useUpdateCheck(): UpdateCheckState;
+/** True when a reload would be allowed now. */
+declare function useCanReload(): boolean;
+/** The banner's props, or `null` when there is nothing to show. */
+declare function useUpdateBanner(): UpdateBannerProps | null;
+/** The notes to show now, or `null`. */
+declare function useWhatsNew(): WhatsNewProps | null;
+/** The version signature, with the channel picked on this device once it has been read. */
+declare function useVersionSignature(): VersionSignature;
+interface UpdatesRootProps {
+    block: UpdatesBlock;
+    slots?: Slots<UpdatesSlots>;
+    slotProps?: SlotPropsFor<UpdatesSlots>;
+    children?: ReactNode;
+}
+/** The block's parts around your screens. */
+declare function UpdatesRoot({ block, slots, slotProps, children }: UpdatesRootProps): react.JSX.Element;
+
+/**
+ * Deep links: turn an incoming universal link or app link into an app path.
+ *
+ * Meant for expo-router's `app/+native-intent.ts`:
+ *
+ *   export function redirectSystemPath({ path }: { path: string }) {
+ *     return normalizeLink(path, links);
+ *   }
+ *
+ * A link to a path the map doesn't know goes to `"/"` (and `onUnknown`), so a
+ * stale or mistyped link opens the app instead of a "not found" screen. It
+ * never throws: anything it can't read is unknown.
+ */
+/** A target path (`"/clients/:id"`, params filled in) or a function of the params. */
+type LinkTarget = string | ((params: Record<string, string>) => string);
+interface LinkOptions {
+    /** App schemes, without `://` (`["myapp"]`). `myapp://clients/1` is the path `/clients/1`. */
+    schemes?: readonly string[];
+    /** Hosts of universal / app links (`["example.com"]`). Other hosts are unknown. */
+    hosts?: readonly string[];
+    /**
+     * Incoming path pattern → app path. A segment `:name` captures one
+     * segment, a final `*` captures the rest (as `params["*"]`). The first
+     * match wins; `"/"` is always known.
+     */
+    map: Readonly<Record<string, LinkTarget>>;
+    /** Patterns to ignore (return `null`, so expo-router doesn't navigate), e.g. an auth callback. */
+    ignore?: readonly string[];
+    /** Told about each link that went to `"/"` because nothing matched. */
+    onUnknown?: (url: string) => void;
+}
+/** The app path for `url`, `"/"` when it is unknown, or `null` when it is ignored. */
+declare function normalizeLink(url: string, options: LinkOptions): string | null;
+
+/**
+ * Where the push block keeps devices and preferences: migration 0005 of
+ * @marktiderman/genesis-supabase, through the app's Supabase client and row
+ * level security. `supabasePushBackend(supabase)` is the one to use; tests
+ * (and an app with its own server) pass their own `PushBackend`.
+ */
+/** A person's notification preferences, as the screens edit them. */
+interface NotificationPreferences {
+    /** Category id → on or off. A category not listed has its default (`NotificationCategory.defaultOn`). */
+    categories: Record<string, boolean>;
+    quietHours: QuietHours;
+    /** Hide what a push says on the lock screen: the sender sends neutral text instead. */
+    hidePreviews: boolean;
+}
+interface QuietHours {
+    enabled: boolean;
+    /** Local time, `"HH:MM"` (24-hour). */
+    start: string;
+    /** Local time, `"HH:MM"`; before `start` means the quiet runs past midnight. */
+    end: string;
+    /** IANA time zone (`"Europe/London"`) the times are read in; required while enabled. */
+    timeZone: string | null;
+}
+declare const DEFAULT_PREFERENCES: NotificationPreferences;
+interface PushBackend {
+    /** Keep this device's token against the signed-in person. */
+    register(token: string, platform: string, appVersion: string | null): Promise<void>;
+    /** Forget this device's token; works signed out (holding the token is the proof). */
+    forget(token: string): Promise<void>;
+    /** The signed-in person's preferences, or `null` before they have saved any. */
+    loadPreferences(userId: string): Promise<NotificationPreferences | null>;
+    savePreferences(userId: string, preferences: NotificationPreferences): Promise<void>;
+}
+type Result = {
+    data: unknown;
+    error: {
+        message?: string;
+        code?: string | null;
+    } | null;
+};
+/** The parts of a Supabase client the backend uses; a `SupabaseClient` fits, typed by your Database or not. */
+interface PushSupabaseLike {
+    rpc: (fn: any, ...rest: any[]) => PromiseLike<Result>;
+    from(table: string): unknown;
+}
+/** A database refusal, with its SQLSTATE; the message is the database's own, never a token. */
+declare class PushBackendError extends Error {
+    readonly operation: string;
+    readonly code: string | null;
+    constructor(operation: string, code: string | null);
+}
+/** Migration 0005's functions and tables, under the signed-in person's row level security. */
+declare function supabasePushBackend(client: PushSupabaseLike): PushBackend;
+
+/**
+ * What the push block reads from `expo-notifications` (SDK 58) and the app's
+ * backend, as the shapes it needs. Pass the real module
+ * (`import * as Notifications from "expo-notifications"`); tests pass fakes.
+ * Every call here was checked against expo-notifications 58.1's own type
+ * declarations.
+ */
+/** `{ remove() }`, as every expo-notifications listener returns. */
+interface SubscriptionLike {
+    remove(): void;
+}
+/** `NotificationPermissionsStatus`: Expo's `PermissionResponse` plus the iOS detail. */
+interface PermissionStatusLike {
+    status: "granted" | "denied" | "undetermined" | string;
+    granted: boolean;
+    canAskAgain: boolean;
+    /** `IosAuthorizationStatus`: 0 not determined, 1 denied, 2 authorized, 3 provisional, 4 ephemeral. */
+    ios?: {
+        status: number;
+    } | null;
+}
+/** `NotificationPermissionsRequest`: iOS options; Android asks for posting notifications. */
+interface PermissionRequestLike {
+    ios?: {
+        allowAlert?: boolean;
+        allowBadge?: boolean;
+        allowSound?: boolean;
+        allowProvisional?: boolean;
+    };
+}
+/** The parts of a received notification the block reads. */
+interface NotificationLike {
+    request: {
+        identifier: string;
+        content: {
+            data?: Record<string, unknown> | null;
+            title?: string | null;
+        };
+    };
+}
+/** A tap (or an action) on a notification. */
+interface NotificationResponseLike {
+    notification: NotificationLike;
+    actionIdentifier: string;
+}
+/** `NotificationBehavior` without the deprecated `shouldShowAlert`. */
+interface NotificationBehaviorLike {
+    shouldShowBanner: boolean;
+    shouldShowList: boolean;
+    shouldPlaySound: boolean;
+    shouldSetBadge: boolean;
+}
+/** `NotificationChannelInput`, the fields the block sets. Importance and visibility are Expo's enum numbers. */
+interface ChannelInputLike {
+    name: string;
+    importance: number;
+    description?: string | null;
+    /** `AndroidNotificationVisibility`: 1 public, 2 private (content hidden on a secure lock screen), 3 secret. */
+    lockscreenVisibility?: number;
+    showBadge?: boolean;
+}
+/** `expo-notifications` (SDK 58). */
+interface NotificationsModuleLike {
+    getPermissionsAsync(): Promise<PermissionStatusLike>;
+    requestPermissionsAsync(request?: PermissionRequestLike): Promise<PermissionStatusLike>;
+    /** Pass the EAS project id: without one there is no Expo push token. */
+    getExpoPushTokenAsync(options: {
+        projectId: string;
+    }): Promise<{
+        data: string;
+    }>;
+    /** Fires when the OS hands the app a new device token; the Expo token is fetched again then. */
+    addPushTokenListener(listener: (token: unknown) => void): SubscriptionLike;
+    /** Android only (a no-op elsewhere). Must run before the permission prompt and the token on Android 13+. */
+    setNotificationChannelAsync(channelId: string, channel: ChannelInputLike): Promise<unknown>;
+    setNotificationHandler(handler: {
+        handleNotification: (notification: NotificationLike) => Promise<NotificationBehaviorLike>;
+    } | null): void;
+    addNotificationResponseReceivedListener(listener: (response: NotificationResponseLike) => void): SubscriptionLike;
+    /** The tap that launched the app (synchronous since SDK 53). */
+    getLastNotificationResponse(): NotificationResponseLike | null;
+    clearLastNotificationResponse(): void;
+    setBadgeCountAsync(count: number): Promise<boolean>;
+    getBadgeCountAsync(): Promise<number>;
+    /** `"expo.modules.notifications.actions.DEFAULT"`: the person tapped the notification itself. */
+    DEFAULT_ACTION_IDENTIFIER: string;
+}
+/** AsyncStorage, MMKV's async adapter, or a stand-in. */
+interface PushStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem?(key: string): Promise<void>;
+}
+/** React Native's `AppState`. */
+interface PushAppStateLike {
+    addEventListener(type: "change", listener: (state: string) => void): {
+        remove(): void;
+    };
+}
+/** Where a reported error came from. */
+type PushErrorSource = "permission" | "register" | "forget" | "preferences" | "badge" | "channels" | "routing" | "storage" | "setup";
+type PushOnError = (error: Error, source: PushErrorSource) => void;
+
+/**
+ * Notification permission, and the soft pre-prompt that comes before the
+ * system's.
+ *
+ * The system prompt can be shown once: a person who says no there has to find
+ * the app in Settings to change it. So the block never asks at launch. The
+ * app calls `prompt.offer()` at the moment push is worth it (they sent their
+ * first message, set a reminder) and the block shows its own sheet first,
+ * saying why; only "Turn on" in that sheet (a tap) brings up the system
+ * prompt. "Not now" waits `cooldownMs` before the sheet can show again, and
+ * after `maxDeclines` it never offers again (Settings still can).
+ */
+
+/**
+ * `unknown` before the first read; `undetermined` the system can still ask;
+ * `granted`; `provisional` (iOS delivers quietly to Notification Center);
+ * `denied` only Settings can change; `unavailable` no notifications module.
+ */
+type PushPermissionStatus = "unknown" | "undetermined" | "granted" | "provisional" | "denied" | "unavailable";
+interface PermissionState {
+    status: PushPermissionStatus;
+    /** The system prompt is up. */
+    requesting: boolean;
+}
+interface PermissionStore extends Store<PermissionState> {
+    /** Read the status without asking (no prompt). */
+    refresh(): Promise<PushPermissionStatus>;
+    /** Show the system prompt (only after a tap); resolves to the new status. */
+    request(): Promise<PushPermissionStatus>;
+}
+/** Expo's answer as one status. Android "denied but can ask again" is still askable. */
+declare function statusOf(response: PermissionStatusLike): PushPermissionStatus;
+declare const canPush: (status: PushPermissionStatus) => status is "granted" | "provisional";
+declare function createPermissionStore(options: {
+    notifications?: NotificationsModuleLike;
+    request?: PermissionRequestLike;
+    /** Runs before the system prompt (Android 13 shows it only once a channel exists). */
+    beforeRequest?: () => Promise<void>;
+    onError?: PushOnError;
+}): PermissionStore;
+interface PromptOptions {
+    /** After "Not now", how long before the sheet may show again. Default 3 days. */
+    cooldownMs?: number;
+    /** After this many "Not now"s it never offers again. Default 3. */
+    maxDeclines?: number;
+    /** `offer()` is ignored this long after the block starts, so no screen can ask at launch. Default 10 s. */
+    launchGraceMs?: number;
+}
+interface PromptState {
+    visible: boolean;
+    /** What `offer(reason)` said push is for here, for the sheet's copy. */
+    reason: string | null;
+}
+interface PromptStore extends Store<PromptState> {
+    /**
+     * Show the soft prompt if it is a good moment: signed in, the system can
+     * still ask, not at launch, not too soon after "Not now". Resolves to
+     * whether it showed.
+     */
+    offer(reason?: string): Promise<boolean>;
+    /** "Turn on": hides the sheet and shows the system prompt. */
+    accept(): Promise<PushPermissionStatus>;
+    /** "Not now": hides the sheet and remembers it. */
+    decline(): Promise<void>;
+    hide(): void;
+}
+declare function createPromptStore(options: PromptOptions & {
+    permission: PermissionStore;
+    storage?: PushStorageLike;
+    storageKey: string;
+    signedIn: () => boolean;
+    /** When the block started (ms), or null before. */
+    startedAt: () => number | null;
+    now: () => number;
+    onError?: PushOnError;
+}): PromptStore;
+
+/**
+ * The signed-in person's notification preferences: categories, quiet hours
+ * and privacy previews. Loaded when they sign in, saved on every change
+ * (shown at once, put back if the save fails), cleared when they sign out.
+ * The server reads the saved row; nothing here decides what is delivered.
+ */
+
+/** Android importance for a category's channel (Expo's `AndroidImportance`). */
+type ChannelImportance = "min" | "low" | "default" | "high" | "max";
+/** One kind of notification the app sends, which a person can turn off. */
+interface NotificationCategory {
+    /** Lower case letters, digits, ".", "_" or "-" (`messages`). Also its Android channel id, and the sender's `category`. */
+    id: string;
+    title: string;
+    description?: string;
+    /** On for someone who never chose. Default true; pass the same `defaultOn` to the sender. */
+    defaultOn?: boolean;
+    /** Android channel importance. Default `"default"`. */
+    importance?: ChannelImportance;
+}
+type PreferencesStatus = "idle" | "loading" | "ready" | "error";
+interface PreferencesState {
+    status: PreferencesStatus;
+    preferences: NotificationPreferences;
+    saving: boolean;
+    /** The last load or save that failed (the change was put back). */
+    error: Error | null;
+}
+interface PreferencesStore extends Store<PreferencesState> {
+    load(userId: string): Promise<void>;
+    /** Apply a change now and save it; on failure it is put back and `error` set. */
+    update(change: (current: NotificationPreferences) => NotificationPreferences): Promise<boolean>;
+    reset(): void;
+    isOn(categoryId: string): boolean;
+}
+/** Checks a change before it is shown or saved, so the server never has to refuse it. */
+declare function validPreferences(p: NotificationPreferences): boolean;
+declare function createPreferencesStore(options: {
+    backend: PushBackend;
+    categories: readonly NotificationCategory[];
+    onError?: PushOnError;
+}): PreferencesStore;
+
+/**
+ * This device's Expo push token, kept against whoever is signed in.
+ *
+ *   sync(userId)   permission granted → (Android) channels → token → backend.register,
+ *                  again when the token changes and at most hourly otherwise (last seen)
+ *   forget()       backend.forget(token) on sign-out, an account switch or deletion;
+ *                  a forget that fails offline is kept and retried at the next start
+ *
+ * The token is remembered on the phone (storage) with the user it was
+ * registered for, so it can be forgotten after the session has ended. Every
+ * step runs in order on one queue, so a sign-out never races a registration.
+ */
+
+type RegistrationStatus = "idle" | "registering" | "registered" | "unavailable" | "error";
+interface RegistrationState {
+    status: RegistrationStatus;
+    /**
+     * Why it isn't registered: `no_project_id` (the build has no EAS project id, so there is no
+     * Expo push token), `no_token` (the OS gave none: a simulator without push, or no network),
+     * `backend` (the server refused or couldn't be reached).
+     */
+    problem: "no_project_id" | "no_token" | "backend" | null;
+}
+interface Registration extends Store<RegistrationState> {
+    sync(userId: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    forget(): Promise<void>;
+    /** Retry forgets that failed earlier (offline sign-out). */
+    flush(): Promise<void>;
+    /** This device's token, once known (the person's own; never shown in logs). */
+    token(): string | null;
+}
+declare function createRegistration(options: {
+    notifications?: NotificationsModuleLike;
+    backend: PushBackend;
+    projectId?: string | null;
+    platform: string;
+    appVersion?: string | null;
+    storage?: PushStorageLike;
+    storageKeyPrefix: string;
+    /** Creates the Android channels; runs before the token is asked for. */
+    ensureChannels: () => Promise<void>;
+    /** Is this user still the one signed in? A sync for someone who has signed out is dropped. */
+    isCurrent: (userId: string) => boolean;
+    now: () => number;
+    onError?: PushOnError;
+}): Registration;
+
+interface PushPromptProps {
+    /** What `offer(reason)` said push is for here ("to hear when someone replies"), or null. */
+    reason: string | null;
+    /** "Turn on": shows the system prompt. */
+    accept: () => void;
+    /** "Not now": asks again after the cooldown, never more than `maxDeclines` times. */
+    decline: () => void;
+    title?: string;
+    body?: string;
+    acceptLabel?: string;
+    declineLabel?: string;
+}
+declare function PushPromptSheet({ reason, accept, decline, title, body, acceptLabel, declineLabel }: PushPromptProps): react.JSX.Element;
+
+/** An Android channel beyond the categories' own (one per category is made for you). */
+interface PushChannel {
+    id: string;
+    name: string;
+    description?: string;
+    importance?: ChannelImportance;
+}
+type PushSlots = {
+    /** The soft pre-prompt, shown after `usePushPrompt().offer()`. Default `PushPromptSheet`. */
+    pushPrompt: PushPromptProps;
+};
+interface PushOptions {
+    /** `import * as Notifications from "expo-notifications"`. Without it the block does nothing (web, tests). */
+    notifications?: NotificationsModuleLike;
+    /** `Platform.OS`. */
+    platform: string;
+    /** The EAS project id (`Constants.expoConfig?.extra?.eas?.projectId`). Without it there is no push token; the block says so once through `onError`. */
+    projectId?: string | null;
+    /** The installed version, kept with the device row (`Application.nativeApplicationVersion`). */
+    appVersion?: string | null;
+    /** Devices and preferences: `supabasePushBackend(supabase)`. */
+    backend: PushBackend;
+    /** The kinds of notification the app sends; each is a toggle in NotificationSettings and an Android channel. */
+    categories?: readonly NotificationCategory[];
+    /** More Android channels. A `default` channel is always made. */
+    channels?: readonly PushChannel[];
+    /** AsyncStorage: this device's token (to forget it after sign-out), the prompt's "Not now"s. */
+    storage?: PushStorageLike;
+    /** `AppState`: read the permission again on coming to the front (the person may have changed it in Settings). */
+    appState?: PushAppStateLike;
+    /** `Linking.openSettings`, for "Turn on in Settings" once the system won't ask again. */
+    openSettings?: () => unknown;
+    /** Where a tap goes: the app's deep-link options, so a pushed path is normalized like any link. */
+    links?: LinkOptions;
+    /** Open a tapped notification's path (`router.push`). Without it a tap opens nothing, and says so through `onError`. */
+    onOpen?: (path: string) => void;
+    /** Where a tap that arrives signed out waits for sign-in: the same `linkHold` as GenesisNativeApp's `links.hold`. */
+    hold?: LinkHold;
+    /**
+     * The Settings row the block contributes (`useBlockSettings`), or `false`
+     * for none. Default `{ title: "Notifications", section: "notifications", href: "/settings/notifications" }`;
+     * its subtitle is the permission's status (`statusLabels`).
+     */
+    settingsRow?: false | {
+        title?: string;
+        section?: string;
+        href?: string;
+    };
+    /** The words for each permission status (the Settings row's subtitle, NotificationSettings' default). */
+    statusLabels?: Partial<Record<PushPermissionStatus, string>>;
+    /** Every tap and action, after routing (an action button, analytics). */
+    onResponse?: (response: NotificationResponseLike) => void;
+    /** Show a notification that arrives while the app is open? Default yes; `useSuppressNotifications` adds rules. */
+    foreground?: (notification: NotificationLike) => boolean;
+    /** The iOS permissions asked for. Default alert, badge and sound. */
+    permissions?: PermissionRequestLike;
+    prompt?: PromptOptions;
+    /** Clear the badge whenever the app comes to the front. Default false (the server sets it). */
+    clearBadgeOnForeground?: boolean;
+    /** Storage key prefix. Default `"genesis:push"`. */
+    storageKeyPrefix?: string;
+    /** Every caught error, for reporting; none of them breaks the app. */
+    onError?: PushOnError;
+    now?: () => number;
+}
+/** The FeatureId of the push block. */
+declare const PUSH_BLOCK_ID = "push";
+interface PushBlock extends NativeBlock<typeof PUSH_BLOCK_ID> {
+    readonly options: PushOptions;
+    readonly permission: PermissionStore;
+    readonly registration: Registration;
+    readonly preferences: PreferencesStore;
+    readonly prompt: PromptStore;
+    readonly categories: readonly NotificationCategory[];
+    readonly badge: {
+        set(count: number): Promise<void>;
+        clear(): Promise<void>;
+    };
+    /** Follow this signed-in user (null when signed out). `PushRoot` calls it from the session. */
+    setUser(userId: string | null): void;
+    /** Hide notifications that match while the app is open (the thread on screen); returns the removal. */
+    suppress(match: (data: Record<string, unknown>, notification: NotificationLike) => boolean): () => void;
+    /** Make the Android channels (once; again after a failure). */
+    ensureChannels(): Promise<void>;
+    /** Start the foreground handler and the listeners; returns the stop. `PushRoot` calls it. */
+    start(): () => void;
+    /** Reads the permission behind the splash, at most a second; never fails the boot. */
+    readonly bootSteps: readonly BootStep[];
+    readonly Root: ComponentType<NativeBlockRootProps>;
+}
+/** Build the block once, at module scope, next to your Supabase client. */
+declare function createPush(options: PushOptions): PushBlock;
+/** Provides the block to the hooks, without rendering any of its parts (rung 4). */
+declare function PushProvider({ block, children }: {
+    block: PushBlock;
+    children?: ReactNode;
+}): react.JSX.Element;
+/** The block from `PushProvider` / `PushRoot` / `GenesisNativeApp`. Throws outside one. */
+declare function usePush(): PushBlock;
+/** The block, or null when push is off: for a screen that works either way. */
+declare function useOptionalPush(): PushBlock | null;
+declare function usePushPermissionState(): PermissionState;
+declare function usePushRegistration(): RegistrationState;
+declare function useNotificationPreferences(): PreferencesState & {
+    update: PreferencesStore["update"];
+};
+/** The soft prompt: `offer("to hear when someone replies")` at the right moment. */
+declare function usePushPrompt(): PromptState & Pick<PromptStore, "offer" | "accept" | "decline">;
+/** The badge: `set(unread)`, `clear()`. */
+declare function useBadge(): PushBlock["badge"];
+/**
+ * Hide notifications that match while this screen is open (`data` is the
+ * notification's `data`): a chat screen hides pushes for its own thread.
+ * Does nothing without a push block.
+ */
+declare function useSuppressNotifications(match: ((data: Record<string, unknown>) => boolean) | null): void;
+interface PushRootProps {
+    block: PushBlock;
+    /** Where a tap that arrives signed out waits for sign-in (GenesisNativeApp passes its `links.hold`). */
+    hold?: LinkHold;
+    /** Open a path; used when the block's own `onOpen` isn't given. */
+    onOpen?: (path: string) => void;
+    slots?: Slots<PushSlots>;
+    slotProps?: SlotPropsFor<PushSlots>;
+    children?: ReactNode;
+}
+/** The block's parts around your screens. Must be inside GenesisNativeApp's session (or a `SessionProvider`). */
+declare function PushRoot({ block, hold, onOpen, slots, slotProps, children }: PushRootProps): react.JSX.Element;
+
+/** `expo-splash-screen`, or a stand-in. Call `preventAutoHideAsync()` at module scope yourself too. */
+interface SplashModule {
+    preventAutoHideAsync?: () => Promise<unknown>;
+    hideAsync: () => Promise<unknown>;
+}
+interface BootScreenProps {
+    status: BootStatus;
+}
+interface SignedOutProps {
+    /** Your screens. The default renders them, for an expo-router layout that redirects. */
+    children: ReactNode;
+}
+type NativeAppSlots = UpdatesSlots & PushSlots & DevtoolsSlots & {
+    /** Shown while booting: under the splash at launch, on its own after "Try again". Default `BootScreen`. */
+    boot: BootScreenProps;
+    /** A failed boot, a fatal global error or a render error. Default `FatalScreen`. */
+    fatal: FatalScreenProps;
+    /** The boundary around your screens. Default `GenesisErrorBoundary`. */
+    errorBoundary: GenesisErrorBoundaryProps;
+    /** What a signed-out user sees. Default your screens (gate them with `useSession`). */
+    signedOut: SignedOutProps;
+};
+interface NativeQueryClientOptions {
+    /** Your own client. Default `createNativeQueryClient(config)`. */
+    client?: QueryClient;
+    config?: QueryClientConfig;
+}
+interface GenesisNativeAppProps {
+    brand: CanonicalBrand;
+    /** A Supabase client (from `createGenesisSupabase` in `@marktiderman/genesis-supabase`). */
+    supabase: AuthClientLike & SupabaseClientInput;
+    /** The data provider. Default `createSupabaseProvider(supabase)`. */
+    provider?: DataProvider;
+    queryClient?: NativeQueryClientOptions;
+    /**
+     * Save queries to the phone: `persistQueries({ storage, keys, buster })`
+     * from `@marktiderman/genesis-native/persist`. The saved cache belongs to
+     * one user: it is restored only for that user and cleared when the user
+     * changes (sign-out, a session that ended while the app was closed, an
+     * account switch).
+     */
+    persist?: (client: QueryClient) => QueryPersistence;
+    /** `expo-splash-screen`: hidden once boot has finished and the session is known. */
+    splash?: SplashModule;
+    /**
+     * `KeyboardProvider` from react-native-keyboard-controller, mounted once
+     * around the app. Its keyboard views (`keyboardScroll` included) do nothing
+     * without it: give both or neither. Read once: it wraps the whole app, so
+     * a different component later would remount everything below it. To pass
+     * it props, define the wrapper at module scope, not inline.
+     */
+    keyboardProvider?: ComponentType<{
+        children: ReactNode;
+    }>;
+    /** `KeyboardAwareScrollView` from react-native-keyboard-controller, for form screens. Needs `keyboardProvider`. */
+    keyboardScroll?: ComponentType<KeyboardScrollProps>;
+    /**
+     * `KeyboardToolbar` from react-native-keyboard-controller: previous / next /
+     * done above the keyboard on Genesis's form layouts. Needs `keyboardScroll`
+     * (and so `keyboardProvider`); without them it is ignored.
+     */
+    keyboardToolbar?: ComponentType<KeyboardToolbarProps>;
+    /**
+     * The optional native modules the app installed, for Genesis components to
+     * use (`GenesisModulesProvider` from `@marktiderman/genesis-ui-native`):
+     * FlashList, expo-image, Reanimated, expo-glass-effect, expo-symbols, a
+     * lucide icon set, the @expo/ui date picker. Each one left out falls back
+     * to plain React Native. Read once.
+     */
+    modules?: GenesisModules;
+    /**
+     * `@gorhom/bottom-sheet` v5, to opt every `NativeSheet` into it (snap
+     * points, drag between heights): `import * as BottomSheet from "@gorhom/bottom-sheet"`,
+     * then `bottomSheet={BottomSheet}`. The app mounts `NativeSheetProvider`
+     * (and so the library's `BottomSheetModalProvider`) for you; the app's root
+     * must still be inside gesture-handler's `GestureHandlerRootView`, with
+     * Reanimated set up. Leave it out and sheets are React Native's own modal
+     * (an iOS page sheet), which needs neither. Read once.
+     */
+    bottomSheet?: NativeSheetLibrary;
+    /**
+     * Toasts (`useToast()` from `@marktiderman/genesis-ui-native`): `NativeToastProvider` is
+     * mounted around the screens, at the top of the screen by default (a bottom toast would sit on
+     * a tab bar). Pass its options to place it, or `null` to mount your own. Read once.
+     */
+    toast?: Pick<NativeToastProviderProps, "position" | "disableAnimation"> | null;
+    /** Follow a link held while signed out, once the user signs in. */
+    links?: {
+        hold: LinkHold;
+        onRelease: (path: string) => void;
+    };
+    /** Run before first render, in order (wipe-on-reinstall, hydrate stores, fonts). Read once. */
+    steps?: readonly BootStep[];
+    bootOptions?: BootOptions;
+    /** Longest wait for Supabase's `getSession()` before using the stored session (offline). Default 5000 ms. */
+    sessionWaitMs?: number;
+    /** Default `globalThis.ErrorUtils`. */
+    errorUtils?: ErrorUtilsLike;
+    /** Report unhandled promise rejections to `onError`. Default Hermes's tracker; `null` turns it off. */
+    rejectionTracker?: EnableRejectionTracker | null;
+    /** `AppState` and NetInfo, so queries refetch on focus and know the network. */
+    lifecycle?: QueryLifecycleOptions;
+    /**
+     * Every caught error, after the blocks' own `onError` (the observability
+     * block, `createObservability` from `/observability`, reports to Sentry
+     * there). A throwing reporter is ignored.
+     */
+    onError?: OnError;
+    /** After a signed-in user signs out, once the query cache is cleared. */
+    onSignedOut?: () => void;
+    /**
+     * The updates block: `createUpdates(…)` from `@marktiderman/genesis-native/updates`
+     * (force upgrade, maintenance, the update banner, what's new). Its policy
+     * loads behind the splash for at most `policyTimeoutMs` and never fails the
+     * boot. Read once; leave it out to turn the block off.
+     */
+    updates?: UpdatesBlock;
+    /**
+     * Blocks to run (`createUpdates(…)` is one). Resolved once at start: a
+     * block whose requirement is missing, or two blocks contributing the same
+     * slot, nav entry or Settings row, shows the fatal screen and reports a
+     * `BlockError` to `onError`. Read once.
+     */
+    blocks?: readonly NativeBlock[];
+    /**
+     * Your features (FeatureIds) that blocks may require but that aren't
+     * blocks. A block requiring anything that is neither one of `blocks` nor
+     * listed here is a `BlockError`. Read once.
+     */
+    appFeatures?: readonly string[];
+    slots?: Slots<NativeAppSlots>;
+    slotProps?: SlotPropsFor<NativeAppSlots>;
+    children?: ReactNode;
+}
+/** The default boot slot: a plain loading view (the splash covers it at launch). */
+declare function BootScreen(_props: BootScreenProps): react.JSX.Element;
+/**
+ * The root of an Expo app: theme, keyboard, data, boot behind the splash, errors, session and held links.
+ *
+ * @stability Beta
+ */
+declare function GenesisNativeApp(props: GenesisNativeAppProps): react.JSX.Element;
+
+/** What a block's `Root` is given: the app's slots, with every block's fills merged under them. @stability Beta */
+interface NativeBlockRootProps {
+    slots?: Slots<NativeAppSlots>;
+    slotProps?: SlotPropsFor<NativeAppSlots>;
+    children?: ReactNode;
+}
+/**
+ * A block a native shell can run. `contributes.slots` fills `GenesisNativeApp`
+ * slots by name (the app's own `slots` win).
+ *
+ * @stability Beta
+ */
+interface NativeBlock<Id extends string = string> extends BlockDef<Id, ComponentType<never>> {
+    /** Run behind the splash after the app's own `steps`, before the session. A step that fails fails the boot, so keep them bounded. */
+    readonly bootSteps?: readonly BootStep[];
+    /** Mounted around the screens, inside the shell's error boundary. The first block's root is the outermost. */
+    readonly Root?: ComponentType<NativeBlockRootProps>;
+    /**
+     * Every error the shell catches (render, global, boot, rejection), before
+     * the app's own `onError`. The observability block reports them here. A
+     * throw is ignored.
+     */
+    readonly onError?: (error: Error, report: ErrorReport) => void;
+}
+/**
+ * The resolved blocks: their ids, nav entries, Settings rows, routes and the
+ * rest, each tagged with its FeatureId. Throws outside `GenesisNativeApp`.
+ *
+ * @stability Beta
+ */
+declare function useBlocks(): ResolvedBlocks<NativeBlock>;
+/** A Settings section as `SettingsPage` from `@marktiderman/genesis-ui-native` takes it. @stability Beta */
+interface BlockSettingsSection<R extends {
+    id: string;
+    title: string;
+} = SettingsRowLike> {
+    id: string;
+    title?: string;
+    footnote?: string;
+    rows: R[];
+}
+/** The row fields a block can fill. @stability Beta */
+interface SettingsRowLike {
+    id: string;
+    title: string;
+    subtitle?: string;
+    showChevron?: boolean;
+    onPress?: () => void;
+    testID?: string;
+}
+/** @stability Beta */
+interface UseBlockSettingsOptions {
+    /** Open a row's `href` (expo-router's `router.push`). Without it, rows with an `href` aren't pressable. */
+    navigate?: (href: string) => void;
+    /** Titles for sections a block names that `sections` doesn't have. Default the section id. */
+    sectionTitles?: Readonly<Record<string, string>>;
+}
+/**
+ * The app's Settings sections with every block's rows added: each row goes
+ * at the end of the section its `section` names (by `order`, then block
+ * order), and a section no one has yet is added after the rest.
+ *
+ * Calls each row's `useSubtitle` hook, so call it unconditionally at the top
+ * of the Settings screen. The blocks are fixed for the life of the app, so
+ * the hooks run in the same order on every render.
+ *
+ * @stability Beta
+ */
+declare function useBlockSettings<R extends SettingsRowLike>(sections: readonly BlockSettingsSection<R>[], options?: UseBlockSettingsOptions): BlockSettingsSection<R | SettingsRowLike>[];
+/** The merge `useBlockSettings` does, without hooks (subtitles already read). @stability Beta */
+declare function mergeBlockSettings<R extends SettingsRowLike>(sections: readonly BlockSettingsSection<R>[], rows: readonly Contributed<BlockSettingsRow>[], subtitles?: readonly (string | null | undefined)[], options?: UseBlockSettingsOptions): BlockSettingsSection<R | SettingsRowLike>[];
+
+export { defaultRejectionTracker as $, type AuthClientLike as A, type BlockSettingsSection as B, type SessionStatus as C, type DevtoolsFeedbackProps as D, type EnableRejectionTracker as E, FatalScreen as F, GenesisErrorBoundary as G, type HeldLinkAuth as H, type SessionStore as I, type SessionStoreOptions as J, type SettingsRowLike as K, type LinkHold as L, type SignedOutProps as M, type NativeBlock as N, type OnError as O, PlainFatalScreen as P, type SplashModule as Q, type UseBlockSettingsOptions as R, SessionProvider as S, type UseBootReturn as T, type UpdatesBlock as U, type VersionSignature as V, type UseHeldLinkOptions as W, createBoot as X, createLinkHold as Y, createSessionStore as Z, defaultErrorUtils as _, type DevtoolsSlots as a, usePushPrompt as a$, installGlobalErrorHandler as a0, installRejectionTracker as a1, mergeBlockSettings as a2, normalizeLink as a3, useBlockSettings as a4, useBlocks as a5, useBoot as a6, useHeldLink as a7, useSession as a8, type PushPermissionStatus as a9, type PushOnError as aA, type PushOptions as aB, type PushPromptProps as aC, PushPromptSheet as aD, PushProvider as aE, PushRoot as aF, type PushRootProps as aG, type PushSlots as aH, type PushStorageLike as aI, type PushSupabaseLike as aJ, type Registration as aK, type RegistrationState as aL, type RegistrationStatus as aM, type SubscriptionLike as aN, canPush as aO, createPermissionStore as aP, createPreferencesStore as aQ, createPromptStore as aR, createPush as aS, createRegistration as aT, statusOf as aU, supabasePushBackend as aV, useBadge as aW, useNotificationPreferences as aX, useOptionalPush as aY, usePush as aZ, usePushPermissionState as a_, type NotificationLike as aa, type NotificationResponseLike as ab, type QuietHours as ac, type ChannelImportance as ad, type ChannelInputLike as ae, DEFAULT_PREFERENCES as af, type NotificationBehaviorLike as ag, type NotificationCategory as ah, type NotificationPreferences as ai, type NotificationsModuleLike as aj, type PermissionRequestLike as ak, type PermissionState as al, type PermissionStatusLike as am, type PermissionStore as an, type PreferencesState as ao, type PreferencesStatus as ap, type PreferencesStore as aq, type PromptOptions as ar, type PromptState as as, type PromptStore as at, type PushAppStateLike as au, type PushBackend as av, PushBackendError as aw, type PushBlock as ax, type PushChannel as ay, type PushErrorSource as az, AuthGate as b, useMaintenance as b$, usePushRegistration as b0, useSuppressNotifications as b1, validPreferences as b2, type ApplicationLike as b3, CLOCK_SKEW_MS as b4, type ChannelSwitchResult as b5, type ChannelSwitcher as b6, type ChannelSwitcherOptions as b7, type EvaluatePolicyOptions as b8, type ForceUpgradeProps as b9, type UpdatesOptions as bA, UpdatesProvider as bB, UpdatesRoot as bC, type UpdatesRootProps as bD, type UpdatesSlots as bE, type UpdatesStorageLike as bF, type VersionSignatureInput as bG, WEEK_MS as bH, type WhatsNewOptions as bI, type WhatsNewProps as bJ, WhatsNewSheet as bK, type WhatsNewState as bL, type WhatsNewStore as bM, createChannelSwitcher as bN, createPolicyStore as bO, createReloadGuard as bP, createUpdateChecker as bQ, createUpdates as bR, createWhatsNewStore as bS, evaluatePolicy as bT, notesSince as bU, sanitizePolicy as bV, staticPolicySource as bW, supabasePolicySource as bX, useBlockReload as bY, useCanReload as bZ, useForceUpgrade as b_, ForceUpgradeScreen as ba, type MaintenanceProps as bb, MaintenanceScreen as bc, type PolicyClientLike as bd, type PolicyOrigin as be, type PolicyState as bf, type PolicyStore as bg, type PolicyStoreOptions as bh, type ReleaseNote as bi, type ReloadGuard as bj, type SupabasePolicySourceOptions as bk, UPDATES_BLOCK_ID as bl, UpdateBanner as bm, type UpdateBannerProps as bn, type UpdateCheckState as bo, type UpdateCheckStatus as bp, type UpdateChecker as bq, type UpdateCheckerOptions as br, type UpdatePlatform as bs, type UpdatePolicy as bt, type UpdatePolicySource as bu, type UpdateVerdict as bv, type UpdatesAppStateLike as bw, type UpdatesErrorSource as bx, type UpdatesModuleLike as by, type UpdatesOnError as bz, type AuthGateProps as c, useUpdateBanner as c0, useUpdateCheck as c1, useUpdatePolicy as c2, useUpdateVerdict as c3, useUpdates as c4, useVersionSignature as c5, useWhatsNew as c6, versionSignature as c7, type BootController as d, type BootOptions as e, BootProvider as f, BootScreen as g, type BootScreenProps as h, type BootState as i, type BootStatus as j, type BootStep as k, type BootStepContext as l, BootTimeoutError as m, type ErrorReport as n, type ErrorUtilsLike as o, type FatalScreenProps as p, type GenesisErrorBoundaryProps as q, GenesisNativeApp as r, type GenesisNativeAppProps as s, type GlobalErrorHandlerOptions as t, type LinkOptions as u, type LinkTarget as v, type NativeAppSlots as w, type NativeBlockRootProps as x, type NativeQueryClientOptions as y, type SessionState as z };