import { AnimationEventHandler } from 'react';
import { AriaRole } from 'react';
import { BrowserRouter } from 'react-router';
import { ButtonHTMLAttributes } from 'react';
import { ChangeEventHandler } from 'react';
import { ClipboardEventHandler } from 'react';
import { Component } from 'react';
import { ComponentType } from 'react';
import { CompositionEventHandler } from 'react';
import { Control } from 'react-hook-form';
import { Controller } from 'react-hook-form';
import { ControllerRenderProps } from 'react-hook-form';
import { CSSProperties } from 'react';
import { default as default_2 } from 'dexie';
import { DefaultOptions } from '@tanstack/react-query';
import { DOMElement } from 'react';
import { DragEventHandler } from 'react';
import { ErrorInfo } from 'react';
import { FieldArrayWithId } from 'react-hook-form';
import { FieldError } from 'react-hook-form';
import { FieldErrors } from 'react-hook-form';
import { FieldPath } from 'react-hook-form';
import { FieldValues } from 'react-hook-form';
import { FocusEventHandler } from 'react';
import { FormHTMLAttributes } from 'react';
import { FormProvider } from 'react-hook-form';
import { ForwardRefExoticComponent } from 'react';
import { HashRouter } from 'react-router';
import { HTMLAttributes } from 'react';
import { ImgHTMLAttributes } from 'react';
import { InfiniteData } from '@tanstack/react-query';
import { InputEventHandler } from 'react';
import { InputHTMLAttributes } from 'react';
import { JSX } from 'react';
import { KeyboardEvent as KeyboardEvent_2 } from 'react';
import { KeyboardEventHandler } from 'react';
import { LabelHTMLAttributes } from 'react';
import { lazy } from 'react';
import { Link } from 'react-router';
import { MemoryRouter } from 'react-router';
import { MouseEvent as MouseEvent_2 } from 'react';
import { MouseEventHandler } from 'react';
import { Navigate } from 'react-router';
import { NavigateOptions } from 'react-router';
import { NavLink } from 'react-router';
import { Outlet } from 'react-router';
import { Params } from 'react-router';
import { Path } from 'react-hook-form';
import { PersistOptions } from 'zustand/middleware';
import { PointerEvent as PointerEvent_2 } from 'react';
import { PointerEventHandler } from 'react';
import { QueryClient } from '@tanstack/react-query';
import { QueryKey } from '@tanstack/react-query';
import { ReactElement } from 'react';
import { ReactEventHandler } from 'react';
import { ReactNode } from 'react';
import { ReactPortal } from 'react';
import { redirect } from 'react-router';
import { Ref } from 'react';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import { Resolver } from 'react-hook-form';
import { Route } from 'react-router';
import { Routes } from 'react-router';
import { SelectHTMLAttributes } from 'react';
import { StateCreator } from 'zustand';
import { StoreApi } from 'zustand';
import { SubmitEventHandler } from 'react';
import { SubmitHandler } from 'react-hook-form';
import { Table as Table_2 } from 'dexie';
import { TextareaHTMLAttributes } from 'react';
import { To } from 'react-router';
import { ToggleEventHandler } from 'react';
import { TouchEvent as TouchEvent_2 } from 'react';
import { TouchEventHandler } from 'react';
import { TransitionEventHandler } from 'react';
import { UIEventHandler } from 'react';
import { UseBoundStore } from 'zustand';
import { useFieldArray } from 'react-hook-form';
import { UseFieldArrayReturn } from 'react-hook-form';
import { useForm } from 'react-hook-form';
import { useFormContext } from 'react-hook-form';
import { UseFormProps } from 'react-hook-form';
import { UseFormRegister } from 'react-hook-form';
import { UseFormReturn } from 'react-hook-form';
import { useFormState } from 'react-hook-form';
import { UseInfiniteQueryOptions } from '@tanstack/react-query';
import { useLocation } from 'react-router';
import { useMatch } from 'react-router';
import { UseMutationOptions } from '@tanstack/react-query';
import { UseMutationResult } from '@tanstack/react-query';
import { useNavigate } from 'react-router';
import { useParams } from 'react-router';
import { UseQueryOptions } from '@tanstack/react-query';
import { UseQueryResult } from '@tanstack/react-query';
import { useRouteError } from 'react-router';
import { useSearchParams } from 'react-router';
import { useWatch } from 'react-hook-form';
import { WheelEventHandler } from 'react';
import { z } from 'zod';

/**
 * What every formatter prints when it has nothing to print.
 *
 * An em dash rather than an empty string, because in a table those are two
 * different claims: a blank cell reads as "this column does not apply here",
 * while `—` reads as "this value is missing". `formatDurationMs` in `/perf` has
 * answered this way since it shipped, and `formatPercent` joined it in 0.65.0;
 * this constant is what stops the third answer from appearing.
 */
export declare const ABSENT_TEXT = "\u2014";

/**
 * A pluggable access-control strategy. Implementations decide whether a given
 * action is allowed, returning a plain boolean, a {@link CanResult}, or a
 * promise of either (for async sources such as a remote policy server).
 */
export declare interface AccessControl {
    /**
     * Resolve whether the described action is permitted.
     *
     * @param params - The action/resource being checked.
     * @returns `true`/`false`, a {@link CanResult}, or a promise of either.
     */
    can: (params: CanParams) => boolean | CanResult | Promise<boolean | CanResult>;
}

/**
 * Provide an {@link AccessControl} strategy to the React tree. Components such
 * as `<Can>` and the `useCan` hook read it from context.
 *
 * @example
 * ```tsx
 * <AccessControlProvider control={createRoleAccessControl({ role: "admin", roles: { admin: ["*"] } })}>
 *   <App />
 * </AccessControlProvider>
 * ```
 */
export declare function AccessControlProvider({ control, children }: AccessControlProviderProps): JSX.Element;

export declare interface AccessControlProviderProps {
    /** The access-control strategy made available to descendants. */
    control: AccessControl;
    children: ReactNode;
}

/**
 * Accessible accordion. Each item collapses/expands its content. Single-mode by
 * default — pass `multiple` to allow more than one item open at a time. Can be
 * controlled via `value` + `onChange`, or uncontrolled via `defaultValue`.
 */
export declare function Accordion({ items, multiple, value, defaultValue, onChange, className, }: AccordionProps): JSX.Element;

export declare interface AccordionItem {
    /** Stable identifier. */
    id: string;
    title: ReactNode;
    children: ReactNode;
    disabled?: boolean;
}

export declare interface AccordionProps {
    items: AccordionItem[];
    /** When `true` multiple items can be open simultaneously. Default `false`. */
    multiple?: boolean;
    /** Controlled open ids. */
    value?: string[];
    /** Uncontrolled default open ids. */
    defaultValue?: string[];
    onChange?: (openIds: string[]) => void;
    className?: string;
}

/**
 * A conversation with a model: role-based turns, Markdown answers, a reasoning
 * block, a streaming caret, per-turn actions and a composer that turns into a stop
 * button while a turn is generating.
 *
 * This is the shape ChatGPT, Claude and DeepSeek converged on, and it is a different
 * component from {@link Chat}, not a variant of it. A human thread is addressed by
 * author and cares about delivery state; a model transcript is addressed by role,
 * has no delivery state at all, and needs three things a human thread never does —
 * partial output, reasoning separate from the answer, and re-asking.
 *
 * Presentational and controlled, like the rest of the SDK: it takes a list and emits
 * intent (`onSend`, `onStop`, `onRegenerate`, `onEditSubmit`, `onFeedback`). The
 * transport stays with the app, because "how do I stream from my backend" has a
 * different answer per provider — the SDK's `createEventStream` covers SSE, `fetch`
 * with a `ReadableStream` covers the rest, and either way the app owns the
 * `AbortController` it hands to `onStop`.
 *
 * @example
 * <AIChat
 *     messages={turns}
 *     pending={pending}
 *     onSend={(text) => ask(text)}
 *     onStop={() => controller.current?.abort()}
 *     onRegenerate={(turn) => reask(turn)}
 *     onFeedback={(turn, vote) => track("answer_rated", { id: turn.id, vote })}
 *     suggestions={["Resuma o último relatório", "Quais pedidos atrasaram?"]}
 * />
 */
export declare function AIChat({ messages, onSend, onStop, onRegenerate, onEditSubmit, onFeedback, onRetry, pending, suggestions, renderAvatar, renderContent, votes, header, emptyState, showSystem, defaultReasoningOpen, showLineNumbers, locale, placeholder, composerActions, composerRef, composerFooter, composerDisabled, maxRows, onSendError, className, ...rest }: AIChatProps): JSX.Element;

/** A file carried by a turn — an upload on the way in, a document on the way out. */
export declare interface AIChatAttachment {
    /** Stable identity. Used as the React key. */
    id: string;
    /** Name shown in the chip. */
    name: string;
    /** Size in bytes. Formatted for display when given. */
    size?: number;
    /** Image URL. When set the attachment renders as a thumbnail instead of a chip. */
    url?: string;
    /** MIME type. Used as the chip's secondary label when there is no size. */
    mimeType?: string;
}

/**
 * The prompt field of a conversation with a model: a textarea that grows with its
 * content, sends on `Enter`, keeps `Shift+Enter` for a newline, and turns into a
 * stop button while a turn is streaming.
 *
 * Uncontrolled on purpose. A draft changes on every keystroke, and lifting that into
 * app state re-renders the whole transcript per character — with a streaming answer
 * above, that is the one place where "controlled by default" costs something
 * visible. Apps that need the draft (a persisted composer, a slash-command menu)
 * read it from `onChange` or drive it through the ref.
 *
 * @example
 * <AIChatComposer
 *     generating={generating}
 *     onSend={(text) => ask(text)}
 *     onStop={() => controller.abort()}
 *     footer={<small>Claude Opus 5 · pode errar</small>}
 * />
 */
export declare const AIChatComposer: ForwardRefExoticComponent<AIChatComposerProps & RefAttributes<AIChatComposerHandle>>;

/** Imperative handle, so a thread can focus, read or refill the field. */
export declare interface AIChatComposerHandle {
    focus: () => void;
    /** Replace the draft — used to put a prompt back in the field. */
    setValue: (text: string) => void;
    /**
     * The current draft.
     *
     * The counterpart `setValue` needs to be usable for anything **additive**. The
     * field is uncontrolled, so without this the only way to append to a draft — a
     * dictated phrase, a picked slash-command, a pasted citation — is to shadow the
     * whole value in app state through `onChange` and hope the two never drift.
     */
    getValue: () => string;
}

export declare interface AIChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_9> {
    /** Called with the trimmed prompt. The field clears only when this does not throw. */
    onSend: (text: string) => void | Promise<void>;
    /**
     * Abort the turn in flight.
     *
     * When given together with `generating`, the send button becomes a stop button
     * and `Escape` aborts too.
     */
    onStop?: () => void;
    /** A turn is being generated. Replaces send with stop and refuses to send. */
    generating?: boolean;
    /** Locale for the placeholder and the button labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Left of the send button — an attach control, a model picker, a tool toggle. */
    actions?: ReactNode;
    /** Under the field — a token count, the model name, a disclaimer. */
    footer?: ReactNode;
    /** Largest height the field grows to, in lines. Default 8. */
    maxRows?: number;
    /**
     * Called when `onSend` rejects. The draft is kept either way.
     *
     * Without it the rejection is swallowed after the draft is preserved: re-throwing
     * out of a DOM event handler surfaces as an unhandled promise rejection, which is
     * console noise for the developer and nothing the user can act on. The visible
     * signal is the prompt still sitting in the field; wire this to a toast to say why.
     */
    onError?: (error: unknown) => void;
}

/** One turn of a conversation with a model. */
export declare interface AIChatMessage {
    /** Stable identity. Used as the React key and by every callback. */
    id: string;
    role: AIChatRole;
    /**
     * The text of the turn.
     *
     * An assistant turn is rendered as Markdown; a user turn is rendered as plain
     * text with newlines preserved. That asymmetry is deliberate: a model emits
     * Markdown by contract, while a person typing `2 * 3 * 4` did not mean to open
     * an emphasis span.
     */
    content: string;
    /**
     * Reasoning the model exposed before answering — extended thinking, a
     * chain-of-thought trace.
     *
     * Rendered in its own collapsible block above the answer, so a long trace never
     * pushes the answer off screen.
     */
    reasoning?: string;
    /**
     * The turn is still arriving.
     *
     * Shows the caret, marks the block `aria-busy`, and hides the action row —
     * copying or rating half an answer is never what somebody meant to do.
     */
    streaming?: boolean;
    /** Generation failed. Shown under whatever streamed, with the retry control. */
    error?: string;
    /** Epoch milliseconds. */
    createdAt?: number;
    /** Model that produced the turn. Shown in the meta row of an assistant turn. */
    model?: string;
    attachments?: readonly AIChatAttachment[];
    /** Anything the app wants to carry through to its own renderers. */
    data?: Record<string, unknown>;
}

export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_8> {
    /** The transcript, **oldest first**. Never reordered by the component. */
    messages: readonly AIChatMessage[];
    /** Renders the composer when given. Receives the trimmed prompt. */
    onSend?: (text: string) => void | Promise<void>;
    /** Abort the turn in flight. Shows the stop button while generating. */
    onStop?: () => void;
    /** Ask again for the newest assistant turn. */
    onRegenerate?: (message: AIChatMessage) => void;
    /** Re-submit an edited user turn. The app decides what to drop after it. */
    onEditSubmit?: (message: AIChatMessage, text: string) => void | Promise<void>;
    /** Rating on an assistant turn. */
    onFeedback?: (message: AIChatMessage, vote: AIChatVote) => void;
    /** Retry a turn that carries an `error`. */
    onRetry?: (message: AIChatMessage) => void;
    /**
     * The request is out and nothing has arrived yet.
     *
     * Distinct from a turn with `streaming: true`: apps that only push a message
     * once the first token lands need somewhere to say "we asked", and without it the
     * screen is frozen for however long the model takes to start.
     */
    pending?: boolean;
    /** Prompts offered on an empty transcript. Clicking one sends it. */
    suggestions?: readonly string[];
    /** Avatar for a turn — an `<Avatar>`, an `<Icon>`, a logo. */
    renderAvatar?: (message: AIChatMessage) => ReactNode;
    /** Render a body yourself — a tool-call card, a chart, a citation list. */
    renderContent?: (message: AIChatMessage) => ReactNode;
    /** Ratings to show as pressed, by message id. Omit to keep them local. */
    votes?: Readonly<Record<string, AIChatVote>>;
    /** Rendered above the transcript, inside the panel. */
    header?: ReactNode;
    /** Shown when there are no turns and no suggestions. */
    emptyState?: ReactNode;
    /** Show `"system"` turns. Default `false`. */
    showSystem?: boolean;
    /** Reasoning blocks start expanded. Default `false`. */
    defaultReasoningOpen?: boolean;
    /** Show line numbers in fenced code. Default `false`. */
    showLineNumbers?: boolean;
    /** Locale for labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Placeholder for the composer. */
    placeholder?: string;
    /** Extra controls inside the composer, before the send button. */
    composerActions?: ReactNode;
    /**
     * Reach the composer imperatively — `focus()`, `getValue()`, `setValue()`.
     *
     * What makes dictation (or a slash-command menu, or "edit and resend") possible
     * without this component knowing anything about them: pair it with
     * `composerActions` and the button you put in the composer can write into the
     * field. Speech recognition is **not** wired in here on purpose — it would make
     * every consumer of `AIChat` pay for an API that streams audio to a third party.
     */
    composerRef?: Ref<AIChatComposerHandle>;
    /** Under the composer field — token count, model name, a disclaimer. */
    composerFooter?: ReactNode;
    /** Disable the composer — no credits, conversation archived, offline. */
    composerDisabled?: boolean;
    /** Largest height the composer grows to, in lines. Default 8. */
    maxRows?: number;
    /**
     * Called when `onSend` **or** `onEditSubmit` rejects. The draft stays in the field
     * either way.
     */
    onSendError?: (error: unknown) => void;
}

/** Who produced a turn. */
export declare type AIChatRole = "user" | "assistant" | "system";

/** Labels the conversation needs, per locale. */
export declare interface AIChatStrings {
    thread: string;
    empty: string;
    emptyHint: string;
    placeholder: string;
    send: string;
    stop: string;
    regenerate: string;
    copy: string;
    copied: string;
    edit: string;
    save: string;
    cancel: string;
    editing: string;
    good: string;
    bad: string;
    reasoning: string;
    thinking: string;
    generating: string;
    done: string;
    stopped: string;
    you: string;
    assistant: string;
    system: string;
    retry: string;
    jumpToLatest: string;
    attachment: string;
    turnActions: string;
}

/** Locale strings for the conversation. */
export declare function aiChatStrings(locale: "pt-BR" | "en"): AIChatStrings;

/**
 * One turn of a conversation with a model.
 *
 * Exported for apps that build their own transcript layout (a split view, a diff of
 * two answers) but still want the SDK's turn: Markdown body, reasoning block,
 * attachments, streaming caret, error state and the action row.
 *
 * @example
 * <AIChatTurn message={turn} canRegenerate onRegenerate={(m) => reask(m)} />
 */
export declare function AIChatTurn({ message, locale, canRegenerate, onRegenerate, onFeedback, onEditSubmit, onEditError, onRetry, renderAvatar, renderContent, vote, defaultReasoningOpen, showLineNumbers, }: AIChatTurnProps): JSX.Element;

export declare interface AIChatTurnProps {
    /** The turn to render. */
    message: AIChatMessage;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /**
     * Offer the regenerate control.
     *
     * Only the newest assistant turn should get it — re-asking an older one throws
     * away every turn after it, which is a different operation and needs its own
     * confirmation.
     */
    canRegenerate?: boolean;
    onRegenerate?: (message: AIChatMessage) => void;
    onFeedback?: (message: AIChatMessage, vote: AIChatVote) => void;
    /** Enables the edit control on a user turn. Receives the edited prompt. */
    onEditSubmit?: (message: AIChatMessage, text: string) => void | Promise<void>;
    /**
     * Called when `onEditSubmit` rejects. The editor stays open with the draft either
     * way.
     *
     * Without it the rejection is swallowed after the draft is preserved: re-throwing
     * out of a click handler surfaces as an unhandled promise rejection, which is
     * console noise for the developer and nothing the user can act on.
     */
    onEditError?: (error: unknown) => void;
    /** Enables the retry control on a turn that carries an `error`. */
    onRetry?: (message: AIChatMessage) => void;
    renderAvatar?: (message: AIChatMessage) => ReactNode;
    /** Render the body yourself — a tool-call card, a chart, a citation list. */
    renderContent?: (message: AIChatMessage) => ReactNode;
    /**
     * Rating to show as pressed.
     *
     * Pass it to keep votes in app state (persisted across a reload); leave it out
     * and the pressed state is kept locally, which is enough for a fire-and-forget
     * `onFeedback`.
     */
    vote?: AIChatVote;
    /** Reasoning blocks start expanded. Default `false`. */
    defaultReasoningOpen?: boolean;
    /** Show line numbers in fenced code. Default `false`. */
    showLineNumbers?: boolean;
}

/** Rating an app can collect on an assistant turn. */
export declare type AIChatVote = "up" | "down";

/**
 * Inline alert / notice with tone (info/success/warning/danger) and appearance
 * (soft/solid/outline). Accepts optional `icon`, `title`, `description` and
 * a dismiss button via `onClose`.
 */
export declare function Alert({ variant, appearance, title, description, icon, onClose, closeLabel, className, children, ...props }: AlertProps): JSX.Element;

export declare type AlertAppearance = "soft" | "solid" | "outline";

export declare interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
    variant?: AlertVariant;
    /** Visual style: soft (default tinted bg), solid (filled), outline (bordered). */
    appearance?: AlertAppearance;
    title?: ReactNode;
    description?: ReactNode;
    icon?: ReactNode;
    /** Show a close button and invoke this when clicked. */
    onClose?: () => void;
    /** Custom close button label for screen readers. */
    closeLabel?: string;
}

export declare type AlertVariant = "neutral" | "info" | "success" | "warning" | "danger";

/** Every symbology in the spec, used to validate what a detector reports back. */
export declare const ALL_BARCODE_FORMATS: readonly BarcodeFormat[];

/**
 * Announce a message to screen readers, from anywhere — a hook, an event handler,
 * a plain function outside React.
 *
 * ## Why the same string announces twice
 *
 * Screen readers announce a live region when its **content changes**. Writing the
 * same text again is not a change, so "Item removido" twice in a row is read once —
 * the classic reason these announcers are quietly broken. Instead of mutating text,
 * every call replaces the region's child with a **new element**. The DOM mutation is
 * real even when the string is identical, so the second announcement happens, and
 * the reader hears the exact message with no padding characters bolted on.
 *
 * @param message - Text to read out. Empty strings are ignored.
 * @param politeness - `"polite"` (default) or `"assertive"`.
 *
 * @example
 * announce(`${count} pedidos encontrados`);
 * announce("Falha ao salvar", "assertive");
 */
export declare function announce(message: string, politeness?: AnnouncePoliteness): void;

/**
 * How urgently a screen reader should interrupt.
 *
 * `"polite"` waits for a pause in what is being read. `"assertive"` cuts in
 * immediately, which is right for an error the user must act on and wrong for
 * everything else — an assertive announcement can truncate the sentence the user
 * was in the middle of.
 */
export declare type AnnouncePoliteness = "polite" | "assertive";

/**
 * Any React component, whatever props it declares.
 *
 * Props sit in a *parameter* position, so a bound over them is contravariant:
 * `ComponentType<unknown>` reads as "a component that accepts every possible
 * props object", and only a component that declares no props at all satisfies
 * it. A page typed `({ mode }: Props) => …` is rejected, and so is one whose
 * props are entirely optional. `any` is the only bound that admits every
 * component — which is why React itself declares `lazy` and
 * `LazyExoticComponent` as `ComponentType<any>`. `ComponentType<never>` is not
 * an escape: it fails React's own bound through
 * `ComponentClass.getDerivedStateFromProps`, where the props land back in a
 * covariant position.
 *
 * This relaxes the *bound* only. `T` is still inferred as the concrete
 * component, so the rendered element keeps checking its props and `preload()`
 * still resolves to the concrete module.
 */
declare type AnyComponent = ComponentType<any>;

declare type AnyEventTarget = EventTarget | {
    current: EventTarget | null;
} | null | undefined;

/**
 * Any page component a route can point at, whatever props it declares.
 *
 * Same contravariance as `lazyWithRetry`, which this field is handed to:
 * `ComponentType<unknown>` means "accepts every possible props object", so a
 * route module default-exporting `({ id }: Props) => …` would not assign here —
 * and neither would one whose props are all optional. React declares its own
 * `lazy` as `ComponentType<any>` for the same reason.
 */
declare type AnyRouteComponent = ComponentType<any>;

/**
 * Translation key the {@link useDescribeApiError} hook looks up.
 *
 * A catalog that does not define it falls back to
 * {@link DEFAULT_API_ERROR_STRINGS}, because `t` returns the key itself when the
 * lookup misses and printing `tempest.error.offline` at the user would be worse
 * than printing pt-BR at them.
 */
export declare const API_ERROR_OFFLINE_KEY = "tempest.error.offline";

/**
 * Translation key for the validation sentence, looked up the same way as
 * {@link API_ERROR_OFFLINE_KEY}.
 */
export declare const API_ERROR_VALIDATION_KEY = "tempest.error.validation";

export declare interface ApiClient {
    request<T>(path: string, options?: RequestOptions): Promise<T>;
    get<T>(path: string, options?: RequestOptions): Promise<T>;
    post<T>(path: string, options?: RequestOptions): Promise<T>;
    put<T>(path: string, options?: RequestOptions): Promise<T>;
    patch<T>(path: string, options?: RequestOptions): Promise<T>;
    delete<T>(path: string, options?: RequestOptions): Promise<T>;
    /**
     * Download a binary body through the full client pipeline.
     *
     * Same base URL, `getToken` header, 401 refresh-and-replay, `onUnauthorized`,
     * logging, timeout and retry policy as {@link ApiClient.request} — only the
     * decoding differs. Without it every download left the client: a hand-rolled
     * `fetch` that re-declares the `Authorization` header and re-implements the
     * error handling, and that has no refresh, which is the client's reason to
     * exist.
     *
     * @param path - Path joined onto the client's base URL.
     * @param options - The same options `request` takes; `method` defaults to GET.
     * @returns The response body as a `Blob`.
     * @throws TempestApiError On any non-2xx response, carrying the status.
     */
    blob(path: string, options?: RequestOptions): Promise<Blob>;
    /**
     * Download a binary body as an `ArrayBuffer`, for the callers a `Blob` does
     * not serve — a decoder, a hash, a typed array fed to WebGL or to
     * `onnxruntime-web`.
     *
     * @param path - Path joined onto the client's base URL.
     * @param options - The same options `request` takes; `method` defaults to GET.
     * @returns The response body as an `ArrayBuffer`.
     * @throws TempestApiError On any non-2xx response, carrying the status.
     */
    arrayBuffer(path: string, options?: RequestOptions): Promise<ArrayBuffer>;
    upload<T>(path: string, formData: FormData, method?: "POST" | "PUT" | "PATCH", options?: Omit<RequestOptions, "body" | "method">): Promise<T>;
}

export declare interface ApiClientConfig {
    /**
     * Base URL for every request. Required.
     *
     * May carry a path (`https://api.example.com/api`) — it is kept, and a
     * request for `"/auth/login"` lands on `/api/auth/login`. May also be
     * relative (`"/api"`), which resolves against the current origin and is the
     * shape to use behind a dev-server or reverse proxy.
     */
    baseURL: string;
    /**
     * Path segment every request is nested under, such as `"/api"` — the
     * `root_path` a Tempest FastAPI service is usually mounted on.
     *
     * The alternative to writing it into `baseURL`, and the better one when the
     * base comes from an environment variable that other things also use (an
     * SSE endpoint, a media host): the variable stays the bare origin and only
     * the client carries the prefix.
     *
     * Applied at most once — a path that already opens with the prefix is left
     * alone, so call sites can migrate one at a time.
     */
    prefix?: string;
    /** Returns the current bearer token (or null/undefined). Called per request. */
    getToken?: () => string | null | undefined;
    /**
     * Origins besides `baseURL`'s that may receive the `getToken` credential.
     *
     * Since 0.66.0 the bearer token is scoped to the origin of `baseURL`. A
     * request to any other origin still goes out — it just goes without the
     * header. That matters because a path may be an absolute URL, in which case
     * it overrides `baseURL` completely, so the destination of a credentialed
     * request could be decided by a value the app read off the network: a
     * pagination link, a `download_url`, a `Location`.
     *
     * List the second host here when it genuinely needs the API's token — a CDN
     * behind the same identity, a sibling service. An origin compares as an
     * origin (`"https://cdn.acme.com"`), so path and trailing slash are
     * ignored.
     *
     * A relative `baseURL` needs nothing here: a relative target resolves
     * against the document and cannot cross an origin.
     */
    trustedOrigins?: readonly string[];
    /**
     * Per-request correlation id sent as the `X-Request-ID` header, matching the
     * Tempest FastAPI SDK `RequestIDMiddleware`. Defaults to a generated id.
     * Return an empty string to disable the header.
     */
    requestId?: () => string;
    /**
     * Called when a request ends up unauthorized — a 401 with no `refresh`
     * configured, a `refresh()` that threw, or a retry that came back 401 again
     * after a refresh that resolved. Use it to end the session.
     */
    onUnauthorized?: (response: Response) => void | Promise<void>;
    /**
     * Where the client reports each request it finished. Off when absent — the
     * client writes to no console of its own.
     *
     * One entry per attempt (so a refresh replay and every retry show up), at
     * `debug` under 400 and at `warn` from 400 up, carrying `requestId`,
     * `status` and the elapsed `ms`. Firing `onUnauthorized` gets its own `warn`,
     * which is what a session dying mid-session looks like in the log.
     *
     * Deliberately **not** a `debug: boolean`: the level lives in the logger you
     * pass, so `createLogger({ level })` decides what survives, the sink decides
     * where it goes (console in dev, Sentry in production, an array in a test),
     * and one namespace per client keeps two clients apart.
     *
     * Never logs a body, a header, or the query string — a bearer token in
     * `Authorization`, a password in a login payload and an `access_token` query
     * param would all end up in whatever the sink writes to. What is logged is
     * the method, the path as the call site wrote it, and the numbers.
     */
    logger?: ApiClientLogger;
    /**
     * Optional refresh hook. When provided and the original request returns 401,
     * the client awaits `refresh()` then retries the request once.
     */
    refresh?: () => Promise<void>;
    /**
     * Retry failed requests with exponential backoff. Off by default, so the
     * client keeps failing fast unless you opt in.
     *
     * `true` uses the built-in policy, which is deliberately conservative: only
     * idempotent methods (`GET`, `HEAD`, `OPTIONS`) and only failures a retry
     * can plausibly fix — a network error, `408`, `425`, `429`, or any `5xx`. A
     * `POST` is never retried on its own, so nothing gets duplicated.
     *
     * Pass {@link RetryOptions} to tune it. Supplying your own `shouldRetry`
     * replaces the built-in policy entirely, method check included — that is the
     * escape hatch for retrying a write you made idempotent with
     * {@link generateIdempotencyKey}.
     *
     * Retries wrap the whole request, refresh included, and each attempt carries
     * its own `X-Request-ID`. A `4xx` outside the three listed above is never
     * retried: repeating an identical request cannot fix a bad payload or a
     * permission the caller does not have.
     */
    retry?: boolean | RetryOptions;
    /** Whether to send cookies on cross-origin requests (default: false). */
    /**
     * Milliseconds before a request is abandoned. Default `15_000`. `null` turns
     * it off.
     *
     * There was no timeout at all before, and the failure it leaves open is not
     * an error: a TCP connection that dies without a FIN never answers, so the
     * browser can hold the request for minutes or forever. In an offline-first
     * SDK that is the wrong place to have no floor — the eternal spinner lands
     * exactly on the bad network this package exists to survive.
     *
     * A timeout surfaces as an {@link ApiError} with `status: 0`, the same shape
     * the client already uses for "never reached the server", so the built-in
     * retry policy replays it without a special case.
     */
    timeout?: number | null;
    /**
     * Milliseconds before a `FormData` request is abandoned. Default `300_000`.
     * `null` turns it off.
     *
     * A binary upload is not a slow request, it is a different kind of request. A
     * single timeout forces a choice between one short enough to protect a normal
     * call and one long enough to finish a file, and 15 seconds cuts an upload
     * mid-body — which the server then has to interpret as a truncated payload.
     *
     * Detected from the body being `FormData`, the same test that already decides
     * the `Content-Type`. Override per request with `options.timeout` when a
     * particular call does not fit either default.
     */
    uploadTimeout?: number | null;
    withCredentials?: boolean;
    /** Default headers merged into every request. */
    headers?: Record<string, string>;
    /** Optional fetch implementation (defaults to globalThis.fetch). */
    fetcher?: typeof fetch;
}

/**
 * The slice of {@link Logger} the client writes to: `debug` for a request that
 * came back under 400, `warn` for everything else. Structural, so the SDK
 * logger fits without adapting and so does any object with those two methods.
 */
export declare type ApiClientLogger = Pick<Logger, "debug" | "warn">;

export declare interface ApiError {
    /** HTTP status code (0 for network failures). */
    status: number;
    /** Human-readable message — the backend envelope's `detail` (or `message`). */
    detail: string;
    /**
     * Programmatic error code from the Tempest FastAPI SDK envelope (`code`),
     * e.g. `"EMAIL_TAKEN"`. Lets callers branch without parsing `detail`.
     */
    code?: string;
    /**
     * Correlation id echoed from the backend envelope's `details.request_id`
     * (or the `X-Request-ID` response header). Pair it with `createLogger`.
     */
    requestId?: string;
    /**
     * Seconds to wait before retrying, parsed from the `Retry-After` response
     * header (commonly on `429`/`503`). Honored by {@link retry}.
     */
    retryAfter?: number;
    /**
     * Field-level messages from a validation response, keyed by the field path
     * the backend named (`"email"`, `"items.0.price"`, `"phone"`).
     *
     * Present whenever the body named a field, through either shape a Tempest
     * stack sends:
     *
     * - FastAPI's validation list — `detail: [{ loc, msg, type }]`, one entry per
     *   field, each keyed by its `loc` path.
     * - The singular keys a `tempest-fastapi-sdk` backend uses once it owns the
     *   handler — `detail.field`, then top-level `field`, then `details.field`, in
     *   that order. There the single value is the same sentence as `detail`.
     *
     * This is the shape a form needs: `detail` is one line for a log or a
     * developer, and pulling the fields back out of it means parsing prose. The
     * first message wins when a field appears twice, because a field shows one
     * error at a time.
     */
    fields?: Record<string, string>;
    /** The raw parsed error body, when available. */
    body?: unknown;
}

/** The fixed sentences {@link describeApiError} may need. */
export declare interface ApiErrorStrings {
    /** Shown when the request never reached the server. */
    offline: string;
    /**
     * Shown when the backend rejected the payload field by field.
     *
     * The per-field messages are on `error.fields`, to be attached to the inputs
     * themselves; this sentence is what the toast says.
     *
     * It does not apply to the one rejection that named a single field with a
     * finished sentence — there the server's own `detail` is shown instead, since
     * it is the same string `fields` carries. Pass `useDetail: false` to force
     * this sentence in that case too.
     */
    validation: string;
}

/**
 * Mobile-first top app bar for PWAs — leading (back / brand) + title +
 * trailing actions, sticky with safe-area padding out of the box.
 *
 * Consumers customise via tokens (`--tempest-*`) and slots; the SDK ships the
 * layout, sticky/safe-area behaviour, and accessible back button so apps don't
 * hand-roll one per screen. For a desktop three-slot nav use [[Navbar]].
 *
 * @example
 * // Detail screen with back + a trailing action
 * <AppBar
 *     title="Profile"
 *     showBack
 *     onBack={() => navigate(-1)}
 *     actions={<IconButton icon={<Settings />} onClick={openSettings} />}
 * />
 *
 * @example
 * // Home screen — brand left, centered title disabled
 * <AppBar brand={<Logo />} actions={<UserMenu />} />
 */
export declare function AppBar({ title, leading, showBack, onBack, backLabel, backIcon, brand, actions, centered, sticky, tone, bordered, safeArea, className, ...props }: AppBarProps): JSX.Element;

export declare interface AppBarProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
    /** Page title — string or any node. Rendered as the bar's `<h1>`. */
    title?: ReactNode;
    /**
     * Replace the whole left slot. When set, the auto back button and `brand`
     * are ignored — you own the leading content.
     */
    leading?: ReactNode;
    /** Show a back button in the left slot. Ignored when `leading` is set. */
    showBack?: boolean;
    /**
     * Back-button handler. Defaults to `window.history.back()`. With a router,
     * pass `onBack={() => navigate(-1)}`.
     */
    onBack?: () => void;
    /** Accessible label for the back button. Default `"Go back"`. */
    backLabel?: string;
    /** Custom back icon. Default a left arrow. */
    backIcon?: ReactNode;
    /** Brand / logo node shown in the left slot (after the back button). */
    brand?: ReactNode;
    /** Right slot — action buttons / menu. One node or many. */
    actions?: ReactNode;
    /** Center the title (three-column grid). Default `false` (left-aligned). */
    centered?: boolean;
    /**
     * Stick to the top of the scroll container. Default `true`.
     *
     * The page has to leave the body out of the scrolling: `body { overflow-x:
     * hidden }` makes the body a scroll container and the bar scrolls away with
     * the content. Use `overflow-x: clip` on `html` and `body` instead — in
     * development the bar says so in the console when it detects it.
     */
    sticky?: boolean;
    /** Visual tone. Default `"surface"`. */
    tone?: AppBarTone;
    /** Thin bottom border. Default `true`. */
    bordered?: boolean;
    /** Add `env(safe-area-inset-top)` padding (iOS notch / PWA). Default `true`. */
    safeArea?: boolean;
}

export declare type AppBarTone = "surface" | "primary" | "transparent";

/**
 * Run a filter set over an in-memory list.
 *
 * Closes the loop `FilterBar` opens: the bar produces `Filter[]`, this applies
 * them. Filters combine with `AND`, matching the flat model the bar builds, and
 * an incomplete filter is skipped rather than treated as a match of nothing — a
 * half-filled form should not empty the table underneath it.
 *
 * Comparison follows the row's type, not the filter's: numbers compare
 * numerically, dates compare by day, and everything else compares as text with
 * `numeric: true` so `"item 2"` lands before `"item 10"`.
 *
 * A few behaviours differ from the SQL the server-side twin produces, and the
 * difference is deliberate rather than accidental:
 *
 * - `ne` matches rows whose value is absent. In SQL, `column <> 'x'` is `NULL`
 *   for a `NULL` column and the row drops out. Here "is not paid" shows the rows
 *   with no status at all, which is what the chip claims.
 * - `empty` matches `NULL`, blank text and empty lists; `__isnull` on the server
 *   only matches `NULL`. A column that stores `""` instead of `NULL` is where
 *   the two disagree.
 *
 * @example
 * const visible = applyFilters(orders, filters);
 *
 * Each filter's values are normalised once, before the scan, rather than inside
 * the per-row predicate: the arity, the `between` ordering and the value array
 * depend only on the filter, so deriving them per row multiplied that work by
 * the row count. `empty`/`notEmpty` ignore their values entirely, which is why
 * the prepared shape does not need to distinguish them.
 *
 * @param items - The full list.
 * @param filters - Applied filters; incomplete ones are ignored.
 * @returns A new array with the rows that satisfy every complete filter.
 */
export declare function applyFilters<T>(items: readonly T[], filters: readonly Filter[]): T[];

/**
 * Apply a {@link KanbanMove} to a column list, returning new arrays.
 *
 * Exported because every consumer needs the same reducer.
 *
 * `toIndex` is the position of the card that was dropped **onto**, read from the
 * board as it looked before the move. Inserting at that same index *after* removing
 * the dragged card lands where the user aimed in both directions — moving down, the
 * removal shifts the target up by one and the insertion lands after it; moving up,
 * nothing shifted. Compensating for the shift (the "obvious" `toIndex - 1`) is what
 * turns a one-step move down into a no-op.
 *
 * @param columns - Current board.
 * @param move - The move reported by `onMove`.
 * @returns A new column list, or the same reference when the move cannot apply.
 */
export declare function applyKanbanMove(columns: KanbanColumn[], move: KanbanMove): KanbanColumn[];

/**
 * Install a generated theme (or raw CSS) into the document.
 *
 * Safe to call outside a browser: with no `document` it is a no-op returning a
 * no-op disposer, so app bootstrap code does not need a `typeof window` guard.
 *
 * @param theme - A {@link GeneratedTheme} from `createTheme`, or CSS text.
 * @param options - Style element id and mount target.
 * @returns A function that removes the injected `<style>` element.
 *
 * @example
 * ```ts
 * import { applyTheme, createTheme, themePresets } from "tempest-react-sdk";
 *
 * const dispose = applyTheme(createTheme(themePresets.violet));
 * // later: dispose();
 * ```
 */
export declare function applyTheme(theme: GeneratedTheme | string, options?: ApplyThemeOptions): () => void;

/** Options for {@link applyTheme}. */
export declare interface ApplyThemeOptions {
    /**
     * `id` of the managed `<style>` element. Reusing the same id replaces the
     * previous theme; a distinct id lets two themes coexist (e.g. a scoped
     * preview under its own selector). Default `"tempest-theme"`.
     */
    id?: string;
    /**
     * Node the `<style>` is appended to. Default `document.head`. Pass a shadow
     * root to theme a single web component.
     */
    target?: Document | ShadowRoot | HTMLElement;
}

/**
 * Compose the Tempest app-wide providers in one place: error boundary →
 * TanStack Query → theme → i18n. Query and theme are on by default; i18n and
 * the error boundary mount only when configured. Each provider can be disabled
 * or tuned independently, so an app's `main.tsx` stays a single declarative
 * block instead of a hand-nested provider pyramid.
 *
 * @example
 * <AppProviders
 *     errorBoundary={{ fallback: <Crash /> }}
 *     i18n={{ locale: "pt-BR", messages }}
 * >
 *     <AppRouter routes={routes} />
 * </AppProviders>
 */
export declare function AppProviders({ children, query, theme, i18n, errorBoundary }: AppProvidersProps): JSX.Element;

export declare interface AppProvidersProps {
    children: ReactNode;
    /**
     * TanStack Query config. Enabled by default with SDK defaults; pass `false`
     * to opt out (e.g. the app already mounts its own `QueryProvider`).
     */
    query?: Omit<QueryProviderProps, "children"> | false;
    /**
     * Theme config. Enabled by default; pass `false` to opt out.
     */
    theme?: Omit<ThemeProviderProps, "children"> | false;
    /**
     * i18n config. Opt-in: provide `locale` + `messages` to mount the provider.
     */
    i18n?: Omit<I18nProviderProps, "children">;
    /**
     * Top-level error boundary. Opt-in: provide a `fallback` to wrap the tree.
     */
    errorBoundary?: Omit<ErrorBoundaryProps, "children">;
}

/**
 * Render a full React Router (v7 or v8, declarative mode) from a
 * {@link defineRoutes}
 * tree: picks the history strategy, wraps everything in a `<Suspense>` boundary
 * for `lazy` routes, and applies per-route `guard` redirects. This is the
 * single entry point apps mount at their root.
 *
 * @example
 * <AppRouter routes={routes} fallback={<Spinner />} />
 */
export declare function AppRouter({ routes, router, basename, initialEntries, fallback, }: AppRouterProps): JSX.Element;

export declare interface AppRouterProps {
    /** Declarative route tree, ideally built with {@link defineRoutes}. */
    routes: TempestRouteObject[];
    /** History strategy (default: `"browser"`). */
    router?: RouterKind;
    /** App-wide base path forwarded to the underlying router. */
    basename?: string;
    /** Initial URLs for the `"memory"` router (tests / non-DOM hosts). */
    initialEntries?: string[];
    /**
     * Suspense fallback shown while a `lazy` route chunk loads, and the default
     * for a route whose `guard` answers `"pending"` — one spinner covers both
     * kinds of "not ready yet". A route overrides it with its own
     * `guardFallback`.
     */
    fallback?: ReactNode;
}

/**
 * Full app layout — composes [[Navbar]] + [[Sidebar]] + content +
 * [[BottomNavigation]] + footer with responsive behaviour:
 *
 * - **Desktop (`>= sidebarBreakpoint`)**: navbar + sidebar + main + footer.
 * - **Mobile (`< sidebarBreakpoint`)**: navbar + main + bottom nav + footer
 *   (sidebar hidden — app should expose it via `<Drawer>` from a hamburger).
 *
 * @example
 * <AppShell
 *     navbar={<Navbar logo={<Brand />} actions={<UserMenu />} />}
 *     sidebar={<Sidebar items={...} value={tab} onChange={setTab} />}
 *     bottomNav={<BottomNavigation items={...} value={tab} onChange={setTab} />}
 *     footer={<Footer />}
 * >
 *     <Page title="Dashboard">{content}</Page>
 * </AppShell>
 */
export declare function AppShell({ navbar, sidebar, bottomNav, footer, sidebarBreakpoint, className, children, ...props }: AppShellProps): JSX.Element;

export declare interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
    /** Top navigation bar (Navbar / custom). Renders on every breakpoint. */
    navbar?: ReactNode;
    /** Side navigation (Sidebar). Hidden below `md` — pair with `<Drawer>` for mobile. */
    sidebar?: ReactNode;
    /** Mobile-only bottom navigation (BottomNavigation). Hidden at `md+`. */
    bottomNav?: ReactNode;
    /** Footer rendered after the main content. */
    footer?: ReactNode;
    /** Breakpoint at which the sidebar appears. Default `"md"`. */
    sidebarBreakpoint?: "sm" | "md" | "lg" | "xl";
    children?: ReactNode;
}

/**
 * Preserve a constant aspect ratio for media (images, video, embeds). The
 * inner child stretches to fill the box. Uses the native `aspect-ratio`
 * CSS property — works on all modern browsers (Safari 15+, Chrome 88+).
 *
 * @example
 * <AspectRatio ratio={16 / 9}>
 *     <img src="/cover.jpg" alt="" style={{ width: "100%", height: "100%", objectFit: "cover" }} />
 * </AspectRatio>
 */
export declare function AspectRatio({ ratio, className, style, children, ...props }: AspectRatioProps): JSX.Element;

export declare interface AspectRatioProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * Width-to-height ratio. Pass `16/9` for widescreen, `1` for square,
     * `4/3` for SD video, `3/4` for portrait, etc. Default `16/9`.
     */
    ratio?: number;
    children?: ReactNode;
}

/**
 * Assert that a code path is unreachable, throwing at runtime if reached.
 *
 * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any
 * unhandled union member at compile time and the runtime fails loudly if an
 * unexpected value slips through.
 *
 * @param value - The value that should be of type `never`.
 * @param message - Optional custom error message.
 * @throws {Error} Always.
 *
 * @example
 * type Shape = "circle" | "square";
 * function area(shape: Shape): number {
 *   switch (shape) {
 *     case "circle": return 1;
 *     case "square": return 2;
 *     default: return assertNever(shape);
 *   }
 * }
 */
export declare function assertNever(value: never, message?: string): never;

export declare type AsyncStatus = "idle" | "pending" | "success" | "error";

/**
 * Container/codec candidates, best first.
 *
 * No browser supports all of these, and none supports MP3 or WAV from
 * `MediaRecorder` — see the note on {@link pickAudioMimeType}. Opus in WebM is the
 * first choice because it is the smallest at speech bitrates and is what Chromium
 * and Firefox produce natively; `audio/mp4` is here for Safari, which produces AAC
 * and nothing else.
 *
 * Ported from the intersection of what `MediaRecorder.isTypeSupported` accepts in
 * Chrome 120+, Firefox 115+ and Safari 17. Re-check against
 * <https://developer.mozilla.org/docs/Web/API/MediaRecorder/isTypeSupported> before
 * adding to the list.
 */
export declare const AUDIO_MIME_CANDIDATES: readonly string[];

/** A running mix. */
export declare interface AudioBus {
    /**
     * Play a stream through the shared mix.
     *
     * @param stream - The stream to play. Only its first audio track is used.
     * @param options - `gain` is the initial multiplier, default `1`.
     * @returns A handle to adjust or detach this source.
     */
    attach: (stream: MediaStream, options?: {
        gain?: number;
    }) => AudioBusHandle;
    /** Scale every source, on top of its own gain. */
    setMasterGain: (gain: number) => void;
    /** Current master gain, after clamping. */
    readonly masterGain: number;
    /**
     * Route the whole mix to one output device.
     *
     * @param deviceId - Device id from `useMediaDevices().audioOutputs`, or `""`
     *   for the system default.
     * @returns `false` when the engine cannot route audio, or the device is gone.
     */
    setOutputDevice: (deviceId: string) => Promise<boolean>;
    /** Device id the mix is routed to. `""` is the system default. */
    readonly outputDevice: string;
    /**
     * Resume a context the browser started suspended.
     *
     * Autoplay policy suspends a context created outside a user gesture, and a
     * suspended context is silent with no error anywhere. Call this from the
     * click that starts playback.
     */
    resume: () => Promise<void>;
    /**
     * Detach everything and close the context this bus created.
     *
     * Idempotent, and the bus stays callable afterwards: `attach` hands back an
     * inert handle instead of throwing. That is not politeness — creating a node
     * on a closed `AudioContext` throws `InvalidStateError`, and the stream that
     * arrives late is the normal case (a WebRTC `ontrack` firing after the
     * component that owned the bus went away).
     */
    close: () => void;
    /** Whether this browser gave us a Web Audio graph at all. */
    readonly supported: boolean;
    /** Whether this browser can route the mix to a chosen output device. */
    readonly canSelectOutput: boolean;
}

/** One source attached to the bus. */
export declare interface AudioBusHandle {
    /**
     * Set this source's gain, where `1` is the level it arrived at.
     *
     * Values above `1` are the point of the whole graph: `element.volume` is
     * clamped at `1`, so a quiet talker could only ever be attenuated — the one
     * correction nobody needs.
     */
    setGain: (gain: number) => void;
    /** Current gain, after clamping. */
    readonly gain: number;
    /** Detach this source and release its nodes. The bus stays up. */
    stop: () => void;
}

/** Options for {@link createAudioBus}. */
export declare interface AudioBusOptions {
    /** Ceiling for every gain on this bus. Default {@link DEFAULT_MAX_GAIN}. */
    maxGain?: number;
    /** Override the master limiter, or pass `false` to run without one. */
    limiter?: Partial<LimiterSettings> | false;
    /**
     * Reuse an existing `AudioContext` instead of creating one.
     *
     * Browsers cap the number of live contexts (Chrome allows around six), so a
     * page that already has one — a level meter, a player — should hand it over
     * rather than open a second.
     */
    context?: AudioContext;
}

/**
 * Playback transport for one clip: play/pause, a seek bar, elapsed and total time.
 *
 * Built around a real `<audio>` element rather than the SDK's `createAudioPlayer`,
 * which is a fire-and-forget handle for notification chimes and has no transport to
 * expose. Accepts a `Blob` directly, because the thing an app most often plays is the
 * recording it just made.
 *
 * The seek bar is a bare `<input type="range">` rather than the SDK's `Slider`: that
 * component is a form field, with a label row and a value badge, and a transport wants
 * neither. The native input keeps the keyboard and screen-reader behaviour that
 * matters here for free.
 *
 * @example
 * const rec = useAudioRecorder(mic.stream);
 * {rec.recording && (
 *     <AudioPlayer src={rec.recording.blob} durationMs={rec.recording.durationMs} />
 * )}
 */
export declare function AudioPlayer({ src, durationMs, sinkId, autoPlay, loop, locale, actions, onEnded, onError, disabled, className, ...rest }: AudioPlayerProps): JSX.Element;

/**
 * Imperative handle over one "current" clip.
 *
 * Named `*Handle` like the SDK's other imperative handles (`ChatComposerHandle`,
 * `SignaturePadHandle`) — it is a control surface, not the `<AudioPlayer>` component.
 */
export declare interface AudioPlayerHandle {
    /** Play `src`. Returns the underlying element, or `null` when the browser blocked autoplay. */
    play: (src: string, options?: PlayAudioOptions) => Promise<HTMLAudioElement | null>;
    /** Stop the currently-playing clip and rewind it. */
    stop: () => void;
    /** Currently playing audio element, or `null`. */
    current: () => HTMLAudioElement | null;
}

export declare interface AudioPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_5> {
    /**
     * What to play — a URL, or a `Blob`/`File` straight from a recorder.
     *
     * A `Blob` is wrapped in an object URL that is revoked when it changes or the
     * component unmounts, so a page that records twenty notes does not leak twenty
     * URLs for the lifetime of the tab.
     */
    src: string | Blob | null;
    /**
     * Known length in milliseconds.
     *
     * Pass it whenever you have it — a recording from `useAudioRecorder` always does.
     * See the note on the seek bar for why the element's own `duration` is not
     * trustworthy for a fresh recording.
     */
    durationMs?: number;
    /** Output device, from `useMediaDevices().audioOutputs`. Chromium only. */
    sinkId?: string;
    /** Start playing as soon as `src` is ready. Default `false`. */
    autoPlay?: boolean;
    /** Loop. Default `false`. */
    loop?: boolean;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Rendered to the right of the times — a download button, a delete button. */
    actions?: React.ReactNode;
    /** Fired when playback reaches the end. */
    onEnded?: () => void;
    /** Fired when the element reports a decode/network error. */
    onError?: (error: unknown) => void;
    /** No `src` yet, or playback not allowed. */
    disabled?: boolean;
}

/**
 * Record a voice note: one button to start, a live level meter, a clock, and a
 * playback review before the audio leaves the component.
 *
 * The permission flow is the part worth reading. The microphone is **not** opened on
 * mount — the prompt fires on the first press of Record, because a prompt the user did
 * not provoke is the most reliable way to earn a permanent block, after which
 * `getUserMedia` rejects without ever asking again. When the permission is already
 * `"denied"`, the component says so and how to fix it instead of offering a button
 * that cannot work.
 *
 * The level meter is not decoration either: a muted OS input or a headset with its mic
 * arm folded up produces a perfectly successful recording of silence, and without a
 * visible level the user only finds out after they finish talking.
 *
 * @example
 * <AudioRecorder
 *     maxDurationMs={120_000}
 *     format="wav"
 *     wavOptions={{ mono: true, sampleRate: 16000 }}
 *     onRecorded={({ blob }) => upload(blob)}
 * />
 */
export declare function AudioRecorder({ onRecorded, maxDurationMs, deviceId, format, wavOptions, audioBitsPerSecond, review, locale, footer, onError, disabled, className, ...rest }: AudioRecorderProps): JSX.Element;

/** Imperative recorder. */
export declare interface AudioRecorderHandle {
    /** Begin recording. No-op when already recording or paused. */
    start: () => void;
    /** Pause. The clock stops; `durationMs` freezes. */
    pause: () => void;
    /** Resume after `pause()`. */
    resume: () => void;
    /** Stop and resolve with the assembled recording. */
    stop: () => Promise<AudioRecording>;
    /** Stop and throw the audio away. */
    cancel: () => void;
    status: () => AudioRecorderStatus;
    /** Recorded length so far, excluding paused time. */
    durationMs: () => number;
    /** The negotiated container. */
    mimeType: string;
}

/** Options for {@link createAudioRecorder}. */
export declare interface AudioRecorderOptions {
    /**
     * Force a container. Throws when the browser cannot produce it.
     *
     * Leave it out. The default negotiates from {@link AUDIO_MIME_CANDIDATES}, which
     * is the only way one call site works on both Chromium and Safari.
     */
    mimeType?: string;
    /** Target bitrate. 32000–64000 is plenty for speech in Opus. */
    audioBitsPerSecond?: number;
    /**
     * Emit a chunk every N ms through `onChunk`, for streaming upload.
     *
     * Without it the whole recording is buffered in memory until `stop()` — fine for
     * a voice note, not fine for an hour-long meeting.
     */
    timesliceMs?: number;
    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
    onChunk?: (chunk: Blob) => void;
    /** Recorder-level failure (device unplugged mid-recording, encoder error). */
    onError?: (error: unknown) => void;
}

export declare interface AudioRecorderProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_6> {
    /**
     * Called once a recording is finished and (when asked) converted.
     *
     * Fires on stop and on hitting `maxDurationMs`, never on cancel.
     */
    onRecorded?: (recording: AudioRecording) => void;
    /** Stop automatically after this long. Strongly recommended on anything public. */
    maxDurationMs?: number;
    /** Specific microphone, from `useMediaDevices().audioInputs`. */
    deviceId?: string;
    /**
     * Output container.
     *
     * `"native"` (default) keeps what the browser produced — Opus on Chromium and
     * Firefox, AAC on Safari — which is the smallest and needs no work. `"wav"`
     * converts on stop, for a backend that only accepts WAV; see `wavOptions`, and
     * expect roughly ten times the bytes.
     */
    format?: "native" | "wav";
    /** Passed to `blobToWav` when `format="wav"`. `{ mono: true, sampleRate: 16000 }` suits speech. */
    wavOptions?: WavOptions;
    /** Target bitrate. 32000–64000 is plenty for speech in Opus. */
    audioBitsPerSecond?: number;
    /** Offer playback of the recording before handing it over. Default `true`. */
    review?: boolean;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Rendered under the controls — a hint, a character count, a legal notice. */
    footer?: ReactNode;
    /** Recorder-level failure, or a failed WAV conversion. */
    onError?: (error: unknown) => void;
    disabled?: boolean;
}

/** Lifecycle of a recording. Shared with the video recorder — the states are the same. */
export declare type AudioRecorderStatus = MediaRecorderStatus;

/** A finished recording. */
export declare interface AudioRecording {
    /** The audio. Wrap with `useObjectUrl` to play it, or POST it as-is. */
    blob: Blob;
    /** What the browser actually produced — not necessarily what you asked for. */
    mimeType: string;
    /** Recorded length, excluding time spent paused. */
    durationMs: number;
}

/**
 * Router-agnostic auth gate. The caller decides what to render in either
 * branch — typically `<Outlet />` for protected layouts and `<Navigate />` for
 * the redirect. Pair with {@link createAuthStore} or any custom auth source.
 *
 * @example
 * <AuthGuard
 *     isAuthenticated={useAuthStore((s) => s.isAuthenticated)}
 *     fallback={<Navigate to="/login" replace />}
 * >
 *     <Outlet />
 * </AuthGuard>
 */
export declare function AuthGuard({ isAuthenticated, children, fallback }: AuthGuardProps): JSX.Element;

export declare interface AuthGuardProps {
    /** Whether the current user is authenticated. */
    isAuthenticated: boolean;
    /** Element to render when authenticated. */
    children: ReactNode;
    /** Element to render when not authenticated. Use this to redirect (e.g. `<Navigate to="/login" />`). */
    fallback: ReactNode;
}

export declare interface AuthState<TUser> {
    user: TUser | null;
    token: string | null;
    isAuthenticated: boolean;
    setSession: (session: {
        user: TUser;
        token: string;
    }) => void;
    setUser: (user: TUser | null) => void;
    setToken: (token: string | null) => void;
    logout: () => void;
}

/**
 * Round avatar. Falls back to colored initials when the image fails to load
 * or no `src` is provided. Optional status dot in the bottom-right corner.
 */
export declare function Avatar({ src, alt, name, size, status, className, onClick, }: AvatarProps): JSX.Element;

/**
 * Overlapping row of avatars with a `+N` overflow chip — participants of a
 * meeting, assignees of a task, members of a team.
 *
 * The whole row is one `role="group"` with a single accessible name, and each
 * avatar's name is exposed as its label. That is deliberate: announcing seven
 * separate images with no relation between them is noise, and the overflow chip
 * carries the remaining count so the total is never hidden from a screen reader.
 *
 * @example
 * ```tsx
 * <AvatarGroup
 *   label="Participantes"
 *   max={3}
 *   items={[
 *     { name: "Ada Lovelace", src: ada },
 *     { name: "Grace Hopper" },
 *     { name: "Alan Turing" },
 *     { name: "Edsger Dijkstra" },
 *   ]}
 *   onOverflowClick={() => setDrawerOpen(true)}
 * />
 * ```
 */
export declare function AvatarGroup({ items, max, size, label, onOverflowClick, className, }: AvatarGroupProps): JSX.Element;

/** One participant of the group. */
export declare interface AvatarGroupItem {
    /** Image URL. Falls back to initials from `name`. */
    src?: string;
    /** Full name — drives the initials and the accessible label. */
    name: string;
}

export declare interface AvatarGroupProps {
    items: AvatarGroupItem[];
    /** How many avatars to show before collapsing into `+N`. Default `4`. */
    max?: number;
    size?: AvatarSize;
    /** Accessible name of the group, e.g. `"Participantes"`. */
    label?: string;
    /**
     * Called when the `+N` chip is activated — a natural hook for "see all
     * participants". Without it the chip is plain text and not focusable.
     */
    onOverflowClick?: () => void;
    className?: string;
}

export declare interface AvatarProps {
    src?: string;
    alt?: string;
    name?: string;
    size?: AvatarSize;
    status?: AvatarStatus;
    className?: string;
    onClick?: () => void;
}

export declare type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";

export declare type AvatarStatus = "online" | "offline" | "busy";

/**
 * Pill / square status badge.
 *
 * - `variant` picks the tone (neutral, primary, success, warning, danger, info).
 * - `appearance` picks the style (soft, solid, outline).
 * - `dot` prepends a status dot in the same tone.
 */
export declare function Badge({ variant, appearance, size, shape, dot, className, children, ...props }: BadgeProps): JSX.Element;

export declare type BadgeAppearance = "soft" | "solid" | "outline";

export declare interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
    variant?: BadgeVariant;
    /** Visual style: soft (default tinted bg), solid (filled), outline (bordered). */
    appearance?: BadgeAppearance;
    size?: BadgeSize;
    /** Pill (default rounded) or square (slightly rounded). */
    shape?: BadgeShape;
    /** Renders a leading status dot in the badge color. */
    dot?: boolean;
}

export declare type BadgeShape = "pill" | "square";

export declare type BadgeSize = "sm" | "md" | "lg";

export declare type BadgeVariant = "neutral" | "primary" | "success" | "warning" | "danger" | "info";

/**
 * Top-of-page persistent notice. Use for environment indicators
 * ("Você está em sandbox"), maintenance windows, account warnings.
 * Different from `Alert` (inline near a field) and `Toast` (transient).
 *
 * @example
 * <Banner variant="warning" dismissible onDismiss={() => setOpen(false)}>
 *     Sua assinatura expira em 3 dias.
 * </Banner>
 */
export declare function Banner({ variant, icon, title, action, dismissible, onDismiss, className, children, ...props }: BannerProps): JSX.Element | null;

export declare interface BannerProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
    /** Visual variant. Default `"info"`. */
    variant?: BannerVariant;
    /** Optional leading icon. */
    icon?: ReactNode;
    /** Optional title displayed before description. */
    title?: ReactNode;
    /** Optional action button rendered on the right side. */
    action?: ReactNode;
    /** Show a dismiss button on the right. */
    dismissible?: boolean;
    /** Callback fired when the dismiss button is clicked. */
    onDismiss?: () => void;
    children?: ReactNode;
}

export declare type BannerVariant = "info" | "success" | "warning" | "danger";

/**
 * The slice of `BarcodeDetector` this SDK uses.
 *
 * Exported so a consumer can **inject a polyfill** where the native API is missing —
 * see {@link isBarcodeDetectionSupported} for why that matters — and so tests can hand
 * in a decoder without a camera. Anything with a `detect()` that resolves to objects
 * carrying a `rawValue` will do.
 */
export declare interface BarcodeDetectorLike {
    /**
     * Decode every symbol visible in the source.
     *
     * @param source - A `<video>`, a `<canvas>`, an `ImageBitmap`, a `Blob`…
     * @returns Every symbol found, or an empty array — finding nothing is not an error.
     */
    detect: (source: ImageBitmapSource) => Promise<readonly DetectedBarcodeLike[]>;
}

/**
 * Symbologies the `BarcodeDetector` API names.
 *
 * Three of them carry the weight in Brazil: `ean_13` is the retail barcode on every
 * packaged product, `qr_code` is what a Pix "copia e cola" payload travels in, and
 * `code_128` is the label on a shipment. The rest are here because the spec has them
 * and asking for one costs nothing.
 */
export declare type BarcodeFormat = "aztec" | "codabar" | "code_128" | "code_39" | "code_93" | "data_matrix" | "ean_13" | "ean_8" | "itf" | "pdf417" | "qr_code" | "upc_a" | "upc_e" | "unknown";

/** A corner of a detected symbol, in the source's pixel coordinates. */
export declare interface BarcodePoint {
    x: number;
    y: number;
}

/**
 * Point the camera at a barcode and get its value.
 *
 * The counterpart to {@link QRCode}, which only encodes. Under it are
 * `useBarcodeScanner` (the detect loop and repeat suppression), `useCameraStream` (the
 * stream and its classified errors) and `useTorch`.
 *
 * **Mounting this opens the camera**, so mount it when the user asks to scan rather
 * than on a page that happens to contain a scanner: a permission prompt nobody
 * provoked is the surest way to earn a permanent block, and after that `getUserMedia`
 * rejects without ever prompting again. The usual shape is a button that reveals it.
 *
 * The `unsupported` slot is not a nicety. `BarcodeDetector` is Chromium-only — absent
 * on Firefox, on every browser on iOS, and on Chromium for Windows and Linux — so on a
 * large share of real devices the fallback *is* the feature. Give it a text field, or
 * inject a polyfill through `detector`.
 *
 * The preview itself is `aria-hidden`: a live camera frame has nothing to announce and
 * no audio to caption, so what a screen reader gets is the `role="status"` line, which
 * says whether scanning is running and reads out each accepted code.
 *
 * @example
 * <BarcodeScanner
 *     formats={["ean_13"]}
 *     onScan={({ rawValue }) => addToCart(rawValue)}
 *     footer={<small>Aponte para o código de barras da embalagem.</small>}
 *     unsupported={<ManualCodeInput onSubmit={addToCart} />}
 * />
 */
export declare function BarcodeScanner({ onScan, formats, paused, detector, intervalMs, repeatDelayMs, torch, aspectRatio, locale, footer, unsupported, onError, className, ...rest }: BarcodeScannerProps): JSX.Element;

export declare interface BarcodeScannerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_7> {
    /** Called for every accepted read — repeats of the same value are suppressed. */
    onScan: (result: BarcodeScanResult) => void;
    /** Symbologies to look for. Defaults to QR + EAN-13 + Code 128. */
    formats?: readonly BarcodeFormat[];
    /** Stop looking without releasing the camera — set it while a confirmation is open. */
    paused?: boolean;
    /** A decoder to use instead of the native one, for Safari and Firefox. */
    detector?: BarcodeDetectorLike;
    /** How often a frame is examined, in ms. Default 200. */
    intervalMs?: number;
    /** Ignore the same value again for this long, in ms. Default 2500. */
    repeatDelayMs?: number;
    /** Offer the torch toggle when the camera has a lamp. Default `true`. */
    torch?: boolean;
    /** Viewport aspect ratio, `width / height`. Default `4 / 3`. */
    aspectRatio?: number;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Under the viewport — an instruction, the code just read, a manual-entry link. */
    footer?: ReactNode;
    /**
     * Rendered instead of the camera when there is no decoder.
     *
     * Worth filling in: on iOS and Firefox this is the **only** thing the user sees, so
     * the fallback is usually a plain text field for typing the code.
     */
    unsupported?: ReactNode;
    /** A frame the engine refused to decode. Routine and usually transient. */
    onError?: (error: unknown) => void;
}

/** One decoded symbol, normalised. */
export declare interface BarcodeScanResult {
    /** The decoded payload — a GTIN, a URL, a Pix BR Code. */
    rawValue: string;
    /** Which symbology it was read as. `"unknown"` when the engine does not say. */
    format: BarcodeFormat;
    /** Box in source pixels, or `null` when the engine reports none. */
    boundingBox: DOMRectReadOnly | null;
    /** Corners in source pixels, clockwise from top-left. Empty when unreported. */
    cornerPoints: readonly BarcodePoint[];
}

/**
 * A ranked distribution: label, proportional bar, value, optional share.
 *
 * The most common chart on an admin panel, and the one the SDK kept sending
 * people to write by hand — `Progress` is a single bar and `Sparkline` is a time
 * series, so a "users per plan" block ended up reimplemented per screen, each
 * with its own CSS and its own `.sort()`.
 *
 * It is a **list**, not a picture: `<ul>` / `<li>` with the value written as
 * text, the bar `aria-hidden` behind it. A screen reader reads "Free, 128, 62%"
 * because that text is there, not because an `aria-label` restates a drawing.
 * Which is also why the label never sits on top of the bar — text over a tinted
 * fill has to be re-verified against that fill, and the SDK has been caught by
 * that twice.
 *
 * Bar width is relative to the **largest** row, so the biggest bar fills the
 * track; the percentage is the row's share of the **total**. They are different
 * numbers on purpose: a width scaled by the total leaves every bar short in a
 * long list, which is when the chart is needed most.
 *
 * Colors come from {@link useChartColors}, the same resolver every chart in the
 * SDK uses, so a theme that declares fewer series than the eight
 * `--tempest-chart-*` slots cycles within its own palette. Reading the tokens
 * through CSS `var()` could not do that: the count lives in
 * `--tempest-chart-count`, which CSS cannot use as a modulus, so a six-color
 * brand palette got the SDK's leftover defaults in rows seven and eight — the
 * exact regression that token exists to prevent. `palette.ts` imports nothing,
 * so this pulls no chart library into the slice.
 *
 * @example
 * <BarList
 *     items={[{ label: "Free", value: 128 }, { label: "Pro", value: 32 }]}
 *     valueFormatter={(n) => `${n} ativos`}
 *     showPercentage
 *     max={5}
 *     otherLabel="Outros"
 * />
 *
 * @param props - Items plus presentation.
 * @returns The list.
 */
export declare function BarList({ items, valueFormatter, showPercentage, sort, max, otherLabel, className, ...rest }: BarListProps): JSX.Element;

/** One entry of a {@link BarList}. */
export declare interface BarListItem {
    /** What the row is called. */
    label: string;
    /** The measured amount. */
    value: number;
    /** Override the bar colour. Defaults to the chart series token for its position. */
    color?: string;
}

export declare interface BarListProps extends Omit<HTMLAttributes<HTMLUListElement>, "children"> {
    /** The rows. Entries whose value is not finite are dropped. */
    items: readonly BarListItem[];
    /** Render the number. Defaults to the value as-is. */
    valueFormatter?: (value: number) => string;
    /** Show each row's share of the total next to its value. Default `false`. */
    showPercentage?: boolean;
    /** Ordering. Default `"desc"`, which is what a ranking means. */
    sort?: BarListSort;
    /** Keep at most this many rows. */
    max?: number;
    /**
     * Label for one aggregated row holding everything `max` cut off.
     *
     * Without it, `max` simply truncates. The aggregate row only appears when more
     * than one row was cut — collapsing a single row into "others" hides its name
     * for nothing.
     */
    otherLabel?: string;
}

/** One row, with everything the component needs to draw it. */
export declare interface BarListRow extends BarListItem {
    /** Share of the total, 0–100. */
    percentage: number;
    /** Bar width relative to the largest row, 0–100. */
    width: number;
    /** Position in the original palette cycle. */
    index: number;
}

/** How the list orders itself before drawing. */
export declare type BarListSort = "desc" | "asc" | "none";

/**
 * Decode a base64url string into bytes.
 *
 * WebAuthn transports every binary field as base64url (`-`/`_`, no padding)
 * because that is what survives JSON, while the DOM API insists on
 * `ArrayBuffer`. Getting this pair wrong — usually by feeding plain base64 to
 * `atob` and losing the last byte — is the classic broken-WebAuthn bug, which is
 * why the SDK owns it instead of leaving it to each app.
 *
 * This is the WebAuthn-facing name for {@link base64ToBytes}; the codec itself is
 * shared, so the padding rule has one implementation rather than three.
 *
 * @param value - Base64url text, with or without `=` padding.
 * @returns The decoded bytes.
 */
export declare function base64UrlToBytes(value: string): Uint8Array<ArrayBuffer>;

/**
 * Initial bearing (forward azimuth) from `origin` to `destination`, in degrees
 * clockwise from true north, normalized to `[0, 360)`. Useful for orienting a
 * heading arrow on a trajectory.
 *
 * @param origin - Start coordinate.
 * @param destination - End coordinate.
 * @returns Bearing in degrees, `[0, 360)`.
 */
export declare function bearingDeg(origin: Coordinate, destination: Coordinate): number;

/**
 * The Chromium-only `beforeinstallprompt` event. iOS Safari never fires it —
 * for those users the app falls back to manual "Add to Home Screen"
 * instructions. Ported into the SDK so consumers get the type without a global
 * augmentation.
 */
export declare interface BeforeInstallPromptEvent extends Event {
    /** Platforms the prompt can target (e.g. `["web", "android"]`). */
    readonly platforms: readonly string[];
    /** Resolves once the user accepts or dismisses the prompt. */
    readonly userChoice: Promise<{
        outcome: "accepted" | "dismissed";
        platform: string;
    }>;
    /** Shows the native install prompt. */
    prompt: () => Promise<void>;
}

/**
 * Convert a recording to 16-bit WAV, with no dependency.
 *
 * `MediaRecorder` cannot produce WAV — it emits Opus on Chromium and Firefox and AAC
 * on Safari — so a backend that insists on WAV has to be served either by a
 * server-side transcode or by this. It decodes through `AudioContext.decodeAudioData`,
 * which is the browser's own decoder for whatever container the recorder chose, then
 * re-encodes the PCM.
 *
 * !!! The cost is real: WAV is uncompressed, so the same voice note that is 40 KB in
 * Opus is roughly 500 KB here at 48 kHz stereo. `{ mono: true, sampleRate: 16000 }`
 * takes that to about 80 KB and is what a speech-to-text endpoint wants anyway.
 *
 * Resampling uses `OfflineAudioContext`, i.e. the browser's own resampler, rather
 * than a hand-rolled one — this is exactly the "we want the underlying call, not a
 * wrapper" case.
 *
 * @param blob - A recording from {@link createAudioRecorder}, or any decodable audio.
 * @param options - See {@link WavOptions}.
 * @returns A `Blob` of type `audio/wav`.
 * @throws When the environment has no Web Audio, or the blob cannot be decoded.
 */
export declare function blobToWav(blob: Blob, options?: WavOptions): Promise<Blob>;

/**
 * Fixed-bottom mobile tab bar. 3–5 items recommended. Pair with
 * `<Show below="md">` to render only on mobile.
 *
 * @example
 * <Show below="md">
 *     <BottomNavigation
 *         items={[
 *             { key: "home", label: "Início", icon: <Home /> },
 *             { key: "search", label: "Buscar", icon: <Search /> },
 *             { key: "profile", label: "Perfil", icon: <User /> },
 *         ]}
 *         value={tab}
 *         onChange={setTab}
 *     />
 * </Show>
 */
export declare function BottomNavigation({ items, value, onChange, showLabels, className, ...props }: BottomNavigationProps): JSX.Element;

export declare interface BottomNavigationItem {
    /** Unique identifier — used as React key and for value matching. */
    key: string;
    /** Visible label. */
    label: ReactNode;
    /** Icon rendered above the label. */
    icon?: ReactNode;
    /** Optional badge content rendered above the icon. */
    badge?: ReactNode;
    /** When true, the item is not selectable. */
    disabled?: boolean;
}

export declare interface BottomNavigationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
    items: BottomNavigationItem[];
    /** Selected key. */
    value: string;
    /** Called with the new selected key on click. */
    onChange: (key: string) => void;
    /** Show label below each icon. Default `true`. */
    showLabels?: boolean;
}

/**
 * Slide-up modal panel — mobile-style sheet anchored to the bottom edge.
 * Uses portal + safe-area padding + scroll lock.
 *
 * @example
 * <BottomSheet open={open} onClose={() => setOpen(false)} title="Filters">
 *     <FilterForm />
 * </BottomSheet>
 */
export declare function BottomSheet({ open, onClose, title, showHandle, dismissOnBackdrop, dismissOnEsc, className, children, ...props }: BottomSheetProps): ReactPortal | null;

export declare interface BottomSheetProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
    /** Controlled open state. */
    open: boolean;
    /** Fires when user dismisses (backdrop click, Esc, swipe). */
    onClose: () => void;
    /** Optional title rendered at the top of the sheet. */
    title?: ReactNode;
    /** Show a drag handle indicator at the top. Default `true`. */
    showHandle?: boolean;
    /** When `true`, clicking the backdrop closes the sheet. Default `true`. */
    dismissOnBackdrop?: boolean;
    /** When `true`, pressing Esc closes the sheet. Default `true`. */
    dismissOnEsc?: boolean;
    children?: ReactNode;
}

/**
 * Compute the axis-aligned bounding box that contains every point. Returns
 * `null` for an empty list (there is nothing to bound).
 *
 * @param points - Coordinates to enclose.
 * @returns The bounds, or `null` when `points` is empty.
 */
export declare function boundingBox(points: readonly Coordinate[]): GeoBounds | null;

/** Geometric center of a bounding box. */
export declare function boundsCenter(bounds: GeoBounds): Coordinate;

export declare interface BreadcrumbItem {
    label: ReactNode;
    href?: string;
    onClick?: () => void;
}

/**
 * Hierarchical navigation breadcrumbs. The last item is rendered as plain
 * text with `aria-current="page"`. Items with neither `href` nor `onClick`
 * also render as text (intermediate but non-clickable).
 */
export declare function Breadcrumbs({ items, separator, className }: BreadcrumbsProps): JSX.Element;

export declare interface BreadcrumbsProps {
    items: BreadcrumbItem[];
    separator?: ReactNode;
    className?: string;
}

/**
 * Breakpoint keys exposed by the SDK. Values mirror the CSS tokens
 * `--tempest-bp-xs|sm|md|lg|xl|2xl` defined in `styles/colors.css`.
 */
export declare type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";

export declare interface BreakpointHelpers {
    /** Current breakpoint key (the largest one whose min-width is matched). */
    current: Breakpoint;
    /** Window width in pixels at last update. `0` when SSR. */
    width: number;
    /** True when viewport width is `>=` the given breakpoint. */
    above: (bp: Breakpoint) => boolean;
    /** True when viewport width is `<` the given breakpoint. */
    below: (bp: Breakpoint) => boolean;
    /** Convenience flags mapping to typical device shapes. */
    isMobile: boolean;
    isTablet: boolean;
    isDesktop: boolean;
}

/** Pixel value paired with each breakpoint key. */
export declare const BREAKPOINTS: Record<Breakpoint, number>;

export { BrowserRouter }

/**
 * Join a base URL, an optional prefix and a request path into an absolute URL.
 *
 * `new URL(path, base)` on its own is wrong for an API client. It follows the
 * URL spec, where a path starting with `/` is absolute against the *origin* and
 * therefore discards whatever path the base carried: a client on
 * `https://api.example.com/api` asked for `/auth/login` reaches
 * `https://api.example.com/auth/login`, and every request 404s with nothing in
 * the config that looks wrong. This function resolves the path against the base
 * *path* instead, so the leading slash is a matter of taste rather than a
 * silent 404, and `baseURL` + `prefix` are interchangeable ways to say the same
 * thing.
 *
 * The prefix is applied at most once: a path that already opens with it — say
 * `"/api/auth/login"` under a `"/api"` prefix — is left alone, so a codebase
 * migrating to `prefix` can move its call sites one at a time. The check is per
 * segment, so `/api-keys` is not mistaken for an already-prefixed path.
 *
 * A path that is itself an absolute URL wins over all of this, which is how a
 * client reaches a second host (a signed upload endpoint, a CDN) without a
 * second client.
 *
 * @example
 * buildApiUrl("https://api.example.com", "/auth/login", { prefix: "/api" });
 * // "https://api.example.com/api/auth/login"
 *
 * buildApiUrl("https://api.example.com/api", "auth/login");
 * // "https://api.example.com/api/auth/login"
 *
 * @param baseURL - Absolute base URL, or a path relative to the current origin.
 * @param path - The request path, or an absolute URL to use as-is.
 * @param options - Optional prefix and query params.
 * @returns The absolute URL to fetch.
 * @throws When `baseURL` is relative and there is no `location` to resolve it.
 */
export declare function buildApiUrl(baseURL: string, path: string, options?: BuildApiUrlOptions): string;

/** Options accepted by {@link buildApiUrl}. */
export declare interface BuildApiUrlOptions {
    /**
     * Path segment every request is nested under, such as `"/api"`. Joined
     * after the path the `baseURL` already carries.
     */
    prefix?: string;
    /** Query params to append. `undefined` and `null` values are skipped. */
    params?: Record<string, string | number | boolean | undefined | null>;
}

/**
 * Order, truncate and measure the rows.
 *
 * Two different numbers come out of this, and conflating them is the classic bug
 * in a hand-written bar list:
 *
 * - `percentage` is the row's share of the **total**, which is what the label
 *   claims when it reads "32%".
 * - `width` is relative to the **largest** row, so the biggest bar fills the
 *   track. Scaling width by the total instead leaves every bar short in a list of
 *   many small values, and the chart stops being readable exactly when it has the
 *   most rows.
 *
 * The total counts positive values only. A negative amount draws no bar (a bar of
 * negative width does not exist) and reports 0%, but its number is still shown —
 * hiding the row would be worse than showing an odd one.
 *
 * @param options - The rows and how to reduce them.
 * @returns The rows to draw, in order.
 */
export declare function buildBarListRows(options: BuildBarListRowsOptions): BarListRow[];

/** What {@link buildBarListRows} needs to reduce a list into rows. */
export declare interface BuildBarListRowsOptions {
    /** The rows as given. */
    items: readonly BarListItem[];
    /** Ordering to apply. `"none"` keeps the caller's order. Default `"desc"`. */
    sort?: BarListSort;
    /** Keep at most this many rows. */
    max?: number;
    /** Aggregate what `max` cut into one row with this label. */
    otherLabel?: string;
}

/**
 * Builds an `intent://` URL that re-opens the current page inside Chrome on
 * Android. When Chrome is missing, the fallback URL points to the Play Store so
 * the user can still recover. Returns `null` outside Android.
 *
 * @returns The `intent://` URL, or `null` when not on Android or without a DOM.
 * @see https://developer.chrome.com/docs/multidevice/android/intents
 */
export declare function buildOpenInChromeIntent(): string | null;

/**
 * Primary action button with variants, sizes and a loading state that
 * preserves layout via an absolutely-positioned spinner.
 *
 * Variants: `primary` (solid), `secondary` (neutral), `danger`, `success`,
 * `ghost` (transparent), `soft` (tinted), `outline` (bordered), `link`.
 *
 * Sizes are density-aware — they read from `--tempest-control-height-*`
 * tokens which respond to the `data-tempest-density` attribute.
 */
export declare function Button({ variant, size, loading, fullWidth, iconOnly, pill, leftIcon, rightIcon, disabled, className, children, ...props }: ButtonProps): JSX.Element;

export declare interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: ButtonVariant;
    size?: ButtonSize;
    loading?: boolean;
    fullWidth?: boolean;
    /** Removes horizontal padding and forces a square footprint (use with `aria-label`). */
    iconOnly?: boolean;
    /** Pill-shaped border radius. */
    pill?: boolean;
    leftIcon?: ReactNode;
    rightIcon?: ReactNode;
}

export declare type ButtonSize = "xs" | "sm" | "md" | "lg" | "xl";

export declare type ButtonVariant = "primary" | "secondary" | "danger" | "success" | "ghost" | "soft" | "outline" | "link";

/**
 * Encode bytes as an unpadded base64url string.
 *
 * Normalises `ArrayBuffer` to a view — which is what the WebAuthn response
 * fields hand over — and delegates the encoding to {@link bytesToBase64}.
 *
 * @param value - Bytes to encode, as a view or a raw buffer.
 * @returns Base64url text, safe to put in JSON and in a URL.
 */
export declare function bytesToBase64Url(value: ArrayBuffer | Uint8Array): string;

/** Recommended `gcTime` presets (milliseconds). */
export declare const CACHE_TIME: {
    readonly SHORT: number;
    readonly DEFAULT: number;
    readonly LONG: number;
};

/**
 * How large the assets a page precached actually are.
 *
 * Prefers the stored `Content-Length`, because materializing a cached ONNX model
 * or WASM binary to learn its length would pull tens of megabytes into memory on
 * every measurement. When the header is missing the size is counted off the body
 * stream instead — chunk by chunk, keeping only one chunk alive at a time.
 *
 * The fallback exists because "no `Content-Length`" is not the rare case a
 * header-only reader assumes. A chunked transfer drops it, a proxy that
 * re-encodes drops it, and a cross-origin response only exposes it under CORS
 * rules — and in a report a `null` from any of those is indistinguishable from a
 * model nobody measured. FAMACHApp shipped 12 field runs with both model-size
 * columns empty for exactly this reason.
 */
/**
 * Byte size of a response sitting in a Cache Storage bucket.
 *
 * @param cacheName The cache bucket to look in.
 * @param url The request URL the response was stored under.
 * @returns The size in bytes, or `null` when Cache Storage is unavailable, the
 *   entry is absent, or the body cannot be read either.
 *
 * @example
 * ```typescript
 * const bytes = await cachedResponseBytes("app-models", "/models/detect.onnx");
 * console.log(bytes === null ? "—" : formatBytes(bytes)); // "12.0 MB"
 * ```
 */
export declare function cachedResponseBytes(cacheName: string, url: string): Promise<number | null>;

/** A cache-name matcher: a prefix string, a `RegExp`, or a predicate. */
export declare type CacheFilter = string | RegExp | ((name: string) => boolean);

/**
 * Main-thread helpers to inspect and clear the Cache Storage buckets a service
 * worker fills — for a "X MB cacheado" readout and a "limpar cache" action
 * (e.g. on logout). All guard `caches` so they no-op safely under SSR / older
 * browsers.
 */
/** Per-cache usage summary returned by {@link inspectCaches}. */
export declare interface CacheReport {
    /** The Cache Storage bucket name. */
    name: string;
    /** Number of cached responses. */
    entries: number;
    /** Approximate total bytes, or `null` when byte measurement was skipped. */
    bytes: number | null;
}

/**
 * Standalone month-grid date picker. Renders a header with the month/year and
 * prev/next buttons, a weekday row, and a 6x7 grid of day buttons. Selection and
 * the visible month can each be controlled or uncontrolled. Grid arithmetic uses
 * plain `Date` math — no external date libraries.
 *
 * Keyboard: arrow keys move focus by day (left/right) or week (up/down), and
 * Enter/Space selects the focused day.
 */
export declare function Calendar({ value, defaultValue, onChange, month, onMonthChange, minDate, maxDate, weekStartsOn, className, ...props }: CalendarProps): JSX.Element;

export declare interface CalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
    /** Controlled selected date. */
    value?: Date;
    /** Initial selected date for the uncontrolled case. */
    defaultValue?: Date;
    /** Called with the newly selected date. */
    onChange?: (date: Date) => void;
    /** Controlled visible month (any day within it). */
    month?: Date;
    /** Called when the visible month changes (prev/next). */
    onMonthChange?: (month: Date) => void;
    /** Earliest selectable date (inclusive). */
    minDate?: Date;
    /** Latest selectable date (inclusive). */
    maxDate?: Date;
    /** First column of the week — `0` Sunday (default) or `1` Monday. */
    weekStartsOn?: WeekStart;
}

/**
 * Convert `value` to `camelCase`.
 *
 * Splits on spaces, hyphens, underscores and other non-alphanumeric runs,
 * lowercases the first word, and capitalizes each subsequent word.
 *
 * @example
 * camelCase("hello world");   // "helloWorld"
 * camelCase("foo-bar_baz");   // "fooBarBaz"
 * camelCase("API response");  // "apiResponse"
 */
export declare function camelCase(value: string): string;

/** A classified camera error with a human-readable, English message. */
declare interface CameraStreamError {
    kind: CameraStreamErrorKind;
    message: string;
}

/** Classified reason a camera stream could not be acquired. */
declare type CameraStreamErrorKind = "unsupported" | "permission-denied" | "no-camera" | "in-use" | "insecure" | "unknown";

/** Lifecycle status of the camera stream. */
declare type CameraStreamStatus = "idle" | "loading" | "ready" | "error";

/**
 * Conditionally render based on an access check. Renders `children` when the
 * action is allowed and `fallback` when it is denied. While an async check is
 * pending it renders `pending`, which defaults to `fallback`.
 *
 * @example
 * ```tsx
 * <Can action="create" resource="posts" fallback={<p>No access</p>}>
 *   <NewPostButton />
 * </Can>
 * ```
 *
 * @example
 * ```tsx
 * <Can
 *   action="read"
 *   resource="finance"
 *   fallback={<p>No access</p>}
 *   pending={<Spinner />}
 * >
 *   <FinancePanel />
 * </Can>
 * ```
 */
export declare function Can({ action, resource, params, children, fallback, pending }: CanProps): JSX.Element;

/**
 * Arguments describing the access check to perform.
 */
export declare interface CanParams {
    /** The action being attempted (e.g. `"create"`, `"read"`, `"delete"`). */
    action: string;
    /** The resource the action targets (e.g. `"posts"`). Optional for global actions. */
    resource?: string;
    /** Arbitrary extra context an access-control strategy may inspect. */
    params?: Record<string, unknown>;
}

export declare interface CanProps extends CanParams {
    /** Rendered when the action is allowed. */
    children: ReactNode;
    /** Rendered when the action is denied. Defaults to nothing. */
    fallback?: ReactNode;
    /**
     * Rendered while an async check is still in flight. Defaults to
     * {@link fallback}, which keeps the pre-existing behaviour.
     *
     * Worth setting whenever `fallback` says something denial-shaped: without
     * it, a permission that resolves over the network flashes "no access" to
     * someone who has it. `pending={null}` renders nothing until the answer
     * lands; `pending={<Spinner />}` says why the screen is waiting.
     */
    pending?: ReactNode;
}

/**
 * Detailed result of an access check. Use the bare `boolean` form when no
 * reason is needed, or this object to surface *why* access was denied.
 */
export declare interface CanResult {
    /** Whether the action is permitted. */
    can: boolean;
    /** Human-readable explanation, typically present when `can` is `false`. */
    reason?: string;
}

/**
 * Uppercase the first character of `value`, leaving the rest untouched.
 *
 * @example
 * capitalize("hello world"); // "Hello world"
 * capitalize("");            // ""
 */
export declare function capitalize(value: string): string;

/**
 * Card container with optional header (title + actions) and footer slot.
 * Use `flush` when you need to host content (tables, lists) without inner padding.
 * Use `interactive` for clickable cards — adds hover lift and focus ring.
 */
export declare function Card({ title, actions, footer, flush, interactive, elevation, className, children, ...props }: CardProps): JSX.Element;

export declare type CardElevation = "flat" | "default" | "raised" | "elevated";

export declare interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
    title?: ReactNode;
    actions?: ReactNode;
    footer?: ReactNode;
    flush?: boolean;
    /** Hoverable card — adds elevation lift, cursor pointer and focus ring. */
    interactive?: boolean;
    /** Visual elevation level. Defaults to `default` (subtle shadow + border). */
    elevation?: CardElevation;
}

/**
 * Horizontal content slider showing one slide at a time.
 *
 * - Track translates by the active index (`translateX(-index * 100%)`).
 * - Prev/next arrows (disabled at the ends unless `loop`); dot indicators jump.
 * - Controlled (`index`) or uncontrolled (`defaultIndex`).
 * - Arrow Left/Right on the focused region navigates.
 *
 * @example
 * <Carousel loop>
 *     <img src="/1.jpg" alt="" />
 *     <img src="/2.jpg" alt="" />
 *     <img src="/3.jpg" alt="" />
 * </Carousel>
 */
export declare function Carousel({ children, loop, showArrows, showDots, index, defaultIndex, onIndexChange, className, ...props }: CarouselProps): JSX.Element;

export declare interface CarouselProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Slides — one rendered at a time. */
    children: ReactNode[];
    /** Wrap around at the ends instead of stopping. Default `false`. */
    loop?: boolean;
    /** Show prev/next arrow buttons. Default `true`. */
    showArrows?: boolean;
    /** Show dot indicators. Default `true`. */
    showDots?: boolean;
    /** Controlled active index. */
    index?: number;
    /** Initial index for uncontrolled use. Default `0`. */
    defaultIndex?: number;
    /** Called whenever the active index changes. */
    onIndexChange?: (index: number) => void;
}

export declare type Catalog = Record<string, Messages>;

/**
 * Center children horizontally, vertically, or both. Flex-based; works with
 * any child size. Pair with `minHeight` (or set parent height) when
 * centering vertically.
 *
 * @example
 * <Center axis="both" minHeight="100vh">
 *     <Spinner />
 * </Center>
 */
export declare function Center({ axis, minHeight, fullWidth, className, style, children, ...props }: CenterProps): JSX.Element;

export declare type CenterAxis = "both" | "horizontal" | "vertical";

export declare interface CenterProps extends HTMLAttributes<HTMLDivElement> {
    /** Which axis to center on. Default `"both"`. */
    axis?: CenterAxis;
    /** Fixed height for the container. Numbers map to `${n}px`; strings pass through. Useful when centering inside an unsized parent. */
    minHeight?: number | string;
    /** When `true` (default), takes up `100%` width of the parent. */
    fullWidth?: boolean;
    children?: ReactNode;
}

export declare const CEPInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange"> & {
    value?: string;
    onChange?: (value: string) => void;
} & RefAttributes<HTMLInputElement>>;

/** A `var(--tempest-chart-…)` reference, so the value follows the active theme. */
export declare type ChartColorToken = string;

/**
 * A message thread: grouped by author and by day, own messages on one side, with
 * delivery state, a typing indicator and an optional composer.
 *
 * Presentational and controlled, like the rest of the SDK: it takes a list and
 * emits intent (`onSend`, `onRetry`). Where messages come from — REST, the SDK's
 * `createWebSocket`, an SSE stream — and how an optimistic insert is done stay with
 * the app, because those differ per backend and a component that assumed one would
 * be wrong for most.
 *
 * It works as a comment thread too: that is the same component with
 * `currentUserId` set and no `typing`.
 *
 * @example
 * <Chat
 *     messages={messages}
 *     currentUserId={me.id}
 *     typing={typingNames}
 *     onSend={(text) => send({ text })}
 *     onRetry={(message) => resend(message.id)}
 * />
 */
export declare function Chat({ messages, currentUserId, onSend, onRetry, typing, renderAvatar, header, emptyState, groupWindowMs, locale, now, placeholder, composerActions, composerDisabled, onSendError, onReact, messageActions, onQuoteClick, className, ...rest }: ChatProps): JSX.Element;

/** One attachment on a message. */
export declare interface ChatAttachment {
    /** Decides how it renders: a picture, a player, a voice note, a download row. */
    kind: ChatAttachmentKind;
    /** Where the bytes are. A blob URL works for a message still uploading. */
    url: string;
    /** File name, shown for `"file"` and used as the download name. */
    name?: string;
    /** MIME type, when the app knows it. */
    mimeType?: string;
    /** Size in bytes, shown next to a file. */
    sizeBytes?: number;
    /** Duration in ms, for audio, voice and video. */
    durationMs?: number;
    /** Poster for a video, or a smaller copy of an image. */
    thumbnailUrl?: string;
    /**
     * Normalised peaks, `0`–`1`, for a voice note.
     *
     * A voice note without one is a grey rectangle: the waveform is what tells
     * somebody whether this is a word or a two-minute monologue.
     */
    waveform?: readonly number[];
    /** Alternative text for an image. */
    alt?: string;
}

/** What a bubble can carry besides text. */
export declare type ChatAttachmentKind = "image" | "video" | "audio" | "voice" | "file";

/**
 * One message bubble.
 *
 * Everything a messenger needs on a single message lives here, because every one
 * of these was a thing each app rebuilt on top of a text-only bubble: the reply
 * stub, attachments, reactions, per-recipient ticks, the actions menu, and the
 * tombstone of a deleted message.
 *
 * @param props - The message and its handlers.
 * @returns The bubble, wrapped in a context menu when actions are given.
 */
export declare function ChatBubble({ message, own, locale, onRetry, onReact, messageActions, onQuoteClick, }: ChatBubbleProps): JSX.Element;

export declare interface ChatBubbleProps {
    /** The message this bubble renders. */
    message: ChatMessage;
    /** Whether it belongs to the current user — side, colour and ticks. */
    own: boolean;
    /** Locale for labels. */
    locale: "pt-BR" | "en";
    /** Retry handler for a `"failed"` message. */
    onRetry?: (message: ChatMessage) => void;
    /** Toggles a reaction. Receives the emoji that was pressed. */
    onReact?: (message: ChatMessage, emoji: string) => void;
    /** Per-message actions, opened by right click, long press or the ⋮ button. */
    messageActions?: (message: ChatMessage) => ContextMenuItem[];
    /** Called when the quote stub is activated — scroll to the quoted message. */
    onQuoteClick?: (message: ChatMessage) => void;
}

/**
 * The message field of a thread: a textarea that grows with its content, sends on
 * `Enter` and keeps `Shift+Enter` for a newline.
 *
 * Uncontrolled on purpose. A chat draft changes on every keystroke, and lifting
 * that into app state re-renders the whole thread per character — the one place
 * where "controlled by default" costs something visible. Apps that need the draft
 * (a persisted composer, a slash-command menu) read it from `onChange` or drive it
 * through the ref.
 *
 * @example
 * <ChatComposer onSend={(text) => api.post("/messages", { body: { text } })} />
 */
export declare const ChatComposer: ForwardRefExoticComponent<ChatComposerProps & RefAttributes<ChatComposerHandle>>;

/** Imperative handle, so a thread can focus the field after retrying a message. */
export declare interface ChatComposerHandle {
    focus: () => void;
    /** Replace the draft — used to put a failed message back in the field. */
    setValue: (text: string) => void;
}

export declare interface ChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_4> {
    /** Called with the trimmed text. The field clears only when this does not throw. */
    onSend: (text: string) => void | Promise<void>;
    /** Locale for the placeholder and the send label. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Rendered to the left of the send button — an attach button, an emoji picker. */
    actions?: ReactNode;
    /** Largest height the field grows to, in lines. Default 6. */
    maxRows?: number;
    /** Send label. Defaults to the locale string. */
    sendLabel?: string;
    /**
     * Called when `onSend` rejects. The draft is kept either way.
     *
     * Without it the rejection is swallowed after the draft is preserved, because
     * the alternative is worse: re-throwing out of a DOM event handler surfaces as
     * an unhandled promise rejection — console noise for the developer, a hit in
     * whatever crash reporter the app runs, and nothing the user can act on. The
     * visible signal is the text still sitting in the field; wire this to a toast
     * to say why.
     */
    onError?: (error: unknown) => void;
}

/** A date heading between runs. */
export declare interface ChatDay {
    kind: "day";
    key: string;
    /** Midnight of that local day, epoch ms — the label is formatted by the view. */
    date: number;
}

/** One entry in a thread. */
export declare interface ChatMessage {
    /** Stable identity. Used as the React key and by `onRetry`. */
    id: string;
    /**
     * What was said. A node, so an app can render a link, an image or a quote.
     *
     * Optional, because a message can be all attachment, or be a tombstone: a
     * deleted message has no body to show, and requiring one made every app
     * invent a placeholder string for the state the component now owns.
     */
    body?: ReactNode;
    /** Who said it. Compared against `currentUserId` to decide sides. */
    authorId: string;
    /** Display name. Falls back to `authorId` in the header of a run. */
    authorName?: string;
    /** Epoch milliseconds. */
    sentAt: number;
    /**
     * Delivery state of an outgoing message.
     *
     * `"failed"` is the one that matters: without it an app has to invent its own
     * way to say "this never left", and the user re-types a message that is
     * sitting right there.
     */
    status?: "sending" | "sent" | "read" | "failed";
    /**
     * Per-recipient delivery. Takes precedence over `status` for the ticks.
     *
     * Use it in a group, where "delivered to all" and "read by all" are different
     * states and `status` can only say one thing.
     */
    receipt?: ChatReceipt;
    /** Media, voice notes and documents carried by this message. */
    attachments?: readonly ChatAttachment[];
    /** The message this one replies to. */
    quote?: ChatQuote;
    /** Emoji reactions, already tallied by the app. */
    reactions?: readonly ChatReaction[];
    /**
     * The message was deleted — it renders as a tombstone.
     *
     * A state, not a `body` the app swaps for a string: as a state the quote of
     * it can be blanked too, and every app stops writing its own wording.
     */
    deleted?: boolean;
    /** The message was edited after it was sent. */
    edited?: boolean;
    /** Anything the app wants to carry through to its own renderers. */
    data?: Record<string, unknown>;
}

export declare interface ChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_3> {
    /** The thread, **oldest first**. Never reordered by the component. */
    messages: readonly ChatMessage[];
    /** Author id treated as "own" — decides side, colour and status ticks. */
    currentUserId?: string;
    /** Renders the composer when given. Receives the trimmed text. */
    onSend?: (text: string) => void | Promise<void>;
    /** Enables the retry control on a `"failed"` message. */
    onRetry?: (message: ChatMessage) => void;
    /** Names currently typing. One, two or a count is phrased for you. */
    typing?: readonly string[];
    /** Avatar for the first message of a run — an `<Avatar>`, an `<Icon>`. */
    renderAvatar?: (message: ChatMessage) => ReactNode;
    /** Rendered above the thread, inside the panel. */
    header?: ReactNode;
    /** Shown when there are no messages. */
    emptyState?: ReactNode;
    /** Gap that still keeps consecutive messages in one run. Default 5 min. */
    groupWindowMs?: number;
    /** Locale for labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Reference instant for "Hoje"/"Ontem". Default: now, at render time. */
    now?: number;
    /** Placeholder for the composer. */
    placeholder?: string;
    /** Extra controls inside the composer, before the send button. */
    composerActions?: ReactNode;
    /** Disable the composer — no permission, thread archived, offline. */
    composerDisabled?: boolean;
    /** Called when `onSend` rejects. The draft stays in the field either way. */
    onSendError?: (error: unknown) => void;
    /**
     * Toggles a reaction on a message. Enables the reaction chips.
     *
     * Called with the emoji that was pressed, including one the user already
     * reacted with: reacting again clears it, rather than stacking a second copy.
     * The app owns that rule — the component only reports the press.
     */
    onReact?: (message: ChatMessage, emoji: string) => void;
    /**
     * Per-message actions: reply, forward, star, edit, delete.
     *
     * Returns the items for one message, opened by right click, by long press on
     * touch, and by a `⋮` button on the bubble. Buttons painted on every bubble
     * turn a conversation into a toolbar, which is why this is a menu.
     */
    messageActions?: (message: ChatMessage) => ContextMenuItem[];
    /** Called when a reply stub is activated — scroll to the quoted message. */
    onQuoteClick?: (message: ChatMessage) => void;
}

/**
 * The stub of the message being replied to, shown above the body.
 *
 * `revoked` is not decoration: deleting the quoted message has to blank the
 * quoted text, or it leaks through everyone who replied to it.
 */
export declare interface ChatQuote {
    /** Id of the quoted message, so the app can scroll to it. */
    messageId: string;
    /** Who wrote it. */
    senderName?: string;
    /** A short piece of what it said. The component never truncates for you. */
    excerpt?: string;
    /** What the quoted message was, when it was not text. */
    kind?: "text" | ChatAttachmentKind;
    /** The quoted message was deleted — the excerpt is not shown. */
    revoked?: boolean;
}

/** One emoji on a message, with its tally. */
export declare interface ChatReaction {
    /** The emoji itself. */
    emoji: string;
    /** How many people reacted with it. */
    count: number;
    /** Whether the current user is one of them — the chip reads as pressed. */
    reacted?: boolean;
    /** Who reacted, for the chip's tooltip. */
    names?: readonly string[];
}

/**
 * Per-recipient delivery, which is what a group needs.
 *
 * `status` is a boolean for the sender: it cannot say "delivered to everyone"
 * versus "read by everyone", and only the second one turns the ticks blue.
 */
export declare interface ChatReceipt {
    /** How many recipients have received it. */
    deliveredTo: number;
    /** How many have read it. */
    readBy: number;
    /** How many recipients there are. */
    totalRecipients: number;
}

/**
 * What the ticks on an outgoing message say.
 *
 * `"read"` is the only one that turns them blue, and in a group that means
 * **everyone** has read it — the distinction `status: "read"` cannot make.
 */
export declare type ChatReceiptState = "sending" | "sent" | "delivered" | "read" | "failed";

/** A run of consecutive messages from one author, under one day. */
export declare interface ChatRun {
    kind: "run";
    /** `${authorId}-${first message id}` — stable across re-renders. */
    key: string;
    authorId: string;
    authorName?: string;
    /** Whether this run belongs to the current user. */
    own: boolean;
    messages: ChatMessage[];
}

export declare type ChatSection = ChatDay | ChatRun;

/**
 * Accessible checkbox. Supports a tri-state via `indeterminate` and pairs the
 * input with a label/description column for forms.
 */
export declare const Checkbox: ForwardRefExoticComponent<CheckboxProps & RefAttributes<HTMLInputElement>>;

export declare interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
    label?: ReactNode;
    description?: ReactNode;
    /** Render the box in the indeterminate state regardless of `checked`. */
    indeterminate?: boolean;
    wrapperClassName?: string;
}

/**
 * Multi-value input. Type a value and press Enter (or comma / Tab) to push a
 * chip. Backspace on empty input removes the last chip.
 *
 * Name the field with `label` (associated through `htmlFor`) or, when the label
 * lives elsewhere in the layout, with `aria-label`. The placeholder is not an
 * accessible name — it disappears as soon as the first chip is added.
 */
export declare function ChipInput({ value, onChange, label, placeholder, helperText, error, commitKeys, normalize, className, id, "aria-label": ariaLabel, }: ChipInputProps): JSX.Element;

export declare interface ChipInputProps {
    value: string[];
    onChange: (next: string[]) => void;
    label?: string;
    placeholder?: string;
    helperText?: string;
    error?: string;
    /** Id for the inner input. Generated when omitted. */
    id?: string;
    /**
     * Accessible name for the inner input when there is no visible `label`.
     * Without either, screen readers announce an unnamed text field.
     */
    "aria-label"?: string;
    /** Keys that commit the current draft as a chip. Default: Enter, comma, Tab. */
    commitKeys?: string[];
    /** Lowercase + trim each chip + dedupe. Default: true. */
    normalize?: boolean;
    className?: string;
}

/**
 * Split a list into consecutive chunks of at most `size` items.
 *
 * The final chunk may be smaller than `size`. An empty input yields `[]`.
 *
 * @param items - The list to split.
 * @param size - Maximum chunk length; must be `>= 1`.
 * @throws {RangeError} When `size` is less than `1`.
 *
 * @example
 * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
 *
 * @example
 * chunk([], 3); // []
 */
export declare function chunk<T>(items: T[], size: number): T[][];

/**
 * Clamp `value` between `min` and `max` (inclusive).
 *
 * @example
 * clamp(120, 0, 100); // 100
 * clamp(-5, 0, 100);  // 0
 * clamp(42, 0, 100);  // 42
 */
export declare function clamp(value: number, min: number, max: number): number;

/** Clamp a latitude into the valid `[-90, 90]` range. */
export declare function clampLatitude(latitude: number): number;

/**
 * Map a thrown WebAuthn failure onto a {@link PasskeyError}.
 *
 * The secure-context check runs first for the same reason it does in the media
 * classifier: over plain HTTP the whole API is absent or refuses, and reporting
 * "not supported" sends a developer hunting for a polyfill for something an
 * `https://` URL fixes.
 *
 * @param error - Whatever `navigator.credentials` rejected with.
 * @param ceremony - Which ceremony was running, for the message.
 * @returns The classified error, ready to throw or to show.
 */
export declare function classifyPasskeyError(error: unknown, ceremony: PasskeyCeremony): PasskeyError;

declare type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];

/**
 * Remove the shared regions and cancel pending cleanups.
 *
 * For test teardown and for a micro-frontend being unmounted from a page it does
 * not own. Regular apps never need it — two empty hidden `div`s cost nothing, and
 * tearing them down while another component still announces would lose messages.
 */
export declare function clearAnnouncer(): void;

/**
 * Delete Cache Storage buckets whose name passes `filter` (all of them when no
 * filter is given).
 *
 * @param filter - Which caches to delete.
 * @returns The names of the caches that were deleted.
 *
 * @example
 * await clearCaches("tempest-"); // drop every SDK-managed cache on logout
 */
export declare function clearCaches(filter?: CacheFilter): Promise<string[]>;

/**
 * Wraps its children in a `<div>` and invokes `onOutside` whenever a
 * `mousedown` or `touchstart` event occurs outside that subtree.
 *
 * Useful for dismissing popovers, dropdowns and menus on outside interaction.
 * Listeners are attached to `document` on mount and removed on unmount.
 *
 * @param props - The click-outside props, plus any `<div>` attributes.
 * @returns The wrapper element containing the children.
 */
export declare function ClickOutside({ onOutside, children, ...props }: ClickOutsideProps): ReactNode;

export declare interface ClickOutsideProps extends HTMLAttributes<HTMLDivElement> {
    /** Called when a pointer event lands outside the wrapped subtree. */
    onOutside: (event: MouseEvent | TouchEvent) => void;
    /** Content wrapped by the outside-click boundary. */
    children: ReactNode;
}

/**
 * Tiny classnames helper. Accepts strings, falsy values and nested arrays.
 *
 * @param values - Class entries, conditionally truthy.
 * @returns A single space-joined class string.
 */
export declare function cn(...values: ClassValue[]): string;

export declare const CNPJInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange"> & {
    value?: string;
    onChange?: (value: string) => void;
} & RefAttributes<HTMLInputElement>>;

/**
 * A read-only code sample: syntax colours, optional line numbers, copy button.
 *
 * The `<pre>` is always focusable. A code block is scrollable and holds nothing
 * focusable inside, so without a tab stop a keyboard user can see there is more
 * code past the edge and has no way to reach it. It is the one scroll container
 * where the stop is unconditional rather than measured — a code sample is
 * expected to be reachable, read and selected on its own.
 *
 * Colours come from an approximate scanner, not a parser — see {@link tokenize}.
 *
 * @example
 * <CodeBlock code={snippet} language="ts" filename="src/main.ts" showLineNumbers />
 * <CodeBlock code={log} language="bash" maxHeight={280} />
 */
export declare function CodeBlock({ code, language, filename, showLineNumbers, highlightLines, copyable, maxHeight, wrap, label, className, ...rest }: CodeBlockProps): JSX.Element;

export declare interface CodeBlockProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** The source to display. Leading and trailing blank lines are trimmed. */
    code: string;
    /** Grammar name or alias (`ts`, `bash`, `json`…). Unknown values render plain. */
    language?: string;
    /** Shown in the header, usually a file path. */
    filename?: ReactNode;
    /** Number the lines. Default `false`. */
    showLineNumbers?: boolean;
    /** 1-based line numbers to mark as the point of the snippet. */
    highlightLines?: readonly number[];
    /** Offer a copy button. Default `true`. */
    copyable?: boolean;
    /** Cap the height in px or any CSS length; the body scrolls past it. */
    maxHeight?: number | string;
    /** Wrap long lines instead of scrolling sideways. Default `false`. */
    wrap?: boolean;
    /**
     * Accessible name for the code region. Defaults to naming the language, and
     * to the filename when there is one.
     */
    label?: string;
}

/** Languages the tokenizer knows. Anything else renders as plain text. */
export declare type CodeLanguage = "typescript" | "javascript" | "tsx" | "jsx" | "json" | "css" | "html" | "bash" | "python" | "sql" | "plain";

/**
 * A single expand/collapse region — a lighter alternative to `Accordion` for
 * one toggleable block. The trigger is a `<button aria-expanded aria-controls>`
 * wired to a content region sharing the same id; the region is `hidden` while
 * closed. Works controlled (`open` + `onOpenChange`) or uncontrolled
 * (`defaultOpen`).
 *
 * @param props - {@link CollapsibleProps}.
 * @returns The collapsible container.
 */
export declare function Collapsible({ open, defaultOpen, onOpenChange, trigger, className, children, ...props }: CollapsibleProps): JSX.Element;

export declare interface CollapsibleProps extends HTMLAttributes<HTMLDivElement> {
    /** Controlled open state. When provided the component is controlled. */
    open?: boolean;
    /** Initial open state for the uncontrolled variant. Default `false`. */
    defaultOpen?: boolean;
    /** Fired with the next open state whenever the trigger is activated. */
    onOpenChange?: (open: boolean) => void;
    /** Content rendered inside the trigger button. */
    trigger: ReactNode;
    /** Collapsible content, hidden while closed. */
    children: ReactNode;
}

/** A generated tint scale, keyed by step. */
export declare type ColorScale = Record<ScaleStep, string>;

/** Options for {@link createColorScale}. */
declare interface ColorScaleOptions {
    /**
     * Pin step `500` to the input color's exact lightness. Default `true`.
     *
     * Right for a **brand** color: the hex a designer hands over is the one the
     * buttons must be. Wrong for a **neutral**: nobody checks that `gray-500` is
     * exactly the input, while everybody notices that a surface stopped being
     * near-white — anchoring rescales both halves around the input and compresses
     * exactly the range a neutral needs wide. With `false`, the ramp keeps the
     * tuned lightness curve and the input only contributes hue and chroma (a warm
     * or cool neutral, as asked).
     */
    anchor?: boolean;
    /**
     * Use the neutral lightness curve instead of the brand one. Default `false`.
     *
     * The neutral curve is wider at both ends, which is what keeps
     * `text-muted`-on-`surface-3` above AA. Implies the ramp is meant for
     * surfaces, borders and text rather than for an action color.
     */
    neutral?: boolean;
}

/**
 * Combobox — text input with a filterable dropdown of options.
 *
 * Selecting an option fires `onChange(value)`. Typing filters the list.
 * Keyboard: ArrowUp/ArrowDown to navigate, Enter to select, Esc to close.
 */
export declare function Combobox({ options, value, onChange, label, placeholder, helperText, error, disabled, filter, emptyMessage, className, }: ComboboxProps): JSX.Element;

export declare interface ComboboxOption {
    value: string;
    label: string;
    disabled?: boolean;
}

export declare interface ComboboxProps {
    options: ComboboxOption[];
    value: string;
    onChange: (value: string) => void;
    label?: string;
    placeholder?: string;
    helperText?: string;
    error?: string;
    disabled?: boolean;
    /** Custom filter — return true to keep the option. Default is case-insensitive substring match on label. */
    filter?: (option: ComboboxOption, query: string) => boolean;
    /** Message shown when no option matches. */
    emptyMessage?: string;
    className?: string;
}

/**
 * A ⌘K-style command palette: an overlay dialog with a search input that
 * substring-filters items by label and keywords, groups results, and supports
 * full keyboard navigation (Arrow up/down, Enter, Escape). Traps focus while
 * open.
 */
export declare function Command({ open, onOpenChange, items, placeholder, emptyMessage, className, }: CommandProps): ReactPortal | null;

export declare interface CommandItem {
    /** Stable unique identifier for the item. */
    id: string;
    /** Human-readable label shown in the list and matched against the query. */
    label: string;
    /** Optional group heading; items sharing a group are rendered together. */
    group?: string;
    /** Extra terms matched against the query in addition to `label`. */
    keywords?: string[];
    /** Invoked when the item is chosen (click or Enter on the active row). */
    onSelect: () => void;
    /** Optional leading icon. */
    icon?: ReactNode;
}

export declare interface CommandProps {
    /** Whether the palette is visible. */
    open: boolean;
    /** Called with the next open state (Escape, selection, backdrop click). */
    onOpenChange: (open: boolean) => void;
    /** Candidate items to filter and display. */
    items: CommandItem[];
    /** Placeholder for the search input. */
    placeholder?: string;
    /** Rendered when no item matches the current query. */
    emptyMessage?: ReactNode;
    /** Forwarded to the dialog element. */
    className?: string;
}

/**
 * Compare two arbitrary cell values with stable, type-aware ordering.
 *
 * The comparator every table in the SDK sorts with, so `DataTable` and
 * `VirtualTable` agree on what "sorted" means. The type-aware branches exist
 * because the naive `String(a) < String(b)` gets the two most common cases wrong:
 * numbers would sort `10` before `9`, and dates would sort by their formatted
 * text. Strings fall back to `localeCompare` with `numeric: true`, so `"item 2"`
 * lands before `"item 10"`.
 *
 * `null` and `undefined` sort first, together — a missing value is not smaller
 * than another missing value.
 *
 * @param a - First value.
 * @param b - Second value.
 * @returns Negative when `a < b`, positive when `a > b`, zero when equal.
 */
export declare function compareValues(a: unknown, b: unknown): number;

/**
 * Typed `localStorage` wrapper that gzips what it writes.
 *
 * {@link createJsonStorage} with {@link compressedStorageCodec}, so it is the
 * same implementation as {@link storage} and genuinely interchangeable with it —
 * `get`, `set` and `remove`, differing only in how the value is encoded. It used
 * to be a hand-written copy that had no `remove`, which made that promise false
 * for anybody who took the docstring at its word.
 *
 * When compression itself fails the value is written as plain JSON rather than
 * dropped: a slightly larger record still loads, an absent one does not. Only a
 * storage-level failure — quota, blocked storage — loses the write.
 */
export declare const compressedStorage: JsonStorage;

/**
 * Codec pair for {@link useLocalStorage}, so a compressed key gets the hook's
 * cross-tab sync and SSR guard for free.
 *
 * @example
 * const [save, setSave] = useLocalStorage("save", EMPTY_SAVE, compressedStorageCodec);
 */
export declare const compressedStorageCodec: StorageCodec;

/**
 * Serialize a value to a gzipped, base64 string carrying the format marker.
 *
 * Base64 costs a third more characters than the raw compressed bytes, and
 * `localStorage` bills two bytes per character on top of that. Packing the
 * bytes into UTF-16 code units directly would be denser, but lone surrogates
 * survive neither every storage implementation nor a JSON round-trip, and a
 * save that decodes to garbage is far worse than one that is bigger. Even with
 * that overhead a typical JSON document lands well under a third of its
 * uncompressed size.
 *
 * @typeParam T - The value being stored.
 * @param value - Any JSON-serializable value.
 * @returns The encoded string, ready for `localStorage`.
 */
export declare function compressToString<T>(value: T): string;

/**
 * Conditionally wraps its children with `wrapper`.
 *
 * Renders `wrapper(children)` when `condition` is `true`, otherwise renders the
 * children unchanged. Avoids duplicating a subtree just to add an optional
 * wrapping element (e.g. a link, tooltip or boundary).
 *
 * @param props - The conditional-wrapper props.
 * @returns The wrapped children when `condition` is `true`, else the children.
 */
export declare function ConditionalWrapper({ condition, wrapper, children, }: ConditionalWrapperProps): ReactNode;

export declare interface ConditionalWrapperProps {
    /** When `true`, the children are passed through `wrapper`. */
    condition: boolean;
    /** Wrapping function applied to the children when `condition` is `true`. */
    wrapper: (children: ReactNode) => ReactNode;
    /** Content that may be wrapped. */
    children: ReactNode;
}

/**
 * Quick confirmation prompt built on top of {@link Modal}. Use for destructive
 * actions with `variant="danger"`.
 */
export declare function ConfirmDialog({ open, title, description, confirmLabel, cancelLabel, variant, loading, onConfirm, onCancel, }: ConfirmDialogProps): JSX.Element;

export declare interface ConfirmDialogProps {
    open: boolean;
    title: ReactNode;
    description?: ReactNode;
    confirmLabel?: string;
    cancelLabel?: string;
    variant?: "primary" | "danger";
    loading?: boolean;
    onConfirm: () => void | Promise<void>;
    onCancel: () => void;
}

/** Options accepted by {@link ModalsApi.confirm}. */
export declare interface ConfirmModalOptions {
    /** Header title. */
    title?: ReactNode;
    /** Prompt message rendered in the dialog body. */
    message: ReactNode;
    /** Confirm button label. Default `Confirmar`. */
    confirmLabel?: string;
    /** Cancel button label. Default `Cancelar`. */
    cancelLabel?: string;
    /** Render the confirm button in the danger variant. */
    danger?: boolean;
    /** Called when the user confirms. */
    onConfirm?: () => void | Promise<void>;
    /** Called when the user cancels or dismisses. */
    onCancel?: () => void;
}

/** Default sink that writes to the browser console. */
export declare const consoleSink: LoggerSink;

/**
 * Dev-friendly adapter that logs every call to `console`. Use as a default
 * before plugging the real provider (Sentry / Datadog / PostHog).
 */
export declare const consoleTelemetryAdapter: TelemetryAdapter;

/**
 * Page-level horizontal container with a max-width preset and responsive
 * side padding (`space-4` mobile / `space-6` tablet / `space-8` desktop).
 */
export declare function Container({ size, className, children, ...props }: ContainerProps): JSX.Element;

export declare interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
    size?: ContainerSize;
}

export declare type ContainerSize = "sm" | "md" | "lg" | "xl" | "full";

/**
 * Context menu — right click, long press, or click.
 *
 * - Opens at the pointer on `contextmenu`, and on a long press from touch or pen,
 *   which is the gesture those pointers have instead of a right click. `trigger`
 *   adds or replaces the mouse gesture; the long press is independent of it.
 * - Clamped inside the viewport after it mounts, so a menu opened near an edge
 *   moves in rather than overflowing — measured before the clamp: a 180 px menu
 *   opened at `x=235` in a 320 px window ran 95 px off screen, cutting the right
 *   edge off every label.
 * - Rendered through a {@link Portal} so it escapes parent overflow/stacking
 *   contexts.
 * - Closes on outside click, Escape, scroll, resize, or item selection.
 * - Arrow Up/Down move focus across selectable items and wrap; Home/End jump to
 *   the ends; Enter activates the focused item. The menu itself takes focus when
 *   it opens, so a screen reader announces it instead of staying on the trigger.
 *
 * @param props - The context menu props.
 * @returns The trigger wrapper plus the portalled menu when open.
 */
export declare function ContextMenu({ items, children, className, trigger, longPressDelay, viewportMargin, }: ContextMenuProps): JSX.Element;

export declare type ContextMenuItem = {
    label: ReactNode;
    onSelect?: () => void;
    disabled?: boolean;
    danger?: boolean;
} | {
    separator: true;
};

export declare interface ContextMenuProps {
    /** Menu entries — selectable items and separators. */
    items: ContextMenuItem[];
    /** Trigger area. Right-clicking anywhere within opens the menu at the cursor. */
    children: ReactNode;
    /** Extra class names forwarded to the menu element. */
    className?: string;
    /**
     * Which pointer gesture opens the menu. Default `"contextmenu"`.
     *
     * `"click"` is the `⋮` button case, where a right click is the wrong gesture
     * on the desktop and impossible on touch. `"both"` keeps the right click and
     * adds the left one.
     */
    trigger?: ContextMenuTrigger;
    /**
     * Hold, in ms, that opens the menu from a coarse pointer. Default `500`.
     *
     * Set `0` to turn the long press off. It is on by default because touch has
     * no right click: measured in Chrome with touch emulation (Pixel 7 and
     * iPhone 13 profiles), a 900 ms hold fires `pointerdown`, `touchstart`,
     * `pointerup`, `touchend` and `click` — and no `contextmenu` at all. Every
     * action behind this menu was unreachable on a phone.
     */
    longPressDelay?: number;
    /**
     * Gap, in px, kept between the menu and the edge of the viewport. Default `8`.
     */
    viewportMargin?: number;
}

/** How the menu is opened by a pointer. Touch always gets the long press. */
declare type ContextMenuTrigger = "contextmenu" | "click" | "both";

/** WCAG 2.x contrast ratio between two hex colors, from `1` to `21`. */
export declare function contrastRatio(a: string, b: string): number;

export { Control }

export { Controller }

/**
 * WGS84 geographic coordinate. Mirrors the `Coordinate` schema from
 * `tempest-fastapi-sdk` (`geo/schemas.py`) — `latitude` in `[-90, 90]`,
 * `longitude` in `[-180, 180]`, serialized snake_case on the wire.
 */
export declare interface Coordinate {
    /** WGS84 latitude in degrees, `[-90, 90]`. E.g. `-23.5505`. */
    latitude: number;
    /** WGS84 longitude in degrees, `[-180, 180]`. E.g. `-46.6333`. */
    longitude: number;
}

/**
 * Button that copies a string to the clipboard and shows a transient "copied"
 * state for `timeout` milliseconds.
 *
 * When `children` are provided they are rendered in both states; otherwise the
 * label toggles between "Copy" and "Copied". The reset timer is cleared on
 * unmount to avoid setting state on an unmounted component.
 *
 * @tempest-limits empty-catch — `navigator.clipboard.writeText` rejects when the
 * page is not a secure context, when the document is not focused, or when the user
 * denied the permission. None of those are recoverable here and none deserve an
 * error surface: the button simply never enters the "copied" state, which is the
 * feedback the user needs.
 *
 * @example
 * <CopyButton value="npm i tempest-react-sdk" />
 */
export declare function CopyButton({ value, timeout, children, onCopied, className, onClick, ...props }: CopyButtonProps): JSX.Element;

export declare interface CopyButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    /** Text written to the clipboard when the button is clicked. */
    value: string;
    /** How long (ms) the "copied" state stays active before resetting. Defaults to 2000. */
    timeout?: number;
    /** Optional label. Falls back to "Copy" / "Copied" based on state. */
    children?: ReactNode;
    /** Called after a successful clipboard write. */
    onCopied?: () => void;
}

export declare interface CounterHandlers {
    increment: () => void;
    decrement: () => void;
    set: (value: number) => void;
    reset: () => void;
}

export declare const CPFInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange"> & {
    value?: string;
    onChange?: (value: string) => void;
} & RefAttributes<HTMLInputElement>>;

/**
 * Create a typed HTTP client backed by `fetch`.
 *
 * Handles JSON serialization, query params, bearer auth via `getToken`, uploads
 * via `FormData`, and throws a typed `ApiError` on any non-2xx response.
 *
 * **Expired sessions.** A `401` with `refresh` configured awaits the refresh and
 * replays the request once. `onUnauthorized` fires whenever that path ends
 * unauthorized anyway — the refresh threw, or the replay came back `401` — which
 * is the signal to clear the session. Without `refresh`, the first `401` calls
 * it directly.
 *
 * **Binary bodies** have their own methods — `blob()` and `arrayBuffer()` — which
 * run the same pipeline and skip the parse. `request()` no longer decodes an
 * unknown `Content-Type` as text either: it returns a `Blob` and says so once in
 * a development build, because reading `image/jpeg` as UTF-8 destroyed the bytes
 * on the way in.
 *
 * **The bearer token is scoped to `baseURL`'s origin** since 0.66.0. A path may
 * be an absolute URL, which overrides the base entirely, so without a scope the
 * destination of a credentialed request could come from a value read off the
 * network. A request to another origin still goes out; it goes without the
 * header, and a development build says so once. Declare the exceptions in
 * {@link ApiClientConfig.trustedOrigins}.
 *
 * **Retries** are off unless you set `retry`. See {@link ApiClientConfig.retry}
 * for the built-in policy; it never replays a write. A single call overrides it
 * with {@link RequestOptions.retry}, and opts out of auth entirely with
 * {@link RequestOptions.skipAuth}.
 *
 * **Logging** is off unless you pass a `logger`. With one, every finished attempt
 * writes a line — `debug` under 400, `warn` from 400 up, plus a `warn` when
 * `onUnauthorized` fires — carrying `requestId`, `status` and elapsed `ms`, and
 * never a body, header or query string. The level and the destination belong to
 * the logger, not to a boolean here.
 *
 * @example
 * const api = createApiClient({
 *     baseURL: import.meta.env.VITE_API_URL,
 *     getToken: () => useAuthStore.getState().token,
 *     refresh,
 *     onUnauthorized: () => useAuthStore.getState().logout(),
 *     logger: createLogger({ level: import.meta.env.DEV ? "debug" : "warn" }).child("http"),
 *     retry: true,
 * });
 *
 * @param config - Base URL plus the optional auth, retry and fetch hooks.
 * @returns A client with `request`/`get`/`post`/`put`/`patch`/`delete`/`blob`/
 * `arrayBuffer`/`upload`.
 */
export declare function createApiClient(config: ApiClientConfig): ApiClient;

/**
 * Mix several streams into one output, with gain above 100% and a master limiter.
 *
 * Three things make this a graph instead of a few `<audio>` elements:
 *
 * 1. **`element.volume` is clamped at `1`.** A participant who speaks too quietly
 *    can only be turned *down* — the one correction nobody needs. A `GainNode`
 *    has no ceiling, so this bus takes one (`maxGain`, default 3).
 * 2. **Clipping is a property of the sum.** Three sources at 200% each are clean
 *    alone and distort the instant they play together. A per-source limiter
 *    cannot see that; the one after the mix can, which is where this puts it.
 * 3. **`setSinkId` lives on the element, not on the context.** Sending the mix to
 *    a headset while the rest of the system keeps the speakers is only reachable
 *    by leaving through a `MediaStreamAudioDestinationNode` into a real
 *    `<audio>`. `AudioContext.setSinkId` has far thinner support.
 *
 * @param options - See {@link AudioBusOptions}.
 * @returns The bus. On an engine with no Web Audio it is inert but callable, and
 *   `supported` is `false` — a page without sound beats a page that throws.
 *
 * @example
 * const bus = createAudioBus({ maxGain: 3 });
 * const handle = bus.attach(remoteStream, { gain: 1 });
 * handle.setGain(2.4);              // above 1 — the point of the whole thing
 * await bus.setOutputDevice(headsetId);
 */
export declare function createAudioBus({ maxGain, limiter: limiterOptions, context: injectedContext, }?: AudioBusOptions): AudioBus;

/**
 * Create an isolated audio player that tracks a single "current" clip.
 * Multiple players coexist independently; use this when several layers of UI
 * need their own playback state.
 */
export declare function createAudioPlayer(): AudioPlayerHandle;

/**
 * Wrap a `MediaStream` in a recorder with a real state machine and an honest clock.
 *
 * The engine is shared with the video recorder (`createMediaRecorder`), because the
 * subtle parts are not audio-specific: `MediaRecorder` reports **no duration** (WebM
 * it writes carries none in its header, which is why `<audio>` shows `Infinity` for a
 * fresh recording) so the clock is kept by hand and subtracts paused time; and
 * `stop()` returns *before* the last `dataavailable` event, so the blob can only be
 * assembled in `onstop`. What stays here is the part that genuinely differs — the
 * container list.
 *
 * The stream is **not** owned here: `stop()` leaves the microphone open so a retake
 * does not need a second permission round-trip. Release it with the owning
 * `useMicrophone().stop()`.
 *
 * @param stream - A live audio stream, usually from {@link useMicrophone}.
 * @param options - See {@link AudioRecorderOptions}.
 * @returns The imperative recorder.
 * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
 */
export declare function createAudioRecorder(stream: MediaStream, options?: AudioRecorderOptions): AudioRecorderHandle;

/**
 * Build a typed Zustand auth store with `persist` middleware. Each app passes
 * its own `TUser` shape so the SDK does not own the user model.
 *
 * @example
 * const useAuthStore = createAuthStore<UserResponse>();
 * const { user, token, logout } = useAuthStore();
 */
export declare function createAuthStore<TUser>(options?: CreateAuthStoreOptions<TUser>): UseBoundStore<Omit< StoreApi<AuthState<TUser>>, "setState" | "persist"> & {
    setState(partial: AuthState<TUser> | Partial<AuthState<TUser>> | ((state: AuthState<TUser>) => AuthState<TUser> | Partial<AuthState<TUser>>), replace?: false | undefined): unknown;
    setState(state: AuthState<TUser> | ((state: AuthState<TUser>) => AuthState<TUser>), replace: true): unknown;
    persist: {
        setOptions: (options: Partial< PersistOptions<AuthState<TUser>, unknown, unknown>>) => void;
        clearStorage: () => void;
        rehydrate: () => Promise<void> | void;
        hasHydrated: () => boolean;
        onHydrate: (fn: (state: AuthState<TUser>) => void) => () => void;
        onFinishHydration: (fn: (state: AuthState<TUser>) => void) => () => void;
        getOptions: () => Partial< PersistOptions<AuthState<TUser>, unknown, unknown>>;
    };
}>;

export declare interface CreateAuthStoreOptions<TUser> {
    /** Persist key used in storage (default: "tempest-auth"). */
    name?: string;
    /** Which storage to persist into (default: localStorage). */
    storage?: "local" | "session";
    /** Initial user (useful for SSR hydration). */
    initialUser?: TUser | null;
    /** Initial token. */
    initialToken?: string | null;
}

/**
 * Build a native detector for the given formats.
 *
 * @param formats - Symbologies to look for. Must be ones the engine supports.
 * @returns The detector, or `null` when the API is missing or refused the formats.
 */
export declare function createBarcodeDetector(formats?: readonly BarcodeFormat[]): BarcodeDetectorLike | null;

/**
 * Build a ten-step tint scale from a single color.
 *
 * The input color's hue is kept throughout and its chroma sets the intensity of
 * the whole ramp, so a muted brand color yields a muted scale instead of being
 * "corrected" into something the brand never approved.
 *
 * @param hex - Any hex color (`#abc` or `#aabbcc`), the intended `500` step.
 * @param mode - `"light"` for a light→dark ramp, `"dark"` for the inverted ramp
 *   used under `[data-tempest-theme="dark"]`.
 * @param options - See {@link ColorScaleOptions}.
 */
export declare function createColorScale(hex: string, mode?: "light" | "dark", options?: ColorScaleOptions): ColorScale;

/**
 * Create a {@link DataProvider} bound to an {@link ApiClient}.
 *
 * Maps Refine-style calls to the Tempest FastAPI SDK conventions: list →
 * `GET /{resource}?page=&size=&order_by=&ascending=&...filters`, one →
 * `GET /{resource}/{id}`, create → `POST`, update → `PATCH`/`PUT`,
 * delete → `DELETE`.
 *
 * @param client - The HTTP client created by `createApiClient`.
 * @param options - Optional overrides for param names, sort encoding,
 *   update method and path building.
 * @returns A stateless data provider.
 *
 * @example
 * const dataProvider = createDataProvider(apiClient);
 * const page = await dataProvider.getList<User>("users", {
 *     pagination: { page: 1, pageSize: 20 },
 *     sort: { field: "created_at", order: "desc" },
 *     filters: { active: true },
 * });
 */
export declare function createDataProvider(client: ApiClient, options?: DataProviderOptions): DataProvider;

/**
 * Open a Server-Sent Events stream with automatic exponential-backoff reconnect.
 *
 * Heartbeat events (default `"ping"`) keep the socket alive without firing
 * `onMessage`. Pass `withCredentials: true` when the backend authenticates via
 * cookies. Call `close()` from the returned controller to tear down.
 *
 * @param url - Full SSE endpoint URL.
 * @param options - Stream configuration and callbacks.
 * @returns A controller exposing `close`, `reconnect` and the current `status`.
 */
export declare function createEventStream<T = unknown>(url: string, options?: CreateEventStreamOptions<T>): EventStreamController;

export declare interface CreateEventStreamOptions<T> {
    /** Send cookies with the EventSource handshake. Default: false. */
    withCredentials?: boolean;
    /** Subscribe to named events in addition to `message`. */
    namedEvents?: readonly string[];
    /** Treat these named events as heartbeat-only (no callback). Default: `["ping"]`. */
    heartbeatEvents?: readonly string[];
    /** Max reconnect attempts. Default: 10. Pass 0 to disable reconnect. */
    maxRetries?: number;
    /** Initial backoff in ms; doubles per attempt, capped at `maxBackoff`. Default: 1000. */
    initialBackoff?: number;
    /** Maximum backoff in ms. Default: 30000. */
    maxBackoff?: number;
    /** Parse `event.data`. Defaults to JSON with raw-string fallback. */
    parser?: (raw: string) => T;
    /**
     * A frame arrived that is not valid JSON, and no `parser` was supplied.
     *
     * Registering this drops the frame instead of delivering it: the previous
     * behaviour handed `onMessage` the raw `string` announced as your message
     * type, so the failure surfaced later, at the first property access, with
     * nothing left pointing at the parse. Leave it out and that behaviour is
     * kept, with a one-time warning in development builds.
     */
    onParseError?: (error: unknown, raw: string) => void;
    /**
     * Schema every decoded frame must satisfy, from zod, valibot, arktype or
     * anything else exposing `~standard` or `.safeParse`.
     *
     * Without it nothing changes: the payload reaches `onMessage` announced as
     * `T` on the strength of the type argument alone, which is a promise about
     * the server that TypeScript cannot keep. With it, a frame that does not
     * match is **not** delivered — the same rule `onParseError` already follows —
     * and `onValidationError` hears why. The value delivered is the schema's
     * output, so coercions and defaults are honoured.
     *
     * When `parser` is also supplied, it decodes first and the schema validates
     * what it returned.
     *
     * The validation must be synchronous. A frame is decoded inside the
     * `message` handler and delivered from it, so an async schema would deliver
     * frames in whatever order their validations settled; that case is reported
     * through `onValidationError` instead of awaited.
     */
    schema?: SchemaLike<T>;
    /**
     * A frame was decoded but the `schema` refused it, so it was dropped.
     *
     * The one signal that does not depend on how the app's bundler resolves
     * `process`: the one-time development warning behind `onParseError` needs
     * `isDevBuild()` to be able to answer, and this callback is the app's own.
     */
    onValidationError?: (issues: SchemaIssue[], raw: string) => void;
    onOpen?: () => void;
    onMessage?: (message: EventStreamMessage<T>) => void;
    onError?: (error: Event) => void;
    onStatusChange?: (status: EventStreamStatus) => void;
}

/**
 * Build a [[FeatureFlagsAdapter]] backed by a GrowthBook instance. Apps
 * initialise GrowthBook themselves (so they can load features over the
 * network, set attributes, etc.) — the adapter just routes lookups.
 *
 * Mapping:
 * - `isEnabled(key, default)` → `growthbook.isOn(key)` (falls back to `default` if no value)
 * - `get(key, default)` → `growthbook.getFeatureValue(key, default)`
 * - `onChange(listener)` → `growthbook.setRenderer(listener)` (single-renderer SDK constraint)
 *
 * @example
 * import { GrowthBook } from "@growthbook/growthbook";
 * import { FeatureFlagsProvider, createGrowthBookFeatureFlagsAdapter } from "tempest-react-sdk";
 *
 * const gb = new GrowthBook({ apiHost: "...", clientKey: "..." });
 * await gb.loadFeatures();
 * const adapter = createGrowthBookFeatureFlagsAdapter({ growthbook: gb });
 *
 * <FeatureFlagsProvider adapter={adapter}><App /></FeatureFlagsProvider>;
 */
export declare function createGrowthBookFeatureFlagsAdapter(options: CreateGrowthBookFeatureFlagsAdapterOptions): FeatureFlagsAdapter;

export declare interface CreateGrowthBookFeatureFlagsAdapterOptions {
    /** The GrowthBook instance. Required. */
    growthbook: GrowthBookLike;
}

/**
 * Create an i18n object with translation, pluralization and Intl helpers.
 *
 * The catalog is a plain `{ [locale]: { [key]: "..." } }` map — bring your
 * own keys, namespaces, or nested-key conventions. The SDK does not enforce
 * a schema so you can plug it into any string-loading pipeline.
 *
 * @example
 * const i18n = createI18n({
 *     locale: "pt-BR",
 *     fallbackLocale: "en",
 *     messages: {
 *         "pt-BR": {
 *             "greet": "Olá, {name}",
 *             "alos_one": "{count} Alô",
 *             "alos_other": "{count} Alôs",
 *         },
 *         "en": { greet: "Hi, {name}", alos_one: "{count} Alo", alos_other: "{count} Alos" },
 *     },
 * });
 * i18n.t("greet", { name: "Mau" });          // "Olá, Mau"
 * i18n.plural("alos", 3);                     // "3 Alôs"
 *
 * @example
 * // A key the catalog does not define, with text to show instead of the key.
 * i18n.t("cart.empty", undefined, { default: "Seu carrinho está vazio" });
 */
export declare function createI18n(options: CreateI18nOptions): I18n;

export declare interface CreateI18nOptions {
    /** Initial locale. */
    locale: string;
    /** Fallback locale used when a key is missing in the active locale. */
    fallbackLocale?: string;
    /** Catalog `{ [locale]: { [key]: "..." } }`. */
    messages: Catalog;
}

/**
 * Timing and cost accounting for a pipeline that runs on the user's device.
 */
/**
 * Create a profiler for one run of a pipeline.
 *
 * Wrap each step in {@link InferenceProfiler.stage}, fold in durations you
 * already have (an SDK `speed` breakdown, say) with
 * {@link InferenceProfiler.mark}, then call `report()` once the run finishes.
 *
 * Stages are timed independently rather than as a tiling of the run, so
 * concurrent work is charged its real wall-clock span to each stage and the
 * timings can sum to more than `totalMs`. Surface that to users when you
 * render the breakdown — a bar chart implying a partition of the total would
 * be wrong for a pipeline that overlaps stages.
 *
 * @returns A profiler bound to the moment it was created.
 *
 * @example
 * ```typescript
 * import { createInferenceProfiler } from "tempest-react-sdk";
 * import { Detector } from "tempest-react-sdk/vision";
 *
 * const profiler = createInferenceProfiler();
 * const detector = await profiler.stage("load-model", () =>
 *     Detector.create("/models/detect.onnx"),
 * );
 * const results = await profiler.stage("detect", () => detector.predict(blob));
 * profiler.mark("forward-pass", results[0].speed.inference);
 *
 * const report = await profiler.report({
 *     models: [
 *         { name: "detector", cacheName: "app-models", url: "/models/detect.onnx" },
 *     ],
 * });
 * console.log(report.timings, report.totalMs, report.device, report.models);
 * ```
 */
export declare function createInferenceProfiler(): InferenceProfiler;

/**
 * Trivial in-memory adapter. Suitable for tests, local development, or as a
 * fallback wrapping the real provider while it loads.
 */
export declare function createInMemoryFlags(options?: InMemoryFlagsOptions): FeatureFlagsAdapter & {
    set: (key: string, value: FlagValue) => void;
};

/**
 * Build a typed `localStorage` wrapper around a codec.
 *
 * One implementation behind every store the SDK ships, so they cannot drift in
 * surface. {@link storage} and {@link compressedStorage} are both this function —
 * before it, the compressed one was a hand-written copy of the same guards and
 * had no `remove`, while its own docstring promised the two were interchangeable
 * at the call site. They were not, and the promise failed exactly where somebody
 * followed it.
 *
 * @example
 * const session = createJsonStorage();
 * session.set("draft", { title: "Sem título" });
 *
 * @example
 * const packed = createJsonStorage(compressedStorageCodec);
 *
 * @param codec - Encoder pair. Defaults to plain JSON.
 * @returns A store with `get` / `set` / `getRaw` / `setRaw` / `remove`.
 *
 * @tempest-limits empty-catch — every method is best-effort by contract:
 * `localStorage` throws on quota exhaustion, in Safari private mode, and when a
 * cross-origin frame has storage blocked. A caller persisting a preference has no
 * recovery to run and no user-facing message to show, so the write is dropped and
 * the app keeps the value in memory for the session.
 */
export declare function createJsonStorage(codec?: StorageCodec): JsonStorage;

/**
 * Build a [[FeatureFlagsAdapter]] backed by a LaunchDarkly JS client. Apps
 * initialise the client themselves (`LDClient.initialize(envKey, ctx)`) and
 * pass it in.
 *
 * Mapping:
 * - `isEnabled(key, default)` → `client.variation(key, default) === true`
 * - `get(key, default)` → `client.variation(key, default)`
 * - `onChange(listener)` → `client.on("change", listener)` / `client.off("change", listener)`
 *
 * @example
 * import * as LDClient from "launchdarkly-js-client-sdk";
 * import { FeatureFlagsProvider, createLaunchDarklyFeatureFlagsAdapter } from "tempest-react-sdk";
 *
 * const client = LDClient.initialize(import.meta.env.VITE_LD_CLIENT_ID, { kind: "user", key: userId });
 * await client.waitUntilReady();
 * const adapter = createLaunchDarklyFeatureFlagsAdapter({ client });
 *
 * <FeatureFlagsProvider adapter={adapter}><App /></FeatureFlagsProvider>;
 */
export declare function createLaunchDarklyFeatureFlagsAdapter(options: CreateLaunchDarklyFeatureFlagsAdapterOptions): FeatureFlagsAdapter;

export declare interface CreateLaunchDarklyFeatureFlagsAdapterOptions {
    /** The LaunchDarkly JS client. Required. */
    client: LDClientLike;
}

/**
 * Sample the loudness of a live stream, 0–1.
 *
 * This exists because a recorder with no visible level is indistinguishable from a
 * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong
 * device selected — all three produce a perfectly successful recording of silence,
 * and the user only finds out after they finish talking.
 *
 * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks
 * perceived loudness. It is deliberately **not** React state — updating state per
 * frame would re-render the tree 60 times a second. Poll `level()` from a
 * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing
 * animation.
 *
 * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number
 * of live contexts (Chrome allows around six), so a meter left running on unmount
 * eventually breaks every later one on the page.
 *
 * `level()` applies instant attack and eased release: a value above the current one
 * is taken as is, a lower one decays by `decay`. A meter that fell as fast as it rose
 * reads as noise instead of as loudness.
 *
 * @tempest-limits empty-catch — `stop()` disconnects nodes whose context may already
 * be closed (the tab was backgrounded, the stream's track ended, `stop()` raced an
 * unmount), and a disconnect on a dead graph throws. There is nothing to report and
 * nothing to retry: the resource this call would have released is already gone, and
 * the `context.close()` right after it is what actually matters.
 *
 * @param stream - A live audio stream.
 * @param options - See {@link LevelMeterOptions}.
 * @returns A `level()` reader and a `stop()`.
 *
 * @example
 * const meter = createLevelMeter(stream);
 * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };
 */
export declare function createLevelMeter(stream: MediaStream, { fftSize, decay, context: injectedContext }?: LevelMeterOptions): LevelMeter;

/**
 * Track one link's throughput, resolution and round trip across samples.
 *
 * Every rate here is a **delta**. `bytesSent` is cumulative since the connection
 * opened, so dividing it by the session length gives the historical average —
 * a number that only ever falls and never shows what is happening now. The
 * previous reading is kept on the sampler and subtracted, which is the part
 * every hand-rolled copy of this ends up rewriting.
 *
 * Bytes are summed across every matching sender, because a peer publishing a
 * camera and a screen at once occupies one uplink with both — and the uplink is
 * what runs out. Resolution and frame rate come from the **largest** stream by
 * area, which is the one that dominates that bandwidth and the one somebody
 * watching the call is looking at.
 *
 * @param options - See {@link LinkStatsSamplerOptions}.
 * @returns A sampler. Use one per `RTCPeerConnection`.
 *
 * @example
 * const sampler = createLinkStatsSampler();
 *
 * setInterval(async () => {
 *   const stats = await sampler.sample(pc);
 *   badge.textContent = `${stats.kbps} kbps · ${stats.rttMs ?? "—"} ms`;
 * }, 2000);
 */
export declare function createLinkStatsSampler(options?: LinkStatsSamplerOptions): LinkStatsSampler;

/**
 * `localStorage`-backed resume storage — the default.
 *
 * `localStorage` and not IndexedDB on purpose. The record is four fields and a
 * URL; the requirement is only that it survives a reload, and pulling Dexie in for
 * that would put an IndexedDB dependency in the bundle of every app that uploads a
 * file. Apps that already have `createOfflineStore` open can pass their own
 * {@link ResumableUploadStorage} instead.
 *
 * @param prefix - Key prefix. Default `"tempest-upload:"`.
 * @returns A storage that no-ops when `localStorage` is unavailable.
 */
export declare function createLocalUploadStorage(prefix?: string): ResumableUploadStorage;

/**
 * Create a structured leveled logger. Plug arbitrary sinks (Sentry, Datadog,
 * remote ingestion) by implementing the `LoggerSink` interface.
 *
 * @tempest-limits empty-catch — a sink that throws must not take the app with it,
 * and it must not stop the sinks after it in the list either. Logging is the thing
 * you reach for when something is already going wrong; a transport failure that
 * propagates would turn a diagnostic into the outage. Nothing here can report the
 * failure without recursing into the logger that just failed.
 */
export declare function createLogger(options?: CreateLoggerOptions): Logger;

export declare interface CreateLoggerOptions {
    /** Lowest level recorded. Default: `"info"`. */
    level?: LogLevel;
    /** Output adapters. Default: a `console.*` sink. */
    sinks?: LoggerSink[];
    /** Initial namespace (prepended to every message). */
    namespace?: string;
}

/**
 * Wrap a `MediaStream` in a recorder with a real state machine and an honest clock.
 *
 * This is the engine behind both `createAudioRecorder` and `createVideoRecorder`; the
 * only thing it does not decide is which containers to try, because that is the one
 * part that genuinely differs between the two.
 *
 * Two things `MediaRecorder` does not give you:
 *
 * - **A duration.** It reports none, and the `Blob` has no reliable one either —
 *   WebM written by `MediaRecorder` carries no duration in its header, which is why
 *   `<audio>`/`<video>` shows `Infinity` for a fresh recording. So the clock is kept
 *   here, and it subtracts paused time: a recorder that counts wall-clock through a
 *   pause reports a 30-second note as two minutes.
 * - **A promise from `stop()`.** The last chunk arrives *after* `stop()` returns, in
 *   a `dataavailable` event that fires before `onstop`. Assembling the blob in
 *   `onstop` is the only point where every chunk is in hand.
 *
 * The stream is **not** owned here: `stop()` leaves the device open so a retake does
 * not need a second permission round-trip. Release it with the owning hook's `stop()`.
 *
 * @param stream - A live stream, from `getUserMedia` or `getDisplayMedia`.
 * @param options - See {@link MediaRecordingOptions}.
 * @returns The imperative recorder.
 * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
 */
export declare function createMediaRecorder(stream: MediaStream, options: MediaRecordingOptions): MediaRecorderHandle;

/**
 * Build several {@link OfflineStore}s that share one IndexedDB database.
 *
 * `createOfflineStore` gives each store a database of its own, which is the
 * right shape for one isolated cache. It is the wrong shape as soon as the
 * tables belong together: chats and their messages, an entity and its drafts,
 * anything you would read or clear as a unit. Splitting those across databases
 * costs a real transaction — Dexie runs one atomically only *within* a single
 * database — and it splits the version bump for a related change across two
 * places.
 *
 * This keeps them in one database at one version, so a schema change is one
 * bump and a multi-table write can be wrapped in `db.transaction(...)`.
 *
 * Stores are reached through `store<TItem>(name)` rather than a prebuilt map.
 * That is forced rather than chosen: Dexie's `Table<T>` expands `UpdateSpec<T>`
 * over the keys of `T`, so building `{ [K in keyof TSchema]: OfflineStore<…> }`
 * — or even naming `OfflineStore<TSchema[K], string>` inside the accessor —
 * makes the checker answer TS2589 ("excessively deep"). Taking the record type
 * as a parameter keeps it a plain type argument, which resolves fine. The table
 * name is still checked against the declared schema.
 *
 * The store surface is identical to `createOfflineStore`; only ownership of the
 * database changes. `ownerField` is set per table, since a database commonly
 * mixes per-user data with shared data.
 *
 * @param config - Database name, version, and one entry per table.
 * @returns A `store(name)` accessor, the shared Dexie instance, and a
 *   `destroy()` that drops the database.
 *
 * @example
 * type Chat = { id: string; service_id: string; updated_at: string };
 * type Message = { id: string; service_chat_id: string; created_at: string };
 *
 * const database = createOfflineDatabase<{ chats: Chat; messages: Message }>({
 *     databaseName: "ChatDatabase",
 *     version: 1,
 *     tables: {
 *         chats: { indexes: "&id, service_id, updated_at" },
 *         messages: { indexes: "&id, service_chat_id, created_at" },
 *     },
 * });
 *
 * const chats = database.store<Chat>("chats");
 * const messages = database.store<Message>("messages");
 *
 * // Both tables in one atomic transaction — impossible across two databases.
 * await database.db.transaction("rw", chats.raw, messages.raw, async () => {
 *     await chats.put(chat);
 *     await messages.bulkPut(pending);
 * });
 */
export declare function createOfflineDatabase<TSchema extends OfflineSchema>(config: OfflineDatabaseConfig<TSchema>): OfflineDatabase<TSchema>;

/**
 * Build a typed IndexedDB-backed store using Dexie. Optionally scope every
 * operation by an `ownerField` (useful for multi-user SSE history, drafts,
 * cache per workspace, etc.).
 *
 * Dexie is an **optional peer dependency** — install it (`npm i dexie`) only
 * when your app needs offline storage.
 *
 * @example
 * type Note = { id: string; owner_id: string; text: string; created_at: string };
 * const notes = createOfflineStore<Note, string>({
 *     databaseName: "TempestNotes",
 *     version: 1,
 *     tableName: "notes",
 *     indexes: "&id, owner_id, created_at",
 *     ownerField: "owner_id",
 * });
 * await notes.put({ id: "n1", owner_id: "u1", text: "hi", created_at: ... }, "u1");
 * const mine = await notes.list("u1", { orderBy: "created_at", reverse: true });
 */
export declare function createOfflineStore<TItem, TKey extends string | number = string>(config: OfflineStoreConfig<TItem>): OfflineStore<TItem, TKey>;

/**
 * Create an offline-first sync engine over an IndexedDB outbox.
 *
 * The engine drains queued mutations to the server (`deliver`) and pulls the
 * server delta back (`pullPage` + `applyRemote`), advancing a watermark so each
 * run only fetches what changed. `flush` is single-flight and skips cleanly
 * while offline; failed deliveries stay queued with their attempt count bumped.
 *
 * Dexie is an **optional peer dependency** (via {@link createOfflineStore}) —
 * install it (`npm i dexie`) when you use this engine.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 * @typeParam TRemote - Server item shape returned by `pullPage`.
 * @param config - Transport callbacks + outbox/watermark configuration.
 * @returns The sync handle (`enqueue`, `flush`, `pendingCount`, …).
 *
 * @example
 * const sync = createOfflineSync<Note, NoteDto>({
 *     databaseName: "NotesOutbox",
 *     watermark: { storageKey: "notes.watermark" },
 *     deliver: async (entry) => {
 *         if (entry.op === "delete") return api.remove(entry.recordId);
 *         await api.upsert(entry.recordId, entry.payload!);
 *     },
 *     pullPage: async (since, cursor) => {
 *         const page = await api.changes(since, cursor);
 *         return { items: page.items, nextCursor: page.next, serverTime: page.now };
 *     },
 *     applyRemote: async (dto) => {
 *         if (dto.deleted) return localStore.remove(dto.id);
 *         await localStore.save(fromDto(dto));
 *     },
 * });
 * await sync.enqueue("create", note.id, note);
 * await sync.flush("after-mutation");
 */
export declare function createOfflineSync<TPayload = unknown, TRemote = unknown>(config: OfflineSyncConfig<TPayload, TRemote>): OfflineSync<TPayload>;

/**
 * Build a {@link RoutingBackend} backed by an OSRM server **you host**. OSRM
 * only serves a driving profile, so motorcycle/bus durations are derived by
 * scaling the car duration through {@link durationFactor} — same approach as
 * the FastAPI SDK's `OSRMBackend`.
 *
 * !!! warning
 *     This makes a network request to `baseUrl`. It is opt-in: nothing in the
 *     SDK calls it unless you construct it and pass your own server URL. For a
 *     zero-network estimate, use {@link estimateTravel} instead.
 *
 * @param options - Server URL, optional `fetch`, per-mode factors.
 * @returns A backend whose `route()` queries OSRM.
 *
 * @example
 * const backend = createOSRMBackend({ baseUrl: "https://osrm.internal" });
 * const estimate = await backend.route(origin, destination, { mode: "car" });
 */
export declare function createOSRMBackend(options: OSRMBackendOptions): RoutingBackend;

/**
 * Build a `206 Partial Content` response from a full one for an HTTP `Range`
 * request. Supports `bytes=start-end`, open-ended `bytes=start-` and suffix
 * `bytes=-suffixLength`. Returns the original response when there is no usable
 * `Range` header, or a `416` when the range is unsatisfiable.
 *
 * @param request The incoming request (its `Range` header drives the slice).
 * @param response The full (200) response to slice.
 */
export declare function createPartialResponse(request: Request, response: Response): Promise<Response>;

/**
 * Build a WebAuthn client: the base64url ↔ `ArrayBuffer` plumbing, the two
 * ceremonies, and one classified error type.
 *
 * ## What your backend must do
 *
 * This is the **client half only**, and a WebAuthn client that documents only its
 * own half is unusable. Four routes are yours to implement:
 *
 * 1. `POST /webauthn/register/begin` → a {@link PasskeyCreationOptionsJSON}. Mint a
 *    random `challenge` (≥16 bytes), store it against the session, and list the
 *    user's existing credentials in `excludeCredentials`.
 * 2. `POST /webauthn/register/finish` ← a {@link PasskeyRegistrationJSON}. Verify
 *    the challenge, `origin` and `type` inside `clientDataJSON`, parse the
 *    attestation object, then store the credential id, public key and signature
 *    counter.
 * 3. `POST /webauthn/signin/begin` → a {@link PasskeyRequestOptionsJSON}. New
 *    challenge. Omit `allowCredentials` for a usernameless or autofill flow.
 * 4. `POST /webauthn/signin/finish` ← a {@link PasskeyAuthenticationJSON}. Look the
 *    credential up by `id`, verify the signature over
 *    `authenticatorData || sha256(clientDataJSON)`, and reject a signature counter
 *    that did not grow (a clone). Only then issue your session token.
 *
 * @param options - Defaults applied when the server options omit them.
 * @returns A client usable from anywhere — React, a plain form, a worker.
 *
 * @example
 * const passkeys = createPasskeyClient({ rpId: "acme.com" });
 *
 * const options = await api.post("/webauthn/register/begin");
 * const credential = await passkeys.register(options);
 * await api.post("/webauthn/register/finish", { body: credential });
 */
export declare function createPasskeyClient(options?: CreatePasskeyClientOptions): PasskeyClient;

/** Options for {@link createPasskeyClient}. */
export declare interface CreatePasskeyClientOptions {
    /**
     * Default relying-party id, applied when the server options omit one. Must be
     * the page's domain or a registrable parent of it (`app.acme.com` may use
     * `acme.com`, never the other way round).
     */
    rpId?: string;
    /** Default ceremony timeout in ms. Default `60_000`. */
    timeoutMs?: number;
    /** `navigator.credentials` replacement, for tests. */
    credentials?: CredentialsContainerLike;
}

/**
 * One `RTCPeerConnection` per peer, with the slots negotiated up front.
 *
 * The signalling protocol stays yours: this produces and accepts three message
 * shapes (`offer`, `answer`, `ice`) and leaves delivery, room membership and
 * identity to your server. What it owns is the part that is the same in every
 * mesh and wrong in most of them — see {@link PeerMesh} for the traps each
 * method exists to avoid.
 *
 * @param options - See {@link PeerMeshOptions}.
 * @returns The mesh.
 *
 * @example
 * const mesh = createPeerMesh({
 *     slots: [
 *         { name: "mic", kind: "audio" },
 *         { name: "cam", kind: "video" },
 *     ],
 *     send: (message) => socket.send(message),
 *     onPeers: setPeers,
 * });
 * socket.onMessage = (message) => void mesh.accept(message);
 * await mesh.addPeer("peer-2", { offerer: true });
 * await mesh.setLocalTrack("mic", micTrack);
 */
export declare function createPeerMesh(options: PeerMeshOptions): PeerMesh;

/**
 * Record a live GPS trajectory from `navigator.geolocation.watchPosition`.
 * Framework-free — the {@link usePositionTracker} hook wraps this for React.
 *
 * Jitter while stationary is filtered by `minDistanceKm`; distance is
 * accumulated across the *full* run even when `maxPoints` trims the retained
 * array. 100% browser-side: no network, no external service.
 *
 * @param options - Filtering, retention and callbacks.
 * @returns A controller with `start`/`stop`/`clear` and live getters.
 *
 * @example
 * const tracker = createPositionTracker({
 *   minDistanceKm: 0.01,
 *   onUpdate: (pts) => console.log(pts.length, "points"),
 * });
 * tracker.start();
 * // …later
 * tracker.stop();
 * console.log(tracker.distanceKm);
 */
export declare function createPositionTracker(options?: CreatePositionTrackerOptions): PositionTracker;

/** Options for {@link createPositionTracker}. */
export declare interface CreatePositionTrackerOptions {
    /**
     * Discard a new sample when it is closer than this (in km) to the last
     * kept point — filters GPS jitter while standing still. Default: `0.005`
     * (5 meters). Pass `0` to keep every sample.
     */
    minDistanceKm?: number;
    /**
     * Cap the retained trajectory to the most recent N points (older points are
     * dropped, but their distance stays counted). Default: `Infinity`.
     */
    maxPoints?: number;
    /** Forwarded to `navigator.geolocation.watchPosition`. */
    positionOptions?: PositionOptions;
    /** Called with the full trajectory each time a point is added. */
    onUpdate?: (points: readonly TrackPoint[]) => void;
    /** Called on a `GeolocationPositionError`. */
    onError?: (error: GeolocationPositionError) => void;
    /** Called whenever the status changes. */
    onStatusChange?: (status: TrackerStatus) => void;
}

/**
 * Build a [[TelemetryAdapter]] backed by [`posthog-js`](https://posthog.com/docs/libraries/js).
 * The PostHog client is supplied by the caller (not bundled).
 *
 * Mapping:
 * - `identify(user)` → `posthog.identify(user.id, { email, name, ...traits })` (or `posthog.reset()` when `null`)
 * - `track({ name, properties })` → `posthog.capture(name, properties)`
 * - `captureException(err, ctx)` → `posthog.captureException(err, ctx)` when available, otherwise `posthog.capture("$exception", { …err, …ctx })`
 * - `flush()` → no-op (PostHog batches automatically)
 *
 * @example
 * import posthog from "posthog-js";
 * import { createPostHogTelemetryAdapter, TelemetryProvider } from "tempest-react-sdk";
 *
 * const adapter = createPostHogTelemetryAdapter({
 *     posthog,
 *     init: { apiKey: import.meta.env.VITE_POSTHOG_KEY, options: { api_host: "https://us.i.posthog.com" } },
 * });
 *
 * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;
 */
export declare function createPostHogTelemetryAdapter(options: CreatePostHogTelemetryAdapterOptions): TelemetryAdapter;

export declare interface CreatePostHogTelemetryAdapterOptions {
    /** The PostHog JS client (the default export of `posthog-js`). Required. */
    posthog: PostHogLike;
    /** Project API key + options. When provided, `Provider.init` calls `posthog.init(apiKey, options)`. */
    init?: {
        apiKey: string;
        options?: Record<string, unknown>;
    };
}

/**
 * Build a typed query-key factory for a domain. Each entry can be a static
 * tuple or a function returning a tuple. The returned object is `as const`
 * so TanStack Query infers literal keys.
 *
 * @example
 * const userKeys = createQueryKeys("user", {
 *     me: () => ["me"] as const,
 *     byId: (id: string) => [id] as const,
 *     list: (filters: { page: number }) => ["list", filters] as const,
 * });
 * // userKeys.byId("42") === ["user", "42"]
 */
export declare function createQueryKeys<TKey extends string, TEntries extends Record<string, KeyBuilder | readonly unknown[]>>(scope: TKey, entries: TEntries): {
    all: readonly [TKey];
} & { [K in keyof TEntries]: TEntries[K] extends KeyBuilder ? (...args: Parameters<TEntries[K]>) => readonly [TKey, ...ReturnType<TEntries[K]>] : TEntries[K] extends readonly unknown[] ? readonly [TKey, ...TEntries[K]] : never; };

/**
 * Deduplicate concurrent refresh calls. When multiple 401 responses arrive
 * at once, all of them share the same in-flight `refresh()` promise instead
 * of triggering N parallel refreshes.
 *
 * **In-flight sharing alone does not collapse a burst.** A page that fires
 * several requests at once gets several 401s back, but they do not land inside
 * one window: the stragglers arrive after the first refresh already resolved,
 * find no promise to join, and each starts another one — rotating a token that
 * is already fresh. Measured against a mock backend, five concurrent expired
 * requests took two refreshes, not one.
 *
 * Pass `getToken` to close that gap. The queue remembers the token its last
 * refresh produced, and a call that finds that same token still in place returns
 * immediately, because the refresh it was about to perform has already happened.
 * The same five requests then take exactly one refresh, and so do twenty.
 *
 * @param refresh - Performs the refresh and installs the new credentials.
 * @param options - Optional token reader that enables already-refreshed
 *   detection.
 * @returns A function that refreshes at most once per rotation.
 *
 * @example
 * const refresh = createRefreshQueue(() => AuthService.refresh(), {
 *     getToken: () => useAuthStore.getState().token,
 * });
 *
 * // In every request that hits 401:
 * await refresh();
 * // ...retry the original request
 */
export declare function createRefreshQueue(refresh: () => Promise<void>, options?: CreateRefreshQueueOptions): () => Promise<void>;

export declare interface CreateRefreshQueueOptions {
    /**
     * Reads the credential the refresh installs — typically the access token.
     *
     * Supplying it makes the queue skip a refresh whose work another caller has
     * already done. Without it, only calls that literally overlap in time are
     * collapsed.
     */
    getToken?: () => string | null | undefined;
}

/**
 * Chunked, resumable upload speaking the **tus 1.0.0** protocol (core plus the
 * *creation* and *termination* extensions).
 *
 * ## Why tus and not a bespoke scheme
 *
 * A resumable client whose wire format is undocumented cannot be integrated, and
 * inventing one means the backend is ours forever. tus is a published spec with
 * off-the-shelf servers (`tusd`, `tuspy`, `tus-node-server`), so a caller can point
 * this at something they did not write.
 *
 * ## What the backend must implement
 *
 * Every request carries `Tus-Resumable: 1.0.0`.
 *
 * | Step | Request | Expected response |
 * | --- | --- | --- |
 * | Create | `POST {endpoint}` + `Upload-Length`, `Upload-Metadata`, `Idempotency-Key` | `201` + `Location` (the upload URL, absolute or endpoint-relative) |
 * | Probe | `HEAD {uploadUrl}` | `200`/`204` + `Upload-Offset` |
 * | Write | `PATCH {uploadUrl}` + `Upload-Offset`, `Content-Type: application/offset+octet-stream`, chunk body | `204` + the new `Upload-Offset`; `409` when the offset does not match |
 * | Discard | `DELETE {uploadUrl}` | `204` |
 *
 * ## The failure that actually happens
 *
 * A chunk that the server stored but whose response never arrived. The client
 * cannot tell that from a chunk that was lost, and re-sending it blindly would
 * duplicate bytes. Two things prevent that:
 *
 * - **Writes are addressed, not appended.** Every `PATCH` states the offset it
 *   writes at, so a retry after a lost response is asked to write bytes the server
 *   already has and answers `409`. On any retry the client re-reads the truth with
 *   `HEAD` first and continues from there.
 * - **Creation carries an `Idempotency-Key`** (from `generateIdempotencyKey`),
 *   persisted before the first attempt and reused on retry. tus has no idempotent
 *   creation of its own, so without this a lost `201` leaves an orphan upload on
 *   the server. A backend that honours the header returns the same `Location`; one
 *   that ignores it still works, it just keeps the orphan.
 *
 * @param options - Endpoint, file, and the knobs above.
 * @returns A handle with `start`/`pause`/`resume`/`abort` and live `state`/`offset`.
 *
 * @example
 * const upload = createResumableUpload({
 *     endpoint: "/api/uploads",
 *     file: recording,
 *     metadata: { filename: "nota.webm", ticket: ticketId },
 *     getToken: () => auth.getToken(),
 *     onProgress: ({ fraction }) => setPercent(Math.round(fraction * 100)),
 * });
 *
 * const done = await upload.start();
 * if (done) await api.post("/api/tickets/1/audio", { body: { url: done.url } });
 */
export declare function createResumableUpload(options: ResumableUploadOptions): ResumableUpload;

/**
 * Build a simple RBAC {@link AccessControl} from a static permission set.
 *
 * Permission strings are `"<resource>:<action>"` (e.g. `"posts:create"`) or a
 * bare `"<action>"`. Wildcards are supported: `"*"` grants everything and
 * `"<resource>:*"` grants every action on a resource.
 *
 * The effective set is `config.permissions` plus, for each active role in
 * `config.role`, the permissions listed in `config.roles[role]`.
 *
 * @param config - Permissions, role map, and active role(s).
 * @returns An access-control strategy backed by the resolved permission set.
 *
 * @example
 * ```ts
 * const ac = createRoleAccessControl({
 *   role: "editor",
 *   roles: { editor: ["posts:*", "comments:read"] },
 * });
 * ac.can({ action: "create", resource: "posts" }); // true
 * ```
 */
export declare function createRoleAccessControl(config: RoleAccessControlConfig): AccessControl;

/**
 * Attach auto-generated selector hooks to a Zustand store. Instead of writing
 * `useStore((s) => s.user)` at every call site, you get `useStore.use.user()`
 * — one memoized selector per top-level state key.
 *
 * @typeParam S - The bound store hook type returned by `create`/{@link createStore}.
 * @param store - The bound Zustand hook.
 * @returns The same hook with a `.use` namespace of field selectors.
 *
 * @example
 * const useCart = createSelectors(
 *     createStore<CartState>((set) => ({ items: [], add: (id) => ... })),
 * );
 * const items = useCart.use.items(); // subscribes only to `items`
 */
export declare function createSelectors<S extends UseBoundStore<StoreApi<object>>>(store: S): WithSelectors<S>;

/**
 * Build a [[TelemetryAdapter]] backed by `@sentry/browser`. The Sentry SDK
 * is supplied by the caller (not bundled) so apps that already initialise
 * Sentry at startup can share that instance — and apps that don't use
 * Sentry never pay for it.
 *
 * Mapping:
 * - `identify(user)` → `Sentry.setUser`
 * - `track(event)` → `Sentry.addBreadcrumb({ category, message: event.name, data })`
 * - `captureException(err, ctx)` → `Sentry.captureException(err, { extra: ctx })`
 * - `flush()` → `Sentry.flush(flushTimeout)`
 *
 * @example
 * import * as Sentry from "@sentry/browser";
 * import { createSentryTelemetryAdapter, TelemetryProvider } from "tempest-react-sdk";
 *
 * const adapter = createSentryTelemetryAdapter({
 *     sentry: Sentry,
 *     initOptions: { dsn: import.meta.env.VITE_SENTRY_DSN, tracesSampleRate: 0.1 },
 * });
 *
 * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;
 */
export declare function createSentryTelemetryAdapter(options: CreateSentryTelemetryAdapterOptions): TelemetryAdapter;

export declare interface CreateSentryTelemetryAdapterOptions {
    /** The Sentry browser SDK namespace. Required. */
    sentry: SentryLike;
    /** Optional init payload — passed verbatim to `Sentry.init` when the provider mounts. */
    initOptions?: Record<string, unknown>;
    /** Flush timeout in ms (default `2000`). */
    flushTimeout?: number;
    /** Breadcrumb category for `track` events (default `"app"`). */
    breadcrumbCategory?: string;
}

export declare function createSfxPool(options?: SfxPoolOptions): SfxPool;

/**
 * Create a typed Zustand store with optional `persist` middleware, wired with
 * Tempest defaults. This is the generic counterpart to `createAuthStore`: use
 * it for any domain slice (cart, preferences, wizard state, …) without
 * re-writing the persistence boilerplate in every app.
 *
 * @typeParam T - The store state shape (state + actions).
 * @param initializer - Standard Zustand `StateCreator` (`(set, get) => state`).
 * @param options - Optional persistence configuration.
 * @returns A bound Zustand hook (`useStore`) with the usual `getState`/`setState`/`subscribe` API.
 *
 * @example
 * interface CartState {
 *     items: string[];
 *     add: (id: string) => void;
 *     clear: () => void;
 * }
 *
 * const useCart = createStore<CartState>(
 *     (set) => ({
 *         items: [],
 *         add: (id) => set((s) => ({ items: [...s.items, id] })),
 *         clear: () => set({ items: [] }),
 *     }),
 *     { persist: { name: "cart", partialize: (s) => ({ items: s.items }) } },
 * );
 */
export declare function createStore<T>(initializer: StateCreator<T, [], []>, options?: CreateStoreOptions<T>): UseBoundStore<StoreApi<T>>;

/**
 * Options accepted by {@link createStore}.
 */
export declare interface CreateStoreOptions<T> {
    /** Enable `localStorage`/`sessionStorage` persistence for the store. */
    persist?: CreateStorePersistOptions<T>;
}

/**
 * Persistence options for {@link createStore}. Mirrors the subset of Zustand's
 * `persist` middleware that apps usually need, with sensible Tempest defaults.
 */
export declare interface CreateStorePersistOptions<T> {
    /** Storage key (required to enable persistence). */
    name: string;
    /** Which Web Storage to use (default: `"local"`). */
    storage?: "local" | "session";
    /**
     * Pick the slice of state to persist. Defaults to persisting the whole
     * state. Use this to avoid writing transient/derived fields.
     */
    partialize?: PersistOptions<T, Partial<T>>["partialize"];
    /** Persisted schema version, forwarded to Zustand for migrations. */
    version?: number;
    /** Migration function forwarded to Zustand's `persist` middleware. */
    migrate?: PersistOptions<T, Partial<T>>["migrate"];
}

/**
 * Turn-key auth preset wiring `createAuthStore` + `createRefreshQueue` +
 * `createApiClient` to the Tempest FastAPI SDK auth contract: login returns
 * `{ access_token, token_type }`, requests carry `Authorization: Bearer`, and a
 * `401` triggers a single deduplicated refresh + replay.
 *
 * The session is cleared whenever that path ends unauthorized anyway — the
 * refresh threw, or the replay came back `401` — so a refresh token that the
 * backend has revoked cannot leave the app holding a dead session. With
 * `redirectTo` set, the browser also leaves the page; without it, clearing the
 * store is enough for a `<RouteGuard>` to navigate on its own.
 *
 * @example
 * const auth = createTempestAuth<User, { email: string; password: string }>({
 *     baseURL: import.meta.env.VITE_API_URL,
 *     mePath: "/api/auth/me",
 * });
 *
 * await auth.login({ email, password });   // stores session, returns the user
 * const orders = await auth.api.get("/api/orders");  // sends the bearer token
 * auth.logout();
 *
 * @param options - The auth configuration.
 * @returns The store hook, a wired API client, and login/logout/refresh helpers.
 */
export declare function createTempestAuth<TUser, TCredentials = {
    email: string;
    password: string;
}>(options: CreateTempestAuthOptions<TUser>): TempestAuth<TUser, TCredentials>;

export declare interface CreateTempestAuthOptions<TUser> {
    /** Base URL of the API. Required. */
    baseURL: string;
    /**
     * Path segment the API is mounted under, such as `"/api"`, forwarded to
     * every client this preset builds — see the `prefix` option of
     * `createApiClient`.
     *
     * Safe to combine with the default paths below: the prefix is applied at
     * most once, so `"/api/auth/login"` under a `"/api"` prefix stays
     * `"/api/auth/login"`.
     */
    prefix?: string;
    /** Login route (`POST`). Default: `"/api/auth/login"`. */
    loginPath?: string;
    /** Refresh route (`POST`). Default: `"/api/auth/refresh"`. */
    refreshPath?: string;
    /** Optional current-user route (`GET`) called after login/refresh. */
    mePath?: string;
    /** Persist key for the store. Default: `"tempest-auth"`. */
    storeName?: string;
    /** Storage backend. Default: `"local"`. */
    storage?: "local" | "session";
    /** Send cookies (needed when the refresh token lives in an httpOnly cookie). */
    withCredentials?: boolean;
    /** Custom fetch implementation (testing / SSR). Defaults to `globalThis.fetch`. */
    fetcher?: typeof fetch;
    /**
     * Extract tokens from a login/refresh response. Default reads
     * `access_token` + `refresh_token`.
     */
    parseTokens?: (data: unknown) => {
        token: string;
        refreshToken?: string;
    };
    /** Pull the user out of the login response, when the API embeds it. */
    parseUser?: (data: unknown) => TUser | null;
    /**
     * Build the refresh request body. Default sends `{ refresh_token }` when a
     * refresh token is stored, else `undefined` (cookie-based refresh).
     */
    refreshBody?: (refreshToken: string | null) => unknown;
    /**
     * Retry policy for `api`, forwarded to {@link createApiClient}. Off by
     * default; `true` enables the conservative built-in policy, which never
     * replays a write.
     */
    retry?: boolean | RetryOptions;
    /**
     * Where to send the browser when the session ends — a hard navigation via
     * `window.location.assign`, after the store is cleared.
     *
     * **Prefer leaving this unset.** `logout()` already clears the store, so a
     * `<RouteGuard when={isAuthenticated} redirectTo="/login">` wrapped around
     * the protected area navigates on its own, which keeps the SPA alive and the
     * router history intact. Reach for this only when the expiry can happen
     * outside any guarded subtree and a full reload is acceptable.
     */
    redirectTo?: string;
}

/**
 * Generate `--tempest-*` overrides from a small brand description.
 *
 * Only the families you pass are generated; everything else falls through to the
 * SDK's own tokens, so a theme stays a patch and not a fork of `colors.css`.
 *
 * @example
 * ```ts
 * import { applyTheme, createTheme } from "tempest-react-sdk";
 *
 * const theme = createTheme({
 *   primary: "#7c3aed",
 *   radius: "lg",
 *   chart: ["#7c3aed", "#0ea5e9", "#22c55e", "#f59e0b"],
 * });
 *
 * applyTheme(theme);
 * ```
 *
 * @param options - Brand colors plus optional radius / chart / focus-ring tuning.
 * @returns The light and dark token maps and the CSS text that carries them.
 */
export declare function createTheme(options?: CreateThemeOptions): GeneratedTheme;

/** Input for {@link createTheme}. Every field is optional — omitted families keep the built-in tokens. */
export declare interface CreateThemeOptions {
    /** Brand color, used as the `500` step of the primary scale. */
    primary?: string;
    /** Neutral color, used as the `500` step of the gray scale (surfaces, borders, text). */
    gray?: string;
    /** Success color (`--tempest-success*`). */
    success?: string;
    /** Warning color (`--tempest-warning*`). */
    warning?: string;
    /** Danger color (`--tempest-danger*`). */
    danger?: string;
    /** Info color (`--tempest-info*`). */
    info?: string;
    /**
     * Categorical series colors for `tempest-react-sdk/charts`, in cycle order.
     * Written to `--tempest-chart-1` … `--tempest-chart-N`, so charts follow the
     * theme instead of a hardcoded palette.
     */
    chart?: string[];
    /** Corner radius scale. A preset name, or explicit per-step values. */
    radius?: ThemeRadius | Partial<Record<"xs" | "sm" | "md" | "lg" | "xl" | "2xl", string>>;
    /**
     * Opacity of `--tempest-focus-ring-color`. Omit it — the default ring is opaque.
     *
     * A translucent ring has no contrast of its own; it has the contrast of
     * whatever it composites over. Passing a value below `1` reintroduces the
     * failure 0.61.0 fixed in the built-in tokens, and logs a warning in a
     * development build. Kept because a translucent ring over a background you
     * control is a legitimate choice.
     */
    focusRingAlpha?: number;
    /** Selector the light tokens are written under. Default `":root"`. */
    selector?: string;
    /** Selector the dark tokens are written under. Default `'[data-tempest-theme="dark"]'`. */
    darkSelector?: string;
}

/**
 * Record a video stream — a camera, a screen share, or a `canvas.captureStream()`.
 *
 * The state machine, the clock that subtracts paused time and the `stop()` that
 * resolves in `onstop` with every chunk in hand are shared with the audio recorder
 * (see `createMediaRecorder`); what this adds is the container list and
 * `videoBitsPerSecond`.
 *
 * The stream is **not** owned here. For a screen share in particular, stopping the
 * recorder must not stop the sharing: a support flow usually records, stops, lets the
 * user look at the result and then records again.
 *
 * @param stream - A live stream carrying at least one video track.
 * @param options - See {@link VideoRecorderOptions}.
 * @returns The imperative recorder.
 * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
 *
 * @example
 * const recorder = createVideoRecorder(stream, { videoBitsPerSecond: 2_500_000 });
 * recorder.start();
 * const { blob, durationMs } = await recorder.stop();
 */
export declare function createVideoRecorder(stream: MediaStream, options?: VideoRecorderOptions): VideoRecorderHandle;

/**
 * Build the processing a microphone is published through.
 *
 * Ordered the way a console is: cut what is not speech, gate what is left, level
 * it, shape it, set how loud it goes out, then hold a ceiling. **The order is not
 * cosmetic.** Gating before the high-pass lets a rumble hold the gate open;
 * compressing before the gate lifts the noise floor up to meet the threshold; and
 * a limiter placed before the output gain is a ceiling the gain then walks
 * straight through.
 *
 * This sits *after* the browser's own echo cancellation and noise suppression,
 * which stay on: the two solve different problems. The browser's is trained on
 * stationary noise inside the capture pipeline; this cuts what it leaves behind
 * and decides when the line should be silent at all.
 *
 * @param source - The captured microphone track.
 * @param settings - Which stages to build. Default {@link DEFAULT_VOICE_CHAIN}.
 * @param options - See {@link VoiceChainOptions}.
 * @returns The track to publish plus its teardown. On an engine with no Web Audio,
 *   and when every stage is off, the source track is handed back untouched and
 *   `supported` is `false` — a call without processing beats a call that throws.
 *   The idle case is decided **before** a context is opened, because browsers cap
 *   how many can be live and one built for a chain that does nothing still counts.
 *
 * @example
 * const floor = await measureNoiseFloor(stream);
 * const chain = createVoiceChain(micTrack, {
 *     ...DEFAULT_VOICE_CHAIN,
 *     gate: true,
 *     gateThreshold: suggestGateThreshold(floor),
 * }, { gain: 1.4 });
 * await mesh.setLocalTrack("mic", chain.track);
 */
export declare function createVoiceChain(source: MediaStreamTrack, settings?: VoiceChainSettings, { gain, context: injectedContext, ownsSource }?: VoiceChainOptions): VoiceChain;

/**
 * Open a WebSocket that survives a bad network: exponential backoff with jitter,
 * a handshake timeout, a silence watchdog, optional heartbeat pings and typed
 * JSON parsing.
 *
 * Three failure modes are covered that an event-driven retry loop misses on its
 * own, because none of them fire an event: a handshake that hangs instead of
 * failing, an open socket whose link died mid-flight, and a device with its
 * radio off burning the retry budget. See `handshakeTimeout`, `silenceTimeout`
 * and `waitForOnline`.
 *
 * @param url - Full ws:// or wss:// URL.
 * @param options - Connection configuration and callbacks.
 * @returns Controller exposing `send`, `close`, `reconnect`, `setSilenceTimeout`,
 *   `opened` and `status`.
 *
 * @example
 * const socket = createWebSocket(url, {
 *   silenceTimeout: 75_000,
 *   onReconnecting: (n, total) => setBanner(`Reconectando ${n}/${total}…`),
 *   onReconnected: () => refetchEverything(),
 *   onLost: (reason) => setBanner(reason === "rejected" ? "Acesso negado" : "Sem conexão"),
 * });
 * await socket.opened;
 */
export declare function createWebSocket<T = unknown>(url: string, options?: CreateWebSocketOptions<T>): WebSocketController;

export declare interface CreateWebSocketOptions<T> {
    /** Subprotocol(s) forwarded to the `WebSocket` constructor. */
    protocols?: string | string[];
    /** Max reconnect attempts. Default: 10. Pass 0 to disable. */
    maxRetries?: number;
    /** Initial backoff (ms). Doubles each attempt, capped at `maxBackoff`. Default: 1000. */
    initialBackoff?: number;
    /** Maximum backoff (ms). Default: 30000. */
    maxBackoff?: number;
    /**
     * Fraction of each backoff delay added at random, 0–1. Default: 0.3.
     *
     * Matters when the *server* is what went down: every client retries on the
     * same schedule, so the box comes back up into a synchronized stampede. Pass
     * `0` for a fixed schedule.
     */
    jitter?: number;
    /**
     * How long one handshake may stay in `CONNECTING` before the attempt is
     * abandoned and retried (ms). Default: 8000. Pass 0 to disable.
     *
     * A `WebSocket` that cannot reach its server does not necessarily fail: it
     * sits in `CONNECTING` firing neither `open` nor `close` nor `error`. A retry
     * chain built only on those events stops on its first hung attempt and never
     * moves again — and hung, rather than refused, is precisely how a bad mobile
     * link behaves, which is the case reconnection exists for.
     */
    handshakeTimeout?: number;
    /**
     * Silence tolerated on an open socket before the link is treated as dead (ms).
     * Default: 0 (off).
     *
     * The socket only reports a connection that closes cleanly. A link that dies
     * mid-flight leaves `readyState` at `OPEN` on this side with nothing ever
     * arriving again, so silence is the only symptom available. The timer is
     * re-armed by **any** inbound frame, not just by pings — traffic is traffic.
     *
     * Set it to a comfortable multiple of the server's ping interval (2.5× is a
     * good default) so one dropped ping is not mistaken for an outage. When the
     * server announces its own interval in the handshake, feed that back with
     * {@link WebSocketController.setSilenceTimeout} instead of hard-coding the
     * value on both ends.
     */
    silenceTimeout?: number;
    /**
     * Suspend the retry schedule while `navigator.onLine` is false, and resume on
     * the `online` event. Default: true.
     *
     * Burning retries against a radio that is switched off is how a phone
     * exhausts its budget inside a tunnel and gives up exactly when it comes out
     * the other side.
     */
    waitForOnline?: boolean;
    /**
     * Ping interval (ms). When set, the client sends `pingPayload` periodically
     * to keep the socket alive. Default: 0 (disabled).
     *
     * Leave it off against a `tempest-fastapi-sdk` server: that server pings on
     * its own and answers a client-sent `{"type":"ping"}` with nothing, while a
     * strict handler rejects the unknown frame. What it needs from the client
     * is the `pong` reply, which `respondToPing` sends for you.
     */
    pingInterval?: number;
    /** Payload sent on each ping. Default: `JSON.stringify({ type: "ping" })`. */
    pingPayload?: string | Blob | BufferSource;
    /**
     * Reply to a server `{"type":"ping"}` with `pongPayload`. Default: true.
     *
     * `tempest-fastapi-sdk` closes a socket with code `4408` when no `pong`
     * arrives within `WS_HEARTBEAT_TIMEOUT_SECONDS`, so a client that stays
     * silent is dropped once per timeout. The ping is still forwarded to
     * `onMessage` — the reply is sent before your handler runs.
     */
    respondToPing?: boolean;
    /** Payload sent in reply to a server ping. Default: `JSON.stringify({ type: "pong" })`. */
    pongPayload?: string | Blob | BufferSource;
    /**
     * Buffer payloads sent while the socket is not open and flush them on the
     * next `open`. Default: false — `send()` returns false and drops.
     *
     * Without it, an action fired during reconnect backoff vanishes and the UI
     * cannot tell "never sent" from "sent and ignored".
     */
    queueWhileClosed?: boolean;
    /** Cap on buffered payloads when `queueWhileClosed` is on. Default: 100. */
    maxQueuedMessages?: number;
    /** Parse incoming frames. Default: JSON with raw-string fallback. */
    parser?: (raw: string) => T;
    /**
     * A frame arrived that is not valid JSON, and no `parser` was supplied.
     *
     * Registering this drops the frame instead of delivering it: the previous
     * behaviour handed `onMessage` the raw `string` announced as your message
     * type, so the failure surfaced later, at the first property access, with
     * nothing left pointing at the parse. Leave it out and that behaviour is
     * kept, with a one-time warning in development builds.
     */
    onParseError?: (error: unknown, raw: string) => void;
    /**
     * Schema every decoded frame must satisfy, from zod, valibot, arktype or
     * anything else exposing `~standard` or `.safeParse`.
     *
     * Without it nothing changes: the payload reaches `onMessage` announced as
     * `T` on the strength of the type argument alone, which is a promise about
     * the server that TypeScript cannot keep. With it, a frame that does not
     * match is **not** delivered — the same rule `onParseError` already follows —
     * and `onValidationError` hears why. The value delivered is the schema's
     * output, so coercions and defaults are honoured.
     *
     * When `parser` is also supplied, it decodes first and the schema validates
     * what it returned.
     *
     * A server ping is still answered when the schema drops it: the heartbeat is
     * the transport's contract with the server, not the app's with its payload,
     * and a socket that stops sending `pong` is closed with `4408` once per
     * timeout. The validation itself must be synchronous — a frame is decoded
     * inside the `message` handler and delivered from it, so an async schema
     * would deliver frames in whatever order their validations settled; that
     * case is reported through `onValidationError` instead of awaited.
     */
    schema?: SchemaLike<T>;
    /**
     * A frame was decoded but the `schema` refused it, so it was dropped.
     *
     * The one signal that does not depend on how the app's bundler resolves
     * `process`: the one-time development warning behind `onParseError` needs
     * `isDevBuild()` to be able to answer, and this callback is the app's own.
     */
    onValidationError?: (issues: SchemaIssue[], raw: string) => void;
    onOpen?: (event: Event) => void;
    onMessage?: (message: WebSocketMessage<T>) => void;
    onClose?: (event: CloseEvent) => void;
    onError?: (event: Event) => void;
    onStatusChange?: (status: WebSocketStatus) => void;
    /**
     * A retry has been scheduled. `attempt` is 1-based, `total` is `maxRetries`.
     *
     * Reconnecting is not an error and reads badly as one: announcing every
     * attempt puts a fresh "the connection dropped" in front of someone whose
     * session is in the middle of coming back on its own. Show a quiet
     * reconnecting state here and treat {@link CreateWebSocketOptions.onLost} as
     * the failure.
     */
    onReconnecting?: (attempt: number, total: number) => void;
    /**
     * The socket is back up after at least one retry.
     *
     * Nothing is resumed for you: a server that keys state by connection sees a
     * brand-new client, so this is where the caller re-subscribes, re-joins or
     * refetches whatever the gap invalidated.
     */
    onReconnected?: () => void;
    /**
     * No further attempt will be made — `"rejected"` when the server refused the
     * client outright (close code 4400–4499, minus the 4408 heartbeat timeout),
     * `"exhausted"` when the schedule ran out.
     *
     * This is the one that deserves UI, because it is the only state the caller
     * can act on: offer a "try again" that calls
     * {@link WebSocketController.reconnect}.
     */
    onLost?: (reason: WebSocketLostReason) => void;
}

/**
 * Minimal subset of `navigator.credentials` the passkey client touches.
 *
 * Declared here — the `<X>Like` pattern the SDK's adapters use — for two reasons:
 * jsdom has no `navigator.credentials` at all, so tests must inject a double; and
 * `mediation: "conditional"` is newer than some TypeScript DOM libs, which would
 * otherwise reject the call that makes autofill work.
 */
export declare interface CredentialsContainerLike {
    /** Runs the registration ceremony. */
    create(options: {
        publicKey: PublicKeyCredentialCreationOptions;
        signal?: AbortSignal;
    }): Promise<Credential | null>;
    /** Runs the authentication ceremony. */
    get(options: {
        publicKey: PublicKeyCredentialRequestOptions;
        signal?: AbortSignal;
        mediation?: string;
    }): Promise<Credential | null>;
}

/**
 * @tempest-limits param-count — `downloadCsv(rows, columns, "usuarios.csv")` reads
 * in the order the sentence does, and its two trailing parameters have defaults,
 * so the common call passes three. Wrapping them in an object would break every
 * caller of a published export for no gain in what the call site says.
 */
/** One column of the exported file. */
export declare interface CsvColumn<T> {
    /** Property of the row this column reads from. Doubles as the column key. */
    key: keyof T;
    /** Column heading, written to the first line. */
    header: string;
    /**
     * Value for the file. Defaults to `String(row[key])`, with nullish becoming an
     * empty field.
     *
     * A `DataTableColumn` renders cells to `ReactNode`, which cannot be written to
     * a text file — a badge or a link would serialize as `[object Object]`. Give
     * the column this accessor and the export says what the badge said.
     */
    csv?: (row: T) => string | number | boolean | null | undefined;
}

/** Options for {@link toCsv}. */
export declare interface CsvOptions {
    /**
     * Field separator. Default `","`.
     *
     * Use `";"` for Excel on a locale whose decimal separator is the comma —
     * which is every pt-BR install — otherwise it opens the file in one column.
     */
    delimiter?: "," | ";";
    /** Prefix the output with a UTF-8 BOM. Default `true`. */
    bom?: boolean;
}

/** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */
export declare interface CursorPage<T> {
    /** The rows for this batch. */
    items: T[];
    /** Opaque cursor for the next batch, or null when exhausted. Pass it back verbatim. */
    next_cursor: string | null;
    /** Whether another batch exists. */
    has_more: boolean;
    /** Batch size used for this query. */
    limit: number;
}

/** Cursor filter query params (`CursorPaginationFilterSchema`). */
export declare interface CursorParams {
    cursor?: string | null;
    limit?: number;
    order_by?: string;
    ascending?: boolean;
}

/** Filters passed to {@link DataProvider.getList}, spread verbatim into the query string. */
export declare type DataFilters = Record<string, ParamValue>;

/**
 * Generic, typed list that renders a `<ul>` with one `<li>` per item.
 *
 * The component is generic over the item type so `renderItem` and
 * `keyExtractor` infer their argument types from `items`. When `items` is
 * empty it renders `empty` (or nothing) instead of an empty list.
 *
 * @param items - The collection to render.
 * @param renderItem - Renders the contents of each list item.
 * @param keyExtractor - Optional stable key derivation (defaults to index).
 * @param empty - Optional node shown when there are no items.
 * @returns The rendered list, or the `empty` node when there are no items.
 */
export declare function DataList<T>({ items, renderItem, keyExtractor, empty, className, ...props }: DataListProps<T>): JSX.Element;

export declare interface DataListProps<T> extends HTMLAttributes<HTMLUListElement> {
    /** The collection to render, one `<li>` per item. */
    items: readonly T[];
    /** Renders the contents of each list item. */
    renderItem: (item: T, index: number) => ReactNode;
    /** Derives a stable React key for each item (defaults to the index). */
    keyExtractor?: (item: T, index: number) => string | number;
    /** Node rendered in place of the list when `items` is empty. */
    empty?: ReactNode;
}

/**
 * Refine-style data provider over the Tempest FastAPI SDK CRUD/pagination
 * conventions. Implementations are stateless wrappers around an {@link ApiClient}.
 */
export declare interface DataProvider {
    /**
     * Fetch a paginated list of a resource.
     *
     * @param resource - The resource name (e.g. `"users"`).
     * @param params - Pagination, sort and filter parameters.
     * @returns The offset-paginated envelope.
     */
    getList<T>(resource: string, params?: GetListParams): Promise<OffsetPage<T>>;
    /**
     * Fetch a single record by id.
     *
     * @param resource - The resource name.
     * @param id - The record id.
     * @returns The record.
     */
    getOne<T>(resource: string, id: string | number): Promise<T>;
    /**
     * Fetch many records by id (default: parallel {@link DataProvider.getOne}).
     *
     * @param resource - The resource name.
     * @param ids - The record ids.
     * @returns The records, in the same order as `ids`.
     */
    getMany<T>(resource: string, ids: (string | number)[]): Promise<T[]>;
    /**
     * Create a record.
     *
     * @param resource - The resource name.
     * @param data - The creation payload.
     * @returns The created record.
     */
    create<T>(resource: string, data: unknown): Promise<T>;
    /**
     * Update a record (PATCH by default, PUT when configured).
     *
     * @param resource - The resource name.
     * @param id - The record id.
     * @param data - The update payload.
     * @returns The updated record.
     */
    update<T>(resource: string, id: string | number, data: unknown): Promise<T>;
    /**
     * Delete a record by id.
     *
     * @param resource - The resource name.
     * @param id - The record id.
     * @returns The delete response (often the deleted record).
     */
    deleteOne<T>(resource: string, id: string | number): Promise<T>;
}

/** Options to tailor {@link createDataProvider} to a backend's conventions. */
export declare interface DataProviderOptions {
    /** Query-param name for the page number. Default: `"page"`. */
    pageParam?: string;
    /** Query-param name for the page size. Default: `"size"`. */
    sizeParam?: string;
    /** Query-param name for the sort field. Default: `"order_by"`. */
    sortFieldParam?: string;
    /** Query-param name for the sort order. Default: `"ascending"`. */
    sortOrderParam?: string;
    /**
     * When `true` (default), emit the sort order as a boolean
     * (`order:"asc"` → `true`). When `false`, emit the literal `"asc"`/`"desc"`.
     */
    sortOrderAsBoolean?: boolean;
    /** HTTP method used by {@link DataProvider.update}. Default: `"patch"`. */
    updateMethod?: "patch" | "put";
    /**
     * Build the request path for a resource (and optional id).
     * Default: `id == null ? "/" + resource : "/" + resource + "/" + id`.
     */
    buildPath?: (resource: string, id?: string | number) => string;
}

/**
 * Stateful, headless data table built on top of {@link Table}. Adds
 * client-side searching, click-to-sort columns, pagination and opt-in inline
 * editing while delegating all table markup to the underlying Table component.
 *
 * - Clicking a sortable header cycles asc → desc → unsorted.
 * - Search matches a case-insensitive substring across `searchKeys`
 *   (or every string/number column when not provided).
 * - Pagination is hidden when the result fits on a single page.
 * - A column with `editable` renders a button that opens an inline editor;
 *   `Enter` commits, `Escape` discards, `Tab` walks to the next editable cell.
 *
 * Editing is strictly opt-in: with no `editable` column (or no `onCellChange`) the
 * rendered markup is byte-for-byte what it was before the feature existed, which
 * matters because the component is published.
 *
 * ## Optimistic, with a visible rollback
 *
 * An accepted edit is shown immediately and `onCellChange` runs in the background.
 * If it rejects, the cell returns to the old value **and** shows the reason as a
 * `role="alert"` tied to the cell. A silent revert is worse than no optimistic
 * update at all: the user watched their edit appear and has no reason to doubt it.
 *
 * The header memo depends on `columns`, `sort` and the editing state only:
 * `toggleSort` and the commit callbacks are recreated each render but always close
 * over the same setters, so including them would rebuild every header on every
 * render without changing behaviour. That is why `exhaustive-deps` is silenced on
 * that dependency array.
 */
export declare function DataTable<T>({ data, columns, pageSize, searchable, searchKeys, initialSort, rowKey, emptyMessage, onCellChange, editLabels, totalItems, page: controlledPage, onPageChange, manualSort, onSortChange, manualSearch, onSearchChange, loading, className, ...rest }: DataTableProps<T>): JSX.Element;

/** Everything a table needs regardless of who owns paging, sorting and searching. */
export declare interface DataTableBaseProps<T> extends HTMLAttributes<HTMLDivElement> {
    /**
     * The rows to work with.
     *
     * By default this is the **full** dataset and sorting, searching and paging
     * all happen in memory. Pass `totalItems` and it becomes the current page as
     * the server returned it, with those three delegated to the caller.
     */
    data: T[];
    /** Column definitions. */
    columns: DataTableColumn<T>[];
    /** Rows per page. Default 10. */
    pageSize?: number;
    /** Render a search input above the table. Default false. */
    searchable?: boolean;
    /**
     * Keys to match the search term against. When omitted, every column whose
     * value is a string or number is searched.
     */
    searchKeys?: (keyof T)[];
    /** Initial sort applied before any header interaction. */
    initialSort?: DataTableSort<T>;
    /** Stable key extractor for rows. Defaults to the row index. */
    rowKey?: (row: T, index: number) => string | number;
    /** Content shown when no rows match. */
    emptyMessage?: ReactNode;
    /**
     * Persist an accepted cell edit. Return a promise: while it is pending the cell
     * already shows the new value, and a rejection rolls that back and surfaces the
     * error in the cell. Without this prop no column is editable.
     */
    onCellChange?: (change: DataTableCellChange<T>) => void | Promise<void>;
    /** Override the PT-BR copy of the editing affordances. */
    editLabels?: Partial<DataTableEditLabels>;
    /**
     * A fetch is in flight.
     *
     * With rows already on screen they stay put, dimmed and `aria-busy`, so the
     * page does not jump under the cursor between pages. With no rows yet it
     * renders placeholder lines at full height, which is a different statement
     * from `emptyMessage`: "loading" and "there is nothing" are not the same
     * screen.
     */
    loading?: boolean;
}

/** One accepted cell edit, handed to `onCellChange`. */
export declare interface DataTableCellChange<T> {
    /** The row as it was before the edit. */
    row: T;
    /** Which column changed. */
    key: keyof T;
    /** The parsed new value. */
    value: unknown;
    /** The value that was displayed before the edit. */
    previous: unknown;
    /** Index of the row in the full `data` array. */
    rowIndex: number;
}

/**
 * Column definition for {@link DataTable}. Extends the headless {@link Table}
 * column shape with a typed `key`, opt-in sorting, opt-in inline editing, and the
 * visual options that are forwarded to the underlying Table cell.
 */
export declare interface DataTableColumn<T> {
    /** Property of the row this column reads from. Doubles as the cell key. */
    key: keyof T;
    /** Column heading. */
    header: ReactNode;
    /** Custom cell renderer. Defaults to `String(row[key])`. */
    render?: (row: T) => ReactNode;
    /** Enable click-to-sort on this column's header. */
    sortable?: boolean;
    /** Text alignment forwarded to the Table cell. */
    align?: TableAlign;
    /** Responsive visibility priority forwarded to the Table cell. */
    priority?: TablePriority;
    /** Fixed column width forwarded to the Table cell. */
    width?: string | number;
    /**
     * Let cells in this column be edited in place. Requires `onCellChange` on the
     * table; without it the column stays read-only.
     */
    editable?: boolean;
    /** Editor input type. Default `"text"`. */
    editorType?: DataTableEditorType;
    /** Text the editor opens with. Defaults to `String(value ?? "")`. */
    formatEdit?: (row: T) => string;
    /**
     * Turn the typed string into the stored value. Defaults to the trimmed string,
     * or `Number(raw)` when `editorType` is `"number"`.
     */
    parse?: (raw: string, row: T) => unknown;
    /** Return a message to reject the edit, or `null` to accept it. */
    validate?: (value: unknown, row: T) => string | null;
}

/** Copy for the inline-editing affordances. Every entry has a PT-BR default. */
export declare interface DataTableEditLabels {
    /**
     * Visually hidden prefix that turns a cell's own content into the button's name.
     *
     * A prefix and not a whole label: the accessible name has to *contain* the visible
     * text (WCAG 2.5.3, Label in Name), and a label built from the raw value would say
     * "850000" over a cell that reads `R$ 8.500,00` — which breaks voice control and
     * makes the screen reader disagree with the screen.
     *
     * A single space is appended when it is rendered, so the name reads
     * `"Editar Salário: R$ 8.500,00"`. Do not add one yourself.
     */
    editCell: (column: string) => string;
    /** Accessible name of the editor input. */
    editor: (column: string, rowNumber: number) => string;
    /** Announced (politely) once a cell saved. */
    saved: (column: string) => string;
    /** Shown in the cell when the save was rejected and no reason was thrown. */
    saveFailed: (column: string) => string;
}

/** Input types an editable column can use. */
export declare type DataTableEditorType = "text" | "number" | "date" | "email" | "tel" | "url";

/**
 * Paging, as one of the three shapes that actually work.
 *
 * These used to be three optional props, so the compiler accepted
 * `totalItems` with no `page` — a table whose pager moves an internal page while
 * `data` keeps showing page one. Every prop was optional on its own, so the only
 * place left to catch it was a `console.warn` in dev, in the browser, with the
 * component mounted. As a union the same mistake is a build error at the call
 * site, for free, everywhere.
 */
export declare type DataTablePagingProps = {
    /** Not server mode. */
    totalItems?: never;
    /** The table owns the page. */
    page?: never;
    /** Nothing to report to. */
    onPageChange?: never;
} | {
    /**
     * Total row count across every page — the `total` of a paginated envelope.
     *
     * Passing it switches the table to **server mode**: `data` is read as the
     * current page, the page count comes from this number instead of
     * `data.length`, and sorting and searching are delegated to the caller
     * (see `manualSort` / `manualSearch`, which are implied here). Pair it with
     * `page` and `onPageChange`.
     */
    totalItems?: never;
    /** Current page, 1-based. Controlled — required in server mode. */
    page: number;
    /** Called with the next page. Required whenever `page` is controlled. */
    onPageChange: (page: number) => void;
} | {
    /**
     * Total row count across every page — the `total` of a paginated envelope.
     *
     * Passing it switches the table to **server mode**: `data` is read as the
     * current page, the page count comes from this number instead of
     * `data.length`, and sorting and searching are delegated to the caller
     * (see `manualSort` / `manualSearch`, which are implied here). `page` and
     * `onPageChange` come with it — the type says so, because a server-mode
     * table without them silently shows page one forever.
     */
    totalItems: number;
    /** Current page, 1-based. Controlled, and required in server mode. */
    page: number;
    /** Called with the next page. */
    onPageChange: (page: number) => void;
};

/**
 * The table's props: the shared half, plus one valid paging shape and one valid
 * sorting shape.
 */
export declare type DataTableProps<T> = DataTableBaseProps<T> & DataTablePagingProps & DataTableSortProps<T> & DataTableSearchProps;

/**
 * Searching: delegated, and therefore reported, or neither.
 *
 * `manualSearch` without `onSearchChange` renders a search box that filters
 * nothing and tells nobody — the same shape of lie as a header arrow that turns
 * without sorting.
 *
 * Independent of the paging axis on purpose, and that leaves one gap this type
 * does not close: `totalItems` *implies* `manualSearch`, so a server-mode table
 * with `searchable` and no `onSearchChange` falls into the same hole without ever
 * writing `manualSearch`. Closing it means the search axis has to read the paging
 * axis, which crosses two three-member unions into nine and turns every mismatch
 * into a wall of candidate shapes. That case is a dev warning instead — the one
 * spot where runtime really is the cheaper check, and `use-dev-warnings.ts` says
 * so at the call site.
 */
export declare type DataTableSearchProps = {
    /** The table filters the rows it has. */
    manualSearch?: false;
    /** Called with the current search term (debouncing, if any, is the caller's). */
    onSearchChange?: (term: string) => void;
} | {
    /**
     * Searching is the caller's job: typing reports through `onSearchChange`
     * and the rows are left as they arrived.
     *
     * Implied by `totalItems`. Filtering the current page would hide the rows
     * that do not match *on this page* and show nothing for a term that only
     * matches on page three — an empty table that looks like "no results".
     */
    manualSearch: true;
    /** Where the typing goes. Required, since nothing else acts on it. */
    onSearchChange: (term: string) => void;
};

export declare interface DataTableSort<T> {
    key: keyof T;
    direction: SortDirection;
}

/**
 * Sorting: delegated, and therefore reported, or neither.
 *
 * `manualSort` without `onSortChange` renders a header that moves its arrow and
 * changes nothing else — the arrow is a lie the compiler can now catch.
 */
export declare type DataTableSortProps<T> = {
    /** The table sorts the rows it has. */
    manualSort?: false;
    /** Called with the next sort state — `null` when the header cycles back to unsorted. */
    onSortChange?: (sort: DataTableSort<T> | null) => void;
} | {
    /**
     * Sorting is the caller's job: clicking a header reports through
     * `onSortChange` and the rows are left in the order they arrived.
     *
     * Implied by `totalItems`, because sorting the page in memory would sort
     * *that page only* while the header claims the whole table is ordered.
     */
    manualSort: true;
    /** Where the click goes. Required, since nothing else acts on it. */
    onSortChange: (sort: DataTableSort<T> | null) => void;
};

/**
 * Thin wrapper around the native `<input type="date">` (or `datetime-local`,
 * `time`, `month`). For richer pickers, pair with `react-datepicker` directly
 * — this primitive keeps the SDK dep-free.
 */
export declare const DatePicker: ForwardRefExoticComponent<DatePickerProps & RefAttributes<HTMLInputElement>>;

export declare interface DatePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onChange" | "size"> {
    /** ISO date string (`YYYY-MM-DD`) or empty. */
    value: string;
    onChange: (value: string) => void;
    label?: string;
    helperText?: string;
    error?: string;
    /** Lower bound (`YYYY-MM-DD`). */
    min?: string;
    /** Upper bound (`YYYY-MM-DD`). */
    max?: string;
    /** Mode. `date` (default), `datetime-local`, `time`, or `month`. */
    mode?: "date" | "datetime-local" | "time" | "month";
    wrapperClassName?: string;
}

/** A selected range. Either bound may be `null` while picking. */
export declare interface DateRange {
    start: Date | null;
    end: Date | null;
}

/**
 * Date-range picker: pick a start day, then an end day, across one or more
 * month grids. The hovered day previews the range before the end is committed.
 * Pure `Date` math — no date libraries. For a single date, use `Calendar`.
 *
 * Selection: first click sets `start` (clears `end`); the next click sets `end`
 * (auto-ordered if you click earlier than the start); a third click starts over.
 */
export declare function DateRangePicker({ value, onChange, numberOfMonths, defaultMonth, minDate, maxDate, weekStartsOn, className, ...props }: DateRangePickerProps): JSX.Element;

export declare interface DateRangePickerProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
    /** Controlled selected range. */
    value: DateRange;
    /** Called with the new range as the user picks start then end. */
    onChange: (range: DateRange) => void;
    /** How many month grids to show side by side. Default `2`. */
    numberOfMonths?: number;
    /** Initial visible month (uncontrolled). Defaults to the range start or today. */
    defaultMonth?: Date;
    minDate?: Date;
    maxDate?: Date;
    /** First column of the week — `0` Sunday (default) or `1` Monday. */
    weekStartsOn?: WeekStart_2;
}

/** The visible time window of a day, in minutes from midnight. */
export declare interface DayWindow {
    startMinute: number;
    endMinute: number;
}

/**
 * Create a trailing-edge debounced version of `fn`.
 *
 * The wrapped function delays invoking `fn` until `wait` milliseconds have
 * elapsed since the last time it was called. Only the latest arguments are
 * used. Call `.cancel()` to clear any pending invocation.
 *
 * @example
 * const save = debounce((q: string) => search(q), 300);
 * save("a"); save("ab"); save("abc"); // only "abc" runs after 300ms
 * save.cancel();                       // nothing runs
 */
export declare function debounce<A extends unknown[]>(fn: (...args: A) => void, wait: number): ((...args: A) => void) & {
    cancel: () => void;
};

export declare interface DecodedJWT {
    header: Record<string, unknown>;
    payload: Record<string, unknown> & {
        exp?: number;
        iat?: number;
        sub?: string;
    };
    signature: string;
}

/**
 * Decode a JWT into header/payload/signature. Does **not** verify the
 * signature — for that, do it server-side or use a JOSE library on the
 * client.
 *
 * @throws If the token shape is invalid (missing parts, bad JSON).
 */
export declare function decodeJWT(token: string): DecodedJWT;

/**
 * Decode a string produced by {@link compressToString}.
 *
 * A string without the marker is parsed as plain JSON, so values written before
 * compression was enabled — or by a write that fell back after `gzipSync`
 * failed — still read back.
 *
 * @typeParam T - The expected value shape.
 * @param raw - The stored string.
 * @returns The decoded value.
 * @throws If the payload is neither valid compressed data nor valid JSON.
 */
export declare function decompressFromString<T>(raw: string): T;

/**
 * Recursively merge `source` into `target`, returning a new object.
 *
 * - Plain objects are merged key by key, recursing into nested plain objects.
 * - Arrays and non-plain values (dates, class instances, primitives) replace
 *   the target value entirely — they are not merged element by element.
 * - Neither `target` nor `source` is mutated.
 *
 * @example
 * deepMerge(
 *   { a: 1, nested: { x: 1, y: 2 } },
 *   { nested: { y: 20, z: 30 } },
 * );
 * // { a: 1, nested: { x: 1, y: 20, z: 30 } }
 *
 * @example
 * deepMerge({ tags: ["a", "b"] }, { tags: ["c"] });
 * // { tags: ["c"] } (arrays replaced, not merged)
 */
export declare function deepMerge<T>(target: T, source: Partial<T>): T;

/**
 * PT-BR defaults, used when no strings are supplied and no catalog answers.
 *
 * The SDK's copy is pt-BR everywhere else (`FilterBar`, `DataTable`, `Chat`), so
 * the default here matches rather than introducing an English string that only
 * shows up on a network failure.
 */
export declare const DEFAULT_API_ERROR_STRINGS: ApiErrorStrings;

/**
 * What a scanner looks for when you do not say.
 *
 * Deliberately three formats, not all fourteen. Every extra symbology is more work
 * per frame, and on a mid-range phone the difference between three and fourteen is the
 * difference between a scanner that locks on instantly and one that feels broken.
 */
export declare const DEFAULT_BARCODE_FORMATS: readonly BarcodeFormat[];

/**
 * Default average car speed in km/h used to derive duration from distance.
 * Mirrors `DEFAULT_CAR_SPEED_KMH` from `tempest-fastapi-sdk`.
 */
export declare const DEFAULT_CAR_SPEED_KMH = 50;

/** Default chunk size: 5 MiB, the size most tus servers are tuned for. */
export declare const DEFAULT_CHUNK_SIZE: number;

/**
 * Multiplier applied to the great-circle distance to approximate real road
 * distance. Mirrors `DEFAULT_CIRCUITY_FACTOR` from `tempest-fastapi-sdk`.
 */
export declare const DEFAULT_CIRCUITY_FACTOR = 1.3;

/** Default ceiling for a per-source or master gain, as a multiplier. */
export declare const DEFAULT_MAX_GAIN = 3;

/**
 * Per-mode multipliers applied to the car duration. Mirrors
 * `DEFAULT_MODE_DURATION_FACTORS` from `tempest-fastapi-sdk` — motorcycles are
 * a touch faster, buses considerably slower (stops + dedicated lanes).
 */
export declare const DEFAULT_MODE_DURATION_FACTORS: Record<TravelMode, number>;

/**
 * The speed presets the player offers, and why they stop at 2×.
 *
 * The spec lets a browser drop the audio once `playbackRate` leaves a range it
 * considers useful, and that limit varies by engine. These four sit inside every
 * range measured, so the default control never silences a clip by accident. A
 * caller who wants 4× can pass it — and should test it with sound on the
 * browsers they support before promising it.
 */
export declare const DEFAULT_PLAYBACK_RATES: readonly number[];

/**
 * COSE algorithms offered when the server sends no `pubKeyCredParams`, in
 * preference order.
 *
 * `-8` is Ed25519, which modern authenticators prefer and which produces the
 * smallest signatures. `-7` is ES256, the one algorithm every WebAuthn
 * authenticator supports. `-257` is RS256, needed for TPM-backed Windows Hello.
 * Offering all three is what avoids a `NotSupportedError` on some device you do
 * not own; a server that cannot verify one of them should send its own list.
 */
export declare const DEFAULT_PUB_KEY_CRED_PARAMS: {
    type: "public-key";
    alg: number;
}[];

/** The key a caller gets when it does not choose one. */
export declare const DEFAULT_PUSH_TO_TALK_KEY = "Space";

/**
 * What a call wants before anybody touches a slider.
 *
 * High-pass, leveller and limiter only. Gate, presence, hiss cut and de-esser are
 * off because each has an audible cost when it is not needed — a gate set for the
 * wrong room clips words, presence on a bright microphone is harsh, and a de-esser
 * on a voice that does not hiss just dulls it.
 */
export declare const DEFAULT_VOICE_CHAIN: VoiceChainSettings;

/**
 * The default instruction for a browser that cannot be prompted.
 *
 * Written out rather than left to the app because every app wrote the same two
 * sentences, and getting them wrong is invisible: an iOS user who is told to
 * look for an "Install" menu never finds one, because Safari puts it behind the
 * Share sheet.
 *
 * On an Android fork the copy also offers the `intent://` link the SDK already
 * builds — reopening the page in Chrome is the only path that reaches a real
 * install on a browser whose menu has no install entry at all.
 *
 * @param input - The resolved method and the optional Chrome intent.
 * @returns The instruction, or `null` when the method needs none.
 */
export declare function defaultInstallHint({ method, openInChromeIntent }: InstallHintInput): ReactNode;

/**
 * Identity helper that types a declarative route tree. Use it so editors give
 * autocomplete and type-checking on every node; the array is returned as-is.
 *
 * @example
 * export const routes = defineRoutes([
 *     { path: "/", element: <Layout />, children: [
 *         { index: true, lazy: () => import("./pages/Home") },
 *         { path: "settings", lazy: () => import("./pages/Settings"),
 *           guard: () => useAuth.getState().isAuthenticated, redirectTo: "/login" },
 *     ] },
 * ]);
 */
export declare function defineRoutes(routes: TempestRouteObject[]): TempestRouteObject[];

/**
 * Turn any caught value into a sentence worth showing.
 *
 * The funnel, in order:
 *
 * 0. `codes[error.code]` — the sentence you wrote for that exact backend case.
 *    Checked first because nothing the funnel derives can beat it, and because a
 *    request that never landed carries no `code` for it to shadow.
 * 1. A request that never reached the server — `status === 0`, or a non-API
 *    error thrown while the browser reports itself offline — produces the
 *    offline sentence. This is the step apps skip, and skipping it renders
 *    "erro 0" or a raw `TypeError` at the user.
 * 2. A validation rejection — `error.fields` is set — produces the validation
 *    sentence, **not** `detail`. On a FastAPI `422` the `detail` line is assembled
 *    from the backend's field paths and the validator's own wording
 *    (`"items.0.price: Input should be greater than 0"`), which is right for a
 *    log and wrong for a person: it is half English in a pt-BR screen and it
 *    names internals. The per-field messages stay on `fields`, where a form can
 *    attach them to the inputs that failed.
 *
 *    **Unless the rejection named exactly one field and its message is
 *    `detail` itself**, in which case `detail` is returned. That is not a guess
 *    about the text: `collectFields` fills a single entry from `detail` only for
 *    the flattened envelope a `tempest-fastapi-sdk` backend sends, where the
 *    server wrote one finished sentence about one field (`"CPF ou CNPJ
 *    inválido"`). Returning it shows the same string that is already on
 *    `fields`, so nothing is invented and nothing is lost. The assembled FastAPI
 *    line never reaches this branch, because it comes from the `detail` **list**
 *    and its entries are the per-issue messages, not `detail`.
 *
 *    This is a fix, not a preference. Before `namedField` shipped in 0.54.0,
 *    `fields` was empty against that backend and the sentence reached the user
 *    through step 3; filling `fields` silently replaced it with "Confira os
 *    campos destacados", which presumes a screen that highlights fields — and
 *    no app highlighted anything on the day of the bump.
 *
 *    `useDetail: false` still suppresses it, and is the way to force the fixed
 *    sentence for a backend whose text is written for developers. `validation`
 *    does **not** override it, and that is on purpose: its own contract is the
 *    sentence for a payload rejected *field by field*, which one field carrying
 *    one finished sentence is not — and `useDescribeApiError` always passes
 *    `validation`, so treating it as an override would mean the branch never ran
 *    for any component, which is every caller that matters here.
 * 3. The backend's own `detail`, which is the most specific thing available and
 *    is already written for a person — unless `useDetail: false` says that text
 *    is for developers.
 * 4. `fallback`, with `(HTTP <status>)` appended when a status is known, so the
 *    screenshot in the support ticket carries the one fact a developer needs.
 *
 * Pure on purpose: it works in an interceptor, in a logger and anywhere outside
 * the React tree. {@link useDescribeApiError} is the same funnel with the
 * sentences resolved through `I18nProvider`.
 *
 * @example
 * catch (error) {
 *     toast(describeApiError(error, "Não foi possível salvar o pedido"));
 * }
 *
 * @example
 * catch (error) {
 *     toast(
 *         describeApiError(error, "Não foi possível se candidatar", {
 *             codes: {
 *                 SERVICE_FULL: "Este serviço atingiu o limite de vagas.",
 *                 CANDIDATE_ALREADY_EXISTS: "Você já se candidatou a este serviço.",
 *             },
 *             useDetail: false,
 *         }),
 *     );
 * }
 *
 * @param error - The caught value, of any shape.
 * @param fallback - What to say when the error carries nothing better.
 * @param options - A `codes` catalog, `useDetail`, and overrides for the fixed
 *     sentences.
 * @returns A sentence to show the user.
 */
export declare function describeApiError(error: unknown, fallback: string, options?: DescribeApiErrorOptions): string;

/**
 * Everything {@link describeApiError} accepts beyond the error and the fallback.
 *
 * Extends the fixed sentences rather than sitting beside them, so a caller that
 * already passed `{ offline, validation }` keeps compiling untouched.
 */
export declare interface DescribeApiErrorOptions extends Partial<ApiErrorStrings> {
    /**
     * Maps the backend's programmatic `code` to a sentence in your language.
     *
     * The client already surfaces `code` on `ApiError`, but without this every
     * app writes the same `switch` over it. A hit here wins over every other
     * step: it is the only sentence written for that exact case, by someone who
     * knew both the backend contract and the screen it lands on.
     */
    codes?: Readonly<Record<string, string>>;
    /**
     * Whether the backend's `detail` may be shown when no `code` matched.
     * Default `true`.
     *
     * Set it to `false` when `detail` is written for developers rather than
     * users, or when it could echo internals — the result is then always either
     * a sentence you wrote or the fallback.
     */
    useDetail?: boolean;
}

/**
 * One filter, in words: `"Status é Pago"`.
 *
 * Used for the chip and for the screen-reader announcement, from the same source —
 * a chip that reads `status=eq:paid` to a sighted user and something else to a
 * screen reader would be two different truths.
 */
export declare function describeFilter(filter: Filter, fields: readonly FilterField[], locale?: "pt-BR" | "en"): string;

/**
 * Renders a semantic `<dl>` of term/description pairs with minimal
 * token-based key/value styling.
 *
 * @param items - The term/description pairs to render.
 * @returns The rendered description list.
 */
export declare function DescriptionList({ items, className, ...props }: DescriptionListProps): JSX.Element;

export declare interface DescriptionListItem {
    /** The key/label rendered inside a `<dt>`. */
    term: ReactNode;
    /** The value rendered inside a `<dd>`. */
    description: ReactNode;
}

export declare interface DescriptionListProps extends HTMLAttributes<HTMLDListElement> {
    /** Term/description pairs rendered as `<dt>`/`<dd>` rows. */
    items: DescriptionListItem[];
}

/**
 * The shape a detector resolves with, before normalisation.
 *
 * Every field is optional because a polyfill is allowed to report the value and no
 * geometry at all, and the native engines differ on `cornerPoints`.
 */
export declare interface DetectedBarcodeLike {
    rawValue?: string;
    format?: string;
    boundingBox?: DOMRectReadOnly;
    cornerPoints?: readonly BarcodePoint[];
}

/**
 * Shapes describing what an on-device inference run cost.
 *
 * The browser exposes no energy counter and no FLOP counter, so "cost" here
 * is assembled from what a page can actually observe: how long each stage
 * took, how much parallelism and memory the device reports, and how large the
 * cached model weights are. Anything the platform does not expose stays
 * `null` — a UI can then render "—" instead of a fabricated number.
 */
/**
 * Device capabilities as reported by the browser.
 *
 * Every field is best-effort. `deviceMemoryGb` and `jsHeapUsedMb` come from
 * Chromium-only APIs (`navigator.deviceMemory`, `performance.memory`) and are
 * `null` everywhere else, including Firefox and Safari.
 */
export declare interface DeviceProfile {
    /** Logical cores available to workers, or `null` when unreported. */
    hardwareConcurrency: number | null;
    /** Approximate device RAM in GiB (coarse, Chromium-only), or `null`. */
    deviceMemoryGb: number | null;
    /** Used JS heap in MiB (Chromium-only), or `null`. */
    jsHeapUsedMb: number | null;
}

export declare interface DisclosureHandlers {
    open: () => void;
    close: () => void;
    toggle: () => void;
}

/** Which surface to put first in the picker. */
export declare type DisplaySurfaceHint = "monitor" | "window" | "browser";

/** How many steps the diverging token scale has, midpoint included. */
export declare const DIVERGING_STEP_COUNT = 9;

/**
 * Build a polarity scale over the diverging tokens.
 *
 * Each arm is scaled against its **own** distance from the centre, so an asymmetric
 * domain (say −5…+80) still uses the full cool arm for its small negatives. Scaling
 * both arms by the wider one — the easy mistake — would collapse every negative
 * into the step next to the midpoint and hide the sign entirely.
 *
 * @example
 * const color = divergingScale({ min: -12, max: 40 });   // centre 0
 * const budget = divergingScale({ min: 80, max: 130, center: 100 });
 *
 * @param options - The data domain and the neutral centre.
 * @returns A function from value to a CSS colour reference.
 */
export declare function divergingScale(options: DivergingScaleOptions): (value: number) => ChartColorToken;

export declare interface DivergingScaleOptions {
    /** Lowest value in the data. */
    min: number;
    /** Highest value in the data. */
    max: number;
    /**
     * The value that means "no deviation". Default `0`.
     *
     * It is a parameter because the interesting midpoint is often not zero — a
     * budget variance diverges around the target, not around nothing.
     */
    center?: number;
}

/**
 * Horizontal or vertical visual separator. When `label` is provided in
 * horizontal mode the divider splits and centers the label between two lines.
 */
export declare function Divider({ orientation, variant, label, align, className, ...props }: DividerProps): JSX.Element;

export declare type DividerAlign = "start" | "center" | "end";

export declare type DividerOrientation = "horizontal" | "vertical";

export declare interface DividerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    orientation?: DividerOrientation;
    variant?: DividerVariant;
    /** Optional label rendered inside the divider (horizontal only). */
    label?: ReactNode;
    /** Label horizontal position (only when `label` provided). Defaults to `center`. */
    align?: DividerAlign;
}

export declare type DividerVariant = "solid" | "dashed";

export declare type DocumentVisibility = "visible" | "hidden";

/**
 * Build a CSV and hand it to the user.
 *
 * Goes through {@link shareOrDownloadBlob}, so on a phone it opens the native
 * share sheet and everywhere else it downloads — the same path every other
 * generated artifact in the SDK takes, instead of a fourth hand-rolled `<a
 * download>`.
 *
 * @example
 * await downloadCsv(users, COLUMNS, "usuarios.csv");
 *
 * @param rows - The rows to export.
 * @param columns - Columns, in the order they should appear.
 * @param fileName - File name offered to the user. Default `"export.csv"`.
 * @param options - Delimiter and BOM, forwarded to {@link toCsv}.
 * @returns A promise that resolves once the share or download completes.
 */
export declare function downloadCsv<T>(rows: readonly T[], columns: readonly CsvColumn<T>[], fileName?: string, options?: CsvOptions): Promise<void>;

/**
 * Sliding side panel. Same building blocks as {@link Modal} but anchored to
 * an edge. Locks body scroll while open.
 */
export declare function Drawer({ open, onClose, placement, title, children, footer, closeOnBackdrop, closeOnEsc, hideCloseButton, className, mobilePlacement, showHandle, }: DrawerProps): ReactPortal | null;

export declare type DrawerPlacement = "right" | "left" | "top" | "bottom";

export declare interface DrawerProps {
    open: boolean;
    onClose: () => void;
    placement?: DrawerPlacement;
    title?: ReactNode;
    children?: ReactNode;
    footer?: ReactNode;
    closeOnBackdrop?: boolean;
    closeOnEsc?: boolean;
    hideCloseButton?: boolean;
    className?: string;
    /**
     * Auto-switch to bottom-sheet placement on mobile viewports (< md).
     * Modern mobile apps default to bottom drawers; on desktop the original
     * `placement` is preserved.
     */
    mobilePlacement?: DrawerPlacement;
    /** Render a drag handle indicator at the leading edge (bottom-sheet style). */
    showHandle?: boolean;
}

/**
 * Dropdown menu — a list of actions anchored to a trigger, following the
 * [APG menu button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/menu-button/).
 *
 * `role="menu"` is a promise about the keyboard, and this component keeps it:
 *
 * - `Enter`, `Space` or `ArrowDown` on the trigger opens and focuses the first
 *   entry; `ArrowUp` opens and focuses the last.
 * - `ArrowUp` / `ArrowDown` move with wrap, `Home` / `End` jump to the ends.
 * - `Escape` closes and returns focus to the trigger, so the next `Tab` continues
 *   from where the user was rather than from the top of the document.
 * - `Tab` closes the menu and lets the page's own tab order take over.
 * - Focus is managed: entries carry `tabIndex={-1}` and only the active one is
 *   `0`, which is what stops `Tab` from walking the menu one entry at a time.
 *
 * Disabled entries, separators and labels are skipped by every movement.
 */
export declare function DropdownMenu({ trigger, items, placement, className, }: DropdownMenuProps): JSX.Element;

export declare type DropdownMenuEntry = {
    type: "item";
    id: string;
    label: ReactNode;
    icon?: ReactNode;
    danger?: boolean;
    disabled?: boolean;
    onSelect: () => void;
} | {
    /**
     * An entry that carries on/off state.
     *
     * Rendered as `role="menuitemcheckbox"` with `aria-checked`, which is how
     * a screen reader announces "checked" instead of leaving the state
     * invisible. Selecting it does **not** close the menu: toggling two
     * settings in a row is the ordinary case, and closing after the first
     * would make the second a second trip.
     */
    type: "checkbox";
    id: string;
    label: ReactNode;
    icon?: ReactNode;
    checked: boolean;
    disabled?: boolean;
    onSelect: () => void;
} | {
    type: "separator";
    id: string;
} | {
    type: "label";
    id: string;
    label: ReactNode;
};

export declare type DropdownMenuPlacement = "bottom-start" | "bottom-end" | "top-start" | "top-end";

export declare interface DropdownMenuProps {
    trigger: ReactElement<{
        onClick?: (e: React.MouseEvent) => void;
        onKeyDown?: (e: KeyboardEvent_2) => void;
        "aria-expanded"?: boolean;
        "aria-controls"?: string;
        "aria-haspopup"?: boolean | "menu";
    }>;
    items: DropdownMenuEntry[];
    placement?: DropdownMenuPlacement;
    className?: string;
}

/**
 * Drag-and-drop file area with a hidden file input. Clickable and keyboard
 * focusable; filters by `maxSize` before calling `onDrop`.
 *
 * @example
 * <Dropzone accept="image/*" maxSize={5 * 1024 * 1024} onDrop={setFiles}>
 *     Solte imagens aqui ou clique para selecionar
 * </Dropzone>
 */
export declare function Dropzone({ onDrop, accept, multiple, disabled, maxSize, onReject, children, className, }: DropzoneProps): JSX.Element;

/** Props for {@link Dropzone}. */
export declare interface DropzoneProps {
    /** Called with the accepted files after a drop or file-dialog selection. */
    onDrop: (files: File[]) => void;
    /** `accept` attribute forwarded to the hidden file input. */
    accept?: string;
    /** Allow selecting/dropping multiple files. Default `true`. */
    multiple?: boolean;
    /** Disable interaction. */
    disabled?: boolean;
    /** Maximum file size in bytes; larger files are filtered out. */
    maxSize?: number;
    /** Called with files rejected by `maxSize`. */
    onReject?: (files: File[]) => void;
    /** Custom inner content. Falls back to a default prompt. */
    children?: ReactNode;
    /** Extra class applied to the drop area. */
    className?: string;
}

/**
 * Mean Earth radius in kilometers. Same value used by `tempest-fastapi-sdk`
 * (`geo/distance.py`) so client and server distances agree.
 */
export declare const EARTH_RADIUS_KM = 6371.0088;

export declare interface ElementSize {
    width: number;
    height: number;
}

/**
 * Build an empty {@link OffsetPage} — handy as `placeholderData`/`initialData`.
 *
 * @param pageSize - The page size to report (default 20).
 * @returns An empty offset page on page 1.
 */
export declare function emptyOffsetPage<T>(pageSize?: number): OffsetPage<T>;

/** Centered "nothing here yet" placeholder with optional icon and CTA. */
export declare function EmptyState({ icon, title, description, action, className }: EmptyStateProps): JSX.Element;

export declare interface EmptyStateProps {
    icon?: ReactNode;
    title: ReactNode;
    description?: ReactNode;
    action?: ReactNode;
    className?: string;
}

/**
 * Encode text into a QR matrix.
 *
 * The whole pipeline of ISO/IEC 18004: pick the densest mode the payload
 * qualifies for, pick the smallest version that fits, build the bit stream, add
 * Reed-Solomon correction, interleave the blocks, lay the modules out, then try
 * all eight masks and keep the one the standard's penalty function likes best.
 *
 * @param text - The payload. Byte mode encodes it as UTF-8.
 * @param options - Level and an optional version floor.
 * @returns The finished matrix, without a quiet zone.
 * @throws {QRCapacityError} When the payload does not fit at that level.
 *
 * @example
 * const qr = encodeQR("https://tempest.dev", { level: "Q" });
 * qr.modules[0][0]; // true — top-left of the finder pattern
 */
export declare function encodeQR(text: string, options?: QREncodeOptions): QRMatrix;

/**
 * Wrap PCM in a 16-bit RIFF/WAVE container.
 *
 * The header is the 44-byte canonical form: `RIFF` size, `WAVE`, a 16-byte `fmt `
 * chunk declaring format 1 (uncompressed PCM), then `data`. Samples are interleaved
 * and clamped before scaling, because a value even slightly past ±1 wraps around when
 * truncated to 16 bits and turns a loud passage into a burst of noise.
 *
 * Implemented here rather than pulled from a package: it is a fixed header and a
 * scaling loop, roughly forty lines, and a dependency for it would put its own
 * version bounds on every consumer of this SDK to save writing them.
 *
 * @param audio - Channels and sample rate.
 * @returns A `Blob` of type `audio/wav`.
 */
export declare function encodeWav({ channels, sampleRate }: PcmAudio): Blob;

/**
 * Class-based React error boundary with a render-prop or static fallback.
 * Auto-resets when any value in `resetKeys` changes.
 *
 * @example
 * <ErrorBoundary
 *     resetKeys={[location.pathname]}
 *     onError={(err) => reportError(err)}
 *     fallback={({ error, reset }) => (
 *         <ErrorState description={error.message} onRetry={reset} />
 *     )}
 * >
 *     <App />
 * </ErrorBoundary>
 */
export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
    state: ErrorBoundaryState;
    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
    componentDidCatch(error: Error, info: ErrorInfo): void;
    componentDidUpdate(previousProps: ErrorBoundaryProps): void;
    reset: () => void;
    render(): ReactNode;
}

export declare interface ErrorBoundaryProps {
    children: ReactNode;
    /**
     * Element shown when a descendant throws. Receives the captured error and
     * a `reset` callback that clears the boundary state.
     */
    fallback: ReactNode | ((props: ErrorBoundaryRenderProps) => ReactNode);
    /** Forwarded to your error tracker (Sentry, Datadog, console, etc.). */
    onError?: (error: Error, info: ErrorInfo) => void;
    /**
     * When any value in this array changes, the boundary automatically resets.
     * Useful for clearing the error after a navigation.
     */
    resetKeys?: readonly unknown[];
}

export declare interface ErrorBoundaryRenderProps {
    error: Error;
    reset: () => void;
}

declare interface ErrorBoundaryState {
    error: Error | null;
}

/** Error placeholder with optional retry CTA. Use when a request fails. */
export declare function ErrorState({ title, description, onRetry, retryLabel, icon, className, }: ErrorStateProps): JSX.Element;

export declare interface ErrorStateProps {
    title?: ReactNode;
    description?: ReactNode;
    onRetry?: () => void;
    retryLabel?: string;
    icon?: ReactNode;
    className?: string;
}

/**
 * Renders a form-field error message as a `<p role="alert">`.
 *
 * Renders `null` when there are no children, so it can be placed
 * unconditionally below a field and only appears when an error is present.
 * Styled with the `--tempest-danger` token (falling back to a red default).
 *
 * @param props - The error-text props, plus any `<p>` attributes.
 * @returns The alert paragraph, or `null` when there is no message.
 */
export declare function ErrorText({ children, className, ...props }: ErrorTextProps): ReactNode;

export declare interface ErrorTextProps extends HTMLAttributes<HTMLParagraphElement> {
    /** The error message. When empty, the component renders nothing. */
    children?: ReactNode;
}

export declare function estimatePasswordStrength(value: string): PasswordStrength;

/**
 * Read the origin's current storage usage and quota.
 *
 * @returns The estimate, or `{ usage: null, quota: null }` when unsupported.
 */
export declare function estimateStorage(): Promise<StorageEstimate_2>;

/**
 * Offline travel estimate between two coordinates. No network — distance comes
 * from {@link haversineKm} scaled by circuity, duration from a mode-adjusted
 * average speed. Mirrors `estimate_travel` from `tempest-fastapi-sdk`.
 *
 * @param origin - Start coordinate.
 * @param destination - End coordinate.
 * @param mode - Travel mode. Default: `"car"`.
 * @param options - Tuning knobs (circuity, speed, per-mode factors).
 * @returns A `"heuristic"` {@link TravelEstimate}.
 * @throws {RangeError} If `carSpeedKmh <= 0` or `circuityFactor <= 0`.
 *
 * @example
 * estimateTravel(
 *   { latitude: -23.5505, longitude: -46.6333 },
 *   { latitude: -23.5629, longitude: -46.6544 },
 *   "car",
 * ); // { mode: "car", distance_km: …, duration_minutes: …, source: "heuristic" }
 *
 * @tempest-limits param-count — `(origin, destination, mode)` is the shape every
 * routing API uses, and the fourth argument is already the named-options object the
 * rule asks for. Folding origin and destination into it would hide that the pair is
 * ordered, and this function is re-exported from the package root, so the change
 * would break every caller to satisfy a count.
 */
export declare function estimateTravel(origin: Coordinate, destination: Coordinate, mode?: TravelMode, options?: EstimateTravelOptions): TravelEstimate;

/** Options for {@link estimateTravel}. */
export declare interface EstimateTravelOptions {
    /** Distance multiplier over the great-circle line. Default: `1.3`. */
    circuityFactor?: number;
    /** Average car speed in km/h. Default: `50`. */
    carSpeedKmh?: number;
    /** Per-mode duration multipliers (merged over the defaults). */
    modeDurationFactors?: Partial<Record<TravelMode, number>>;
}

export declare interface EventStreamController {
    close: () => void;
    /** Force an immediate reconnect, resetting the retry counter. */
    reconnect: () => void;
    /** Current connection status. */
    readonly status: EventStreamStatus;
}

export declare interface EventStreamMessage<T> {
    /** Server-named event (default `"message"`). */
    event: string;
    /** Parsed payload — validated when `schema` is set, JSON-decoded when possible, raw string otherwise. */
    data: T;
    /** Server-supplied id, if any. */
    id?: string;
    /** Raw `MessageEvent` for advanced cases. */
    raw: MessageEvent;
}

export declare type EventStreamStatus = "idle" | "connecting" | "open" | "closed" | "error";

/**
 * Grow a bounding box outward by `ratio` of its own span on every side, with a
 * small absolute floor so a single-point (zero-span) box still gets padding.
 * A `ratio` of `0.1` adds 10% margin — handy so a plotted trajectory does not
 * hug the edge of the viewport.
 *
 * @param bounds - The box to expand.
 * @param ratio - Fraction of the span to add per side. Default: `0.1`.
 * @returns A new, larger {@link GeoBounds}.
 */
export declare function expandBounds(bounds: GeoBounds, ratio?: number): GeoBounds;

export declare interface FeatureFlagsAdapter {
    /** Synchronous lookup of a flag with a default. */
    isEnabled: (key: string, defaultValue?: boolean) => boolean;
    /** Read a string/number/json flag value. */
    get: <T extends FlagValue = FlagValue>(key: string, defaultValue?: T) => T;
    /** Subscribe to flag changes. Optional. */
    onChange?: (listener: () => void) => () => void;
}

/** Inject a feature flags adapter into the tree. */
export declare function FeatureFlagsProvider({ adapter, children }: FeatureFlagsProviderProps): JSX.Element;

export declare interface FeatureFlagsProviderProps {
    adapter: FeatureFlagsAdapter;
    children: ReactNode;
}

export { FieldArrayWithId }

export { FieldError }

export { FieldErrors }

export { FieldPath }

export { FieldValues }

/**
 * Drag-and-drop file dropzone. Pair with `uploadWithProgress` from the SDK
 * to wire actual uploads with byte-level progress.
 */
export declare function FileUpload({ value, onChange, label, accept, multiple, maxSize, onReject, disabled, title, subtitle, className, }: FileUploadProps): JSX.Element;

export declare interface FileUploadProps {
    /** Files currently in the dropzone (controlled). */
    value: File[];
    /** Called with the new list when the user adds or removes a file. */
    onChange: (files: File[]) => void;
    label?: string;
    /** Accept attribute forwarded to `<input>`. */
    accept?: string;
    /** Allow multiple files. Default: false. */
    multiple?: boolean;
    /** Max file size in bytes. Files above are rejected via `onReject`. */
    maxSize?: number;
    /** Called with rejected files when they exceed `maxSize` or fail the `accept` filter. */
    onReject?: (rejected: {
        file: File;
        reason: "size" | "type";
    }[]) => void;
    disabled?: boolean;
    /** Title shown on the empty dropzone. */
    title?: string;
    /** Helper line below the title. */
    subtitle?: string;
    className?: string;
}

/** One applied filter. */
export declare interface Filter {
    field: string;
    operator: FilterOperator;
    /** `between` carries a pair; `in` carries a list; `empty`/`notEmpty` carry nothing. */
    value?: string | readonly string[];
}

/**
 * A row of applied filters, and a small editor to add another.
 *
 * Filters are combined with **AND**, flat — no nested `(a OR b) AND c` groups. That
 * is the shape of nearly every admin list ("status is paid, created after March,
 * text contains nota"), and it is what serializes into a URL somebody can send to a
 * colleague. Nested groups need a tree UI with per-node operators and a different
 * serialization; a component trying to be both is clumsy at the common case.
 *
 * Controlled, like the rest of the SDK: it holds the half-typed draft in the editor
 * and nothing else. The applied set is the app's, which is what lets it come from —
 * and go back into — the URL.
 *
 * @example
 * const [filters, setFilters] = useState<Filter[]>(() =>
 *     filtersFromSearchParams(new URLSearchParams(location.search), FIELDS),
 * );
 *
 * <FilterBar fields={FIELDS} value={filters} onChange={setFilters} />
 */
export declare function FilterBar({ fields, value, onChange, locale, actions, className, ...rest }: FilterBarProps): JSX.Element;

export declare interface FilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_13> {
    /** Fields the user may filter by. */
    fields: readonly FilterField[];
    /** Applied filters. Controlled. */
    value: readonly Filter[];
    /** Next filter set. Combined with AND. */
    onChange: (filters: Filter[]) => void;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Rendered at the end of the bar — a "save this view" button, a counter. */
    actions?: ReactNode;
}

/** One filterable field. */
export declare interface FilterField {
    /** Key sent to the backend. */
    name: string;
    /** What the user sees. */
    label: string;
    type: FilterFieldType;
    /** Choices for `select`. */
    options?: ReadonlyArray<{
        value: string;
        label: string;
    }>;
    /** Restrict or reorder the operators offered. Defaults per type. */
    operators?: readonly FilterOperator[];
    /** Placeholder for the value input. */
    placeholder?: string;
}

/** Kind of value a field holds, which decides its operators and its input. */
export declare type FilterFieldType = "text" | "number" | "date" | "select" | "boolean";

/** Comparison a filter can make. */
export declare type FilterOperator = "eq" | "ne" | "contains" | "gt" | "gte" | "lt" | "lte" | "between" | "in" | "empty" | "notEmpty";

export declare type FilterPredicate<T> = (item: T, search: string) => boolean;

/**
 * Read filters back from URL search params.
 *
 * Anything that does not parse is dropped rather than guessed at: a hand-edited URL
 * is the normal way this input arrives, and rendering a filter the app cannot
 * evaluate would show a list that does not match what the chips claim.
 *
 * @param params - Params from the location.
 * @param fields - Known fields; a param naming anything else is ignored.
 * @returns The filters that parsed.
 */
export declare function filtersFromSearchParams(params: URLSearchParams, fields: readonly FilterField[]): Filter[];

/**
 * Encode filters as query params for a paginated backend.
 *
 * The counterpart of {@link applyFilters}: same filter set, evaluated by the
 * database instead of by the browser, which is the only option once the list is
 * paginated on the server and the page in memory is not the whole result.
 *
 * The encoding is the `<column>__<op>` convention `tempest-fastapi-sdk` already
 * reads (`BaseRepository._apply_filters` → `build_filter_condition`):
 *
 * | Operator | Param |
 * | --- | --- |
 * | `eq` | `field` (or `field__iexact` for the `name` column) |
 * | `ne` | `field__ne` |
 * | `contains` | `field__icontains` |
 * | `gt` `gte` `lt` `lte` | `field__gt` … `field__lte` |
 * | `between` | `field__between` twice, low value first |
 * | `in` | `field__in` once per value |
 * | `empty` / `notEmpty` | `field__isnull=true` / `=false` |
 *
 * Returns `URLSearchParams` rather than a plain object because `between` carries
 * a pair and `in` carries a list: an object would keep only the last value of
 * each, silently narrowing the filter. Repeated params are also how FastAPI
 * receives a `list[str]` declared with `Query`.
 *
 * Two things the backend has to hold up its end of, or the filter fails quietly:
 *
 * - **Every key must be declared.** `BasePaginationFilterSchema.get_conditions()`
 *   only forwards fields the subclass declares, so a `status__ne` the schema
 *   never mentions is dropped by FastAPI before the repository sees it — no
 *   error, no filtering.
 * - **`isnull` matches `NULL` only.** A column that stores `""` for "no value"
 *   will not answer an `empty` filter, while {@link applyFilters} treats blank
 *   text as empty.
 *
 * The defaults are that dialect, not a universal truth. A backend that names its
 * substring column something other than `name`, or that spells its operators
 * differently, passes `options` — the alternative was an encoder whose special
 * cases were a wall for anyone not on the Tempest stack.
 *
 * @example
 * const params = filtersToQueryParams(filters);
 * params.set("page", String(page));
 * const data = await api.get(`/orders?${params}`);
 *
 * @example
 * // A backend whose searchable column is `razao_social` and that spells `ne`
 * // the Django way.
 * const params = filtersToQueryParams(filters, {
 *     substringColumns: ["razao_social"],
 *     operatorSuffix: { ne: "__exclude" },
 * });
 *
 * @param filters - Applied filters; incomplete ones are ignored.
 * @param options - Dialect overrides. Defaults to the `tempest-fastapi-sdk` one.
 * @returns Params ready to append to a request URL.
 */
export declare function filtersToQueryParams(filters: readonly Filter[], options?: FiltersToQueryParamsOptions): URLSearchParams;

/** Overrides for the backend dialect {@link filtersToQueryParams} encodes into. */
export declare interface FiltersToQueryParamsOptions {
    /**
     * Columns whose `eq` is emitted as `<column>__iexact` rather than as the bare
     * column name. Default `["name"]`, which is what `build_filter_condition`
     * special-cases.
     *
     * Pass the columns **your** backend treats that way — `nome`, `titulo`,
     * `razao_social` — or `[]` when it treats none of them specially and a bare
     * `eq` should stay bare.
     */
    substringColumns?: readonly string[];
    /**
     * Operator suffixes, merged over the `tempest-fastapi-sdk` dialect, so an
     * override names only the operators that differ.
     *
     * @example
     * // A DRF-style backend
     * filtersToQueryParams(filters, {
     *     substringColumns: [],
     *     operatorSuffix: { contains: "__icontains", ne: "__exclude" },
     * });
     */
    operatorSuffix?: Partial<Record<FilterOperator, string>>;
}

/**
 * Serialize filters into URL search params.
 *
 * One param per filter, `field=operator:value`, with `|` between the values of a
 * multi-value operator. A filter set that cannot survive a reload is a filter set
 * people re-enter every time they open a link somebody sent them, so this is part
 * of the model rather than something each app reinvents.
 *
 * Repeated fields are kept: `status=eq:paid&status=eq:sent` is two filters, and
 * collapsing them would silently drop one.
 *
 * @param filters - Applied filters.
 * @returns Params ready to merge into a location.
 */
export declare function filtersToSearchParams(filters: readonly Filter[]): URLSearchParams;

/**
 * Build a projection that fits `bounds` into a `width × height` viewport while
 * preserving aspect ratio (uniform scale, centered). This is what powers the
 * tile-free trajectory plot: project the bounds, scale to the SVG box, keep
 * shapes undistorted.
 *
 * @param bounds - Geographic extent to fit.
 * @param width - Viewport width in pixels.
 * @param height - Viewport height in pixels.
 * @param options - Padding tuning.
 * @returns A {@link FittedProjection} with a `project(coord)` mapper.
 *
 * @tempest-limits param-count — `(bounds, width, height)` is the viewport the caller
 * measured, usually straight out of a `getBoundingClientRect()`, and the fourth
 * argument is already the options object. Public surface via the package root:
 * renaming these into one bag breaks callers and buys a count, not clarity.
 */
export declare function fitProjection(bounds: GeoBounds, width: number, height: number, options?: FitProjectionOptions): FittedProjection;

/** Options for {@link fitProjection}. */
export declare interface FitProjectionOptions {
    /** Inner padding in pixels kept clear on every edge. Default: `16`. */
    padding?: number;
}

/** A ready-to-use mapping from coordinates to viewport pixels. */
export declare interface FittedProjection {
    /** Project a coordinate to a pixel inside the viewport. */
    project: (coord: Coordinate) => PixelPoint;
    /** Uniform scale (unit-plane → pixels) actually used, after aspect fit. */
    scale: number;
    /** Viewport width in pixels. */
    width: number;
    /** Viewport height in pixels. */
    height: number;
}

export declare type FlagValue = boolean | string | number | null;

/**
 * Material Floating Action Button. Renders a round FAB when only an `icon` is
 * given, or an extended pill FAB when a `label` is also provided. By default it
 * is fixed to the bottom-right corner; set `position="none"` to place it inline.
 *
 * Spreads all native `<button>` props (`onClick`, `disabled`, etc.).
 *
 * @remarks
 * Always pass an `aria-label` when there is no `label`, since an icon-only FAB
 * has no accessible name otherwise.
 *
 * @example
 * <FloatingActionButton icon={<Plus />} aria-label="Adicionar" onClick={create} />
 *
 * @example
 * <FloatingActionButton icon={<Plus />} label="Novo" onClick={create} />
 */
export declare function FloatingActionButton({ icon, label, position, size, variant, className, ...props }: FloatingActionButtonProps): JSX.Element;

declare type FloatingActionButtonPosition = "bottom-right" | "bottom-left" | "none";

export declare interface FloatingActionButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
    /** Icon rendered inside the FAB. Required. */
    icon: ReactNode;
    /** When present, renders an extended (pill) FAB with icon + label. */
    label?: ReactNode;
    /** Corner placement, or `"none"` for static/inline. Default `"bottom-right"`. */
    position?: FloatingActionButtonPosition;
    /** Size token. Default `"md"`. */
    size?: FloatingActionButtonSize;
    /** Visual style. Default `"primary"`. */
    variant?: FloatingActionButtonVariant;
    /** Extra class names merged onto the root. */
    className?: string;
}

declare type FloatingActionButtonSize = "sm" | "md" | "lg";

declare type FloatingActionButtonVariant = "primary" | "surface";

/**
 * Typed, JSX-friendly list renderer.
 *
 * Maps over `each`, calling `children(item, index)` for every entry. When
 * `each` is empty, it renders `fallback` (or nothing). The generic parameter is
 * inferred from `each`, so the render callback's `item` is fully typed:
 * `<For each={users}>{(user) => <li>{user.name}</li>}</For>`.
 *
 * @typeParam T - The element type of the `each` collection.
 * @param props - The list-rendering props.
 * @returns The mapped children, or the fallback when `each` is empty.
 */
export declare function For<T>({ each, children, fallback }: ForProps<T>): ReactNode;

/**
 * Form wrapper with a built-in layout variant. Replaces ad-hoc `<form>` +
 * `<Stack>` / `<Grid>` boilerplate; pair with [[FormRow]], [[FormSection]],
 * and [[FormActions]] for richer layouts.
 *
 * @example
 * <Form layout="grid" columns={2} gap={4} onSubmit={form.handleSubmit(save)}>
 *     <Input label="Nome" {...form.register("name")} />
 *     <Input label="Email" {...form.register("email")} />
 *     <FormActions align="end">
 *         <Button type="submit">Salvar</Button>
 *     </FormActions>
 * </Form>
 */
export declare const Form: ForwardRefExoticComponent<FormProps & RefAttributes<HTMLFormElement>>;

/**
 * Footer button row for a form. Use inside (or after) [[Form]] / [[FormSection]].
 *
 * @example
 * <FormActions align="end">
 *     <Button variant="ghost" onClick={onCancel}>Cancelar</Button>
 *     <Button type="submit" loading={form.formState.isSubmitting}>Salvar</Button>
 * </FormActions>
 */
export declare function FormActions({ align, gap, className, style, children, ...props }: FormActionsProps): JSX.Element;

export declare type FormActionsAlign = "start" | "center" | "end" | "between";

export declare interface FormActionsProps extends HTMLAttributes<HTMLDivElement> {
    /** Horizontal alignment of buttons. Default `end`. */
    align?: FormActionsAlign;
    /** Gap between buttons. Numbers map to a multiple of the 4px scale (default `2` → 8px). */
    gap?: number | string;
}

/**
 * Format a byte count as a human-readable size string.
 *
 * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`
 * controls the fractional digits for scaled units (default 1); `0` bytes
 * always renders as `"0 B"`.
 *
 * An absent or unrepresentable count renders as `"—"`. It used to render as
 * **`"NaN undefined"`**: `Math.log(NaN)` walks the exponent off the end of the
 * unit table, so the unit itself came out `undefined` — the size was not merely
 * unreadable, it claimed a unit that does not exist.
 *
 * @example
 * formatBytes(0);       // "0 B"
 * formatBytes(1536);    // "1.5 KB"
 * formatBytes(1048576); // "1 MB"
 * formatBytes(1536, 2); // "1.50 KB"
 * formatBytes(null);    // "—"
 */
export declare function formatBytes(bytes: number | null | undefined, decimals?: number, options?: FormatFallbackOptions): string;

/** Format an 11-digit Brazilian CEP-like value as `00000-000`. */
export declare function formatCEP(value: string): string;

/** Format an unmasked CNPJ-shaped value as `00.000.000/0000-00`. */
export declare function formatCNPJ(value: string): string;

/**
 * Format a number using compact notation (e.g. `1.2K`, `3.4M`).
 *
 * Wraps `Intl.NumberFormat` with `notation: "compact"`. The `locale` defaults
 * to `"en-US"`.
 *
 * An absent or unrepresentable value renders as `"—"`. The `null` case is the
 * one that matters: `Intl` coerces it to zero, so a count the backend left out
 * used to read as **`"0"`** — a number the reader has no reason to doubt.
 *
 * @example
 * formatCompactNumber(1234);            // "1.2K"
 * formatCompactNumber(5600000);         // "5.6M"
 * formatCompactNumber(1234, "pt-BR");   // "1,2 mil"
 * formatCompactNumber(null);            // "—"
 */
export declare function formatCompactNumber(value: number | null | undefined, locale?: string, options?: FormatFallbackOptions): string;

/**
 * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.
 *
 * @param value - Raw digits or partially masked string.
 * @returns Masked CPF string.
 */
export declare function formatCPF(value: string): string;

/**
 * Format a number as Brazilian Real currency.
 *
 * An absent or unrepresentable amount renders as `"—"` rather than as a number.
 * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to
 * zero, so an amount the backend left out used to reach the screen as
 * **`"R$ 0,00"`** — a plausible figure a reader has no way to question — and
 * `undefined` as `"R$ NaN"`.
 *
 * @example
 * ```typescript
 * formatCurrency(1234.56);                      // "R$ 1.234,56"
 * formatCurrency(null);                         // "—"
 * formatCurrency(null, { fallback: "sem valor" }); // "sem valor"
 * ```
 *
 * @param value - The amount in BRL, or `null`/`undefined` when there is none.
 * @param options - Text to render when there is nothing to format.
 * @returns A locale-formatted string, e.g. "R$ 1.234,56".
 */
export declare function formatCurrency(value: number | null | undefined, options?: FormatFallbackOptions): string;

/**
 * Format an ISO date or Date instance as `dd/MM/yyyy`.
 *
 * Absent input answers `"—"`. It used to **throw**: `new Date(null)` is epoch and
 * `null.getTime` is a `TypeError`, so a nullable column — which is every
 * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —
 * took the screen down instead of rendering a gap.
 *
 * A value that is present and unparseable still answers `""`, deliberately: on a
 * screen that reads a log, "nobody filled this in" and "what they filled in is
 * broken" are different findings, and the second is the one worth chasing.
 *
 * @example
 * ```typescript
 * formatDate("2026-05-16T12:00:00Z"); // "16/05/2026"
 * formatDate(null);                   // "—"
 * formatDate("banana");               // ""
 * ```
 *
 * @param value - ISO string, Date, or `null`/`undefined`.
 * @param options - Text to render when the value is absent.
 * @returns Formatted date string, the fallback when absent, or empty string when
 *   the value is present and invalid.
 */
export declare function formatDate(value: string | Date | null | undefined, options?: FormatFallbackOptions): string;

/**
 * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an
 * `<input type="date">` accepts.
 *
 * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,
 * which is the reflex and which is wrong: `toISOString` converts to UTC first, so
 * anything after 21:00 in UTC-3 reports the next day and the form opens on the
 * wrong date. `formatDate` cannot fill this role because a date input rejects
 * `dd/MM/yyyy` outright.
 *
 * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut
 * is load-bearing rather than an optimisation: `new Date("2026-05-16")` is parsed
 * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the
 * exact value a backend sent would move it back a day.
 *
 * @example
 * <input type="date" defaultValue={formatDateForInput(order.createdAt)} />
 *
 * Absent input answers `""` here — **not** the em dash the reading formatters
 * use — because that is what an input reads as "no value"; an em dash would
 * arrive as content the user has to delete before typing a date.
 *
 * @param value - ISO string, Date, or `null`/`undefined`.
 * @param options - Text for an absent value; defaults to `""`.
 * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —
 *   which is what a date input reads as "no value", unlike `"Invalid Date"`.
 */
export declare function formatDateForInput(value: string | Date | null | undefined, options?: FormatFallbackOptions): string;

/**
 * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.
 *
 * Same contract as {@link formatDate}: absent answers the fallback (`"—"` by
 * default) instead of throwing, and present-but-invalid answers `""`.
 *
 * @param value - ISO string, Date, or `null`/`undefined`.
 * @param options - Text to render when the value is absent.
 * @returns Formatted datetime string, the fallback when absent, or empty string
 *   when the value is present and invalid.
 */
export declare function formatDateTime(value: string | Date | null | undefined, options?: FormatFallbackOptions): string;

/**
 * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an
 * `<input type="datetime-local">` accepts.
 *
 * The sibling of {@link formatDateForInput}, and it exists for the same reason:
 * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`
 * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the
 * next day at 01:00 — here the trap costs the hour as well as the date.
 *
 * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying
 * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it
 * is a different instant from the naive string that looks like it, so it is
 * converted to the local calendar parts the input has to show.
 *
 * Seconds are dropped. A `datetime-local` steps by the minute unless the app
 * sets `step`, so a `:ss` the field cannot represent would be silently discarded
 * on the first edit anyway — truncating here keeps the rendered value and the
 * submitted value the same.
 *
 * @example
 * <input
 *     type="datetime-local"
 *     defaultValue={formatDateTimeForInput(appointment.startsAt)}
 * />
 *
 * @param value - ISO string or Date.
 * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is
 *   invalid — which is what a datetime input reads as "no value", unlike
 *   `"Invalid Date"`.
 */
export declare function formatDateTimeForInput(value: string | Date | null | undefined, options?: FormatFallbackOptions): string;

/**
 * Rendering helpers for the numbers a profiler produces.
 */
/**
 * Format a millisecond duration for display.
 *
 * Sub-second values keep millisecond resolution — the interesting range for a
 * single forward pass — and anything longer switches to seconds so a cold
 * start that pays a model download does not read as a five-digit number.
 * Durations under `1 ms` render as `"<1 ms"` rather than `"0 ms"`, which
 * would read as "not measured".
 *
 * @param value Duration in milliseconds.
 * @returns The formatted string, or `"—"` for a non-finite or negative input.
 *
 * @example
 * ```typescript
 * formatDurationMs(0.04);   // "<1 ms"
 * formatDurationMs(142.6);  // "143 ms"
 * formatDurationMs(4321);   // "4.32 s"
 * formatDurationMs(NaN);    // "—"
 * ```
 */
export declare function formatDurationMs(value: number): string;

/** The text a formatter falls back to when the value cannot be rendered. */
export declare interface FormatFallbackOptions {
    /**
     * Text for a value that is absent (`null`/`undefined`) or unrepresentable
     * (`NaN`, `Infinity`). Defaults to {@link ABSENT_TEXT}.
     *
     * The formatters that feed an `<input>` default to `""` instead, because an
     * input reads an empty string as "no value" and would render an em dash as
     * content the user has to delete.
     */
    fallback?: string;
}

/**
 * Format a fraction (0-1) as a percentage.
 *
 * A non-finite input renders as `"—"` rather than `"NaN%"` or `"∞%"`, which is
 * what `Intl.NumberFormat` produces and what a division by zero upstream puts on
 * the screen. It matches `formatDurationMs`, which already answers that way.
 *
 * @example
 * ```typescript
 * formatPercent(0.9874);                // "98,7%"
 * formatPercent(0.9874, { decimals: 2 }); // "98,74%"
 * formatPercent(0 / 0);                 // "—"
 * ```
 *
 * @param value - Fraction between 0 and 1.
 * @param options - Rendering options; `decimals` defaults to 1.
 * @returns Formatted percent string, e.g. "12,5%", or `"—"` for a non-finite input.
 */
export declare function formatPercent(value: number | null | undefined, options?: FormatPercentOptions): string;

/** How {@link formatPercent} renders a fraction. */
export declare interface FormatPercentOptions extends FormatFallbackOptions {
    /**
     * Decimal places to show, fixed (padded as well as truncated).
     *
     * Defaults to `1`, which is what the function always did. Two is the case
     * that produced this option: a confidence of 98,74% and one of 98,7% are the
     * same number on a summary card and two different readings on a detail
     * screen, so the precision belongs to the call site.
     */
    decimals?: number;
}

/**
 * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.
 *
 * By default the grouping is decided by **length**, which is what a field
 * accepting both landlines and mobiles needs.
 *
 * `mobile: true` is for a field that only accepts mobile numbers, and it exists
 * because the default is wrong as an as-you-type mask there. Reading anything up
 * to ten digits as a landline puts the hyphen after the fourth subscriber digit,
 * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`
 * once the eleventh digit lands. The separator visibly jumps backwards while the
 * user is still typing. With `mobile`, the same input reads `(11) 91234` and the
 * hyphen never moves. It also inserts the leading `9` every Brazilian mobile
 * carries, so a ten-digit number gets corrected rather than masked as a landline.
 *
 * @param value - Raw digits or partially masked string.
 * @param options - Masking options.
 * @returns Masked phone string.
 *
 * @example
 * formatPhone("1191234");                      // "(11) 9123-4"
 * formatPhone("1191234", { mobile: true });    // "(11) 91234"
 * formatPhone("1112345678", { mobile: true }); // "(11) 91234-5678" — 9 inserted
 */
export declare function formatPhone(value: string, options?: FormatPhoneOptions): string;

export declare interface FormatPhoneOptions {
    /**
     * Treat the number as a mobile line: insert the mandatory `9` after the area
     * code when it is missing, and group the subscriber part `5+4` from the
     * first digit typed instead of waiting for the eleventh.
     *
     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten
     * digits, `5+4` at eleven.
     */
    mobile?: boolean;
}

export declare function FormField<TValues extends FieldValues = FieldValues, TName extends FieldPath<TValues> = FieldPath<TValues>>({ name, label, helperText, required, control, children }: FormFieldProps<TValues, TName>): JSX.Element;

export declare interface FormFieldChildProps {
    name: string;
    value: unknown;
    onChange: (...args: unknown[]) => void;
    onBlur: () => void;
    ref: ControllerRenderProps["ref"];
    error?: string;
    "aria-invalid"?: boolean;
    "aria-describedby"?: string;
    label?: ReactNode;
    helperText?: ReactNode;
    required?: boolean;
    id?: string;
}

export declare interface FormFieldProps<TValues extends FieldValues = FieldValues, TName extends FieldPath<TValues> = FieldPath<TValues>> {
    /** Field name (dot path supported, e.g. `"address.city"`). */
    name: TName;
    /** Field label rendered by the wrapped control. */
    label?: ReactNode;
    /** Helper text rendered by the wrapped control when there is no error. */
    helperText?: ReactNode;
    /** When `true`, marks the control as required (visual hint + native attribute). */
    required?: boolean;
    /**
     * Explicit `control` from `useForm()` / `useZodForm()`. Optional when a
     * `FormProvider` is in the tree.
     */
    control?: Control<TValues>;
    /**
     * The control to render. Receives `{ value, onChange, onBlur, ref, error, ... }`
     * via `cloneElement`. Pass `<Input />`, `<Select />`, masked inputs, etc.
     */
    children: ReactElement;
}

export declare type FormLayout = "stack" | "inline" | "grid";

export declare interface FormProps extends FormHTMLAttributes<HTMLFormElement>, LayoutProps {
}

export { FormProvider }

/**
 * Forces a horizontal row regardless of parent layout — useful for grouping
 * two short fields side-by-side inside an otherwise stacked form (e.g. CEP +
 * city, expiry month + year).
 *
 * @example
 * <Form layout="stack">
 *     <FormRow>
 *         <Input label="CEP" />
 *         <Input label="Cidade" />
 *     </FormRow>
 *     <Input label="Endereço completo" />
 * </Form>
 */
export declare function FormRow({ gap, className, style, children, ...props }: FormRowProps): JSX.Element;

export declare interface FormRowProps extends HTMLAttributes<HTMLDivElement> {
    /** Gap between row items. Numbers map to a multiple of the 4px scale (default `3` → 12px). */
    gap?: number | string;
}

/**
 * Visually grouped subset of fields with an optional title and description.
 * Has its own `layout`/`columns`/`gap` so subsets can stack while the parent
 * grids (or vice versa).
 *
 * @example
 * <FormSection title="Endereço" description="Usado para entrega" layout="grid" columns={3}>
 *     <Input label="CEP" />
 *     <Input label="Rua" />
 *     <Input label="Número" />
 * </FormSection>
 */
export declare function FormSection({ title, description, layout, columns, gap, className, style, children, ...props }: FormSectionProps): JSX.Element;

export declare interface FormSectionProps extends Omit<HTMLAttributes<HTMLElement>, "title">, LayoutProps {
    title?: ReactNode;
    description?: ReactNode;
}

export declare interface ForProps<T> {
    /** The collection to iterate over. */
    each: readonly T[];
    /** Render function called for each item with its index. */
    children: (item: T, index: number) => ReactNode;
    /** Rendered when `each` is empty. Defaults to `null`. */
    fallback?: ReactNode;
}

/** A generated theme: token maps per color scheme, plus the CSS text that carries them. */
export declare interface GeneratedTheme {
    /** Light-scheme custom properties, without the leading `--`-less names (keys include `--`). */
    light: Record<string, string>;
    /** Dark-scheme custom properties. */
    dark: Record<string, string>;
    /** Both blocks rendered as CSS, ready for {@link applyTheme} or a stylesheet. */
    css: string;
}

/**
 * Generate an RFC4122 v4 idempotency key (UUID). Use as the value for an
 * `Idempotency-Key` header on POST/PATCH requests that must not run twice.
 */
export declare function generateIdempotencyKey(): string;

/**
 * Axis-aligned geographic bounding box. `min`/`max` follow the same degree
 * ranges as {@link Coordinate}.
 */
export declare interface GeoBounds {
    minLatitude: number;
    maxLatitude: number;
    minLongitude: number;
    maxLongitude: number;
}

export declare interface GeolocationState {
    loading: boolean;
    error: GeolocationPositionError | null;
    coords: GeolocationCoordinates | null;
    timestamp: number | null;
}

/**
 * A pin plotted on a map: a {@link Coordinate} plus optional presentation and
 * an identity used for click callbacks. Shared by `TrajectoryMap` and the
 * Brazil maps' `markers` prop.
 */
export declare interface GeoMarker extends Coordinate {
    /** Stable identity (returned by click handlers). Falls back to the index. */
    id?: string;
    /** Tooltip / accessible label for the pin. */
    label?: string;
    /** Fill color. Defaults to the primary token. */
    color?: string;
    /** Radius in pixels. Default: 6. */
    radius?: number;
}

/**
 * Inline-safe theme resolution intended for early bootstrap (e.g. inside the
 * `<head>` script that prevents the flash of incorrect theme). Reads from
 * localStorage and falls back to `prefers-color-scheme`.
 */
export declare function getInitialTheme(options?: GetInitialThemeOptions): ResolvedTheme;

export declare interface GetInitialThemeOptions {
    /** localStorage key. Default: `"tempest-theme"`. */
    storageKey?: string;
    /** Theme used when nothing is stored and the user has no system preference. */
    defaultTheme?: ThemeMode;
}

/** Parameters for a paginated, sorted, filtered list request. */
export declare interface GetListParams {
    /** Offset pagination — 1-based `page` and `pageSize`. */
    pagination?: {
        page?: number;
        pageSize?: number;
    };
    /** Single-field sort. `order` defaults to `"asc"`. */
    sort?: {
        field: string;
        order?: "asc" | "desc";
    };
    /** Arbitrary filter query params, spread onto the request. */
    filters?: DataFilters;
}

/**
 * Which symbologies this engine will actually decode.
 *
 * Worth asking rather than assuming: the format list belongs to the platform decoder,
 * not to the browser, so two Chromium builds on two operating systems answer
 * differently — and asking for a format the engine does not have makes the constructor
 * throw `NotSupportedError`, which reads like a bug in your code.
 *
 * @returns The supported formats, or an empty array when there is no detector.
 */
export declare function getSupportedBarcodeFormats(): Promise<readonly BarcodeFormat[]>;

/**
 * Look up a preset by name.
 *
 * @param name - Preset name.
 * @returns The preset options, or `undefined` when the name is unknown (so a
 *   value coming from `localStorage` or a query string cannot crash boot).
 */
export declare function getThemePreset(name: string): CreateThemeOptions | undefined;

/**
 * Thin wrapper over `@react-oauth/google`'s `<GoogleLogin>` that:
 *
 * 1. Normalises the success payload into [[OAuthCredential]] (`idToken`,
 *    `provider: "google"`, `raw`).
 * 2. Normalises errors into [[OAuthError]].
 * 3. Lets you pass `GoogleLogin` via the `component` prop, so the SDK does
 *    not declare `@react-oauth/google` as a peer dep — apps that don't use
 *    Google never pay for it.
 *
 * @example
 * import { GoogleLogin, GoogleOAuthProvider } from "@react-oauth/google";
 * import { GoogleSignIn } from "tempest-react-sdk";
 *
 * <GoogleOAuthProvider clientId={import.meta.env.VITE_GOOGLE_CLIENT_ID}>
 *     <GoogleSignIn
 *         component={GoogleLogin}
 *         onSuccess={async ({ idToken }) => {
 *             await api.post("/auth/google", { body: { id_token: idToken } });
 *         }}
 *         onError={(err) => toast.error(err.message)}
 *     />
 * </GoogleOAuthProvider>
 */
export declare function GoogleSignIn({ component: Component, onSuccess, onError, locale, theme, text, shape, size, disableOneTap, width, className, style, }: GoogleSignInProps): JSX.Element;

export declare interface GoogleSignInProps {
    /**
     * `GoogleLogin` component from `@react-oauth/google`. The caller imports
     * it and passes it through so the SDK doesn't take `@react-oauth/google`
     * as a peer dep.
     */
    component: (props: Record<string, unknown>) => ReactNode;
    /** Fired with the validated credential on success. */
    onSuccess: (credential: OAuthCredential) => void | Promise<void>;
    /** Fired with a normalised error on failure. */
    onError?: (error: OAuthError) => void;
    /** Optional locale override (e.g. `"pt-BR"`). Falls back to browser locale. */
    locale?: string;
    /** Visual theme — passed through to `<GoogleLogin>`. */
    theme?: GoogleSignInTheme;
    /** Button text variant. */
    text?: GoogleSignInText;
    /** Button shape. */
    shape?: GoogleSignInShape;
    /** Button size. */
    size?: GoogleSignInSize;
    /** Disable Google's "One Tap" auto-prompt. Default `false`. */
    disableOneTap?: boolean;
    /** Optional `width` override (px) — Google's button is fixed-width. */
    width?: number;
    /** Optional className applied to the wrapper. */
    className?: string;
    /** Optional inline style applied to the wrapper. */
    style?: CSSProperties;
}

export declare type GoogleSignInShape = "rectangular" | "pill" | "circle" | "square";

export declare type GoogleSignInSize = "large" | "medium" | "small";

export declare type GoogleSignInText = "signin_with" | "signup_with" | "continue_with" | "signin";

export declare type GoogleSignInTheme = "filled_blue" | "filled_black" | "outline";

/** Simple CSS-Grid wrapper for equal-width or custom column layouts. */
export declare function Grid({ columns, gap, className, style, children, ...props }: GridProps): JSX.Element;

export declare interface GridProps extends HTMLAttributes<HTMLDivElement> {
    /** Number of columns or a custom `grid-template-columns` value. Accepts responsive object. */
    columns?: ResponsiveValue<number | string>;
    /** Gap as a CSS length. Numbers map to a multiple of the 4px scale. Accepts responsive object. */
    gap?: ResponsiveValue<number | string>;
    children?: ReactNode;
}

/**
 * Group items of a list into buckets keyed by the result of `key`.
 *
 * Items preserve their original order within each bucket.
 *
 * @example
 * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? "even" : "odd"));
 * // { odd: [1, 3], even: [2, 4] }
 *
 * @example
 * groupBy([{ city: "SP" }, { city: "RJ" }, { city: "SP" }], (u) => u.city);
 * // { SP: [{ city: "SP" }, { city: "SP" }], RJ: [{ city: "RJ" }] }
 */
export declare function groupBy<T, K extends PropertyKey>(items: T[], key: (item: T) => K): Record<K, T[]>;

/**
 * Minimal subset of [`@growthbook/growthbook`](https://docs.growthbook.io/lib/js)
 * used by the adapter. Pass a `GrowthBook` instance directly.
 */
export declare interface GrowthBookLike {
    isOn: (key: string) => boolean;
    getFeatureValue: <T>(key: string, defaultValue: T) => T;
    /** Registers a renderer fired whenever GrowthBook re-evaluates features. */
    setRenderer?: (renderer: () => void) => void;
}

export { HashRouter }

/**
 * Great-circle distance between two coordinates using the haversine formula
 * (spherical Earth). Mirrors `haversine_km` from `tempest-fastapi-sdk`.
 *
 * @param origin - Start coordinate.
 * @param destination - End coordinate.
 * @returns Distance in kilometers (`>= 0`).
 *
 * @example
 * haversineKm(
 *   { latitude: -23.5505, longitude: -46.6333 }, // São Paulo
 *   { latitude: -22.9068, longitude: -43.1729 }, // Rio de Janeiro
 * ); // ≈ 360.9
 */
export declare function haversineKm(origin: Coordinate, destination: Coordinate): number;

/**
 * Heartbeat timeout, which sits inside the rejection range but is not one.
 *
 * `tempest-fastapi-sdk` closes with 4408 when no `pong` arrived within
 * `WS_HEARTBEAT_TIMEOUT_SECONDS`. That is the *link* failing, not the server
 * refusing the peer — exactly the case reconnection exists for. Treating the
 * whole 4400–4499 range as fatal, which is the obvious reading, makes one
 * missed pong permanent.
 */
export declare const HEARTBEAT_CLOSE_CODE = 4408;

/** Convert a hex color to OKLCH. */
export declare function hexToOklch(hex: string): Oklch;

/** Parse a hex color into sRGB channels in the `0`–`1` range. */
export declare function hexToRgb(hex: string): {
    r: number;
    g: number;
    b: number;
};

/** Format a hex color as `rgb(r g b / alpha)`, for focus rings and overlays. */
export declare function hexToRgbaString(hex: string, alpha: number): string;

/** Inverse of `<Show>` — hides children when the condition matches. */
export declare function Hide({ above, below, only, children }: HideProps): ReactNode;

export declare interface HideProps {
    /** Hide children when viewport width is `>=` this breakpoint. */
    above?: Breakpoint;
    /** Hide children when viewport width is `<` this breakpoint. */
    below?: Breakpoint;
    /** Hide on specific breakpoints. */
    only?: Breakpoint | Breakpoint[];
    children: ReactNode;
}

/**
 * Resolve a conflict by keeping whichever record carries the higher version
 * number (monotonic counter / row version). The remote record wins ties.
 *
 * @typeParam T - The record shape.
 * @param local - The current local record, or `undefined` when new.
 * @param remote - The incoming remote record.
 * @param getVersion - Reads the monotonic version number.
 * @returns The winning record.
 *
 * @example
 * applyRemote: async (dto) => {
 *     const local = await store.get(dto.id);
 *     await store.save(higherVersionWins(local, dto, (r) => r.version));
 * }
 */
export declare function higherVersionWins<T>(local: T | undefined, remote: T, getVersion: (record: T) => number): T;

/**
 * Content preview shown when the trigger is hovered or focused.
 *
 * - Opens after `openDelay` on `mouseenter`/`focus`.
 * - Closes after `closeDelay` on `mouseleave`/`blur`.
 * - Positioned relative to the trigger via `placement`.
 * - The card is rendered as a labelled `role="dialog"` region; the trigger stays keyboard focusable.
 *
 * @param props - The hover card props.
 * @returns The trigger wrapper and the anchored card when open.
 */
export declare function HoverCard({ trigger, children, openDelay, closeDelay, placement, className, ...rest }: HoverCardProps): JSX.Element;

export declare type HoverCardPlacement = "top" | "bottom" | "left" | "right";

export declare interface HoverCardProps extends HTMLAttributes<HTMLDivElement> {
    /** Element the user hovers/focuses to reveal the card. */
    trigger: ReactNode;
    /** Card content shown while hovering/focusing the trigger or the card itself. */
    children: ReactNode;
    /** Delay in ms before opening on mouseenter/focus. Default 300. */
    openDelay?: number;
    /** Delay in ms before closing on mouseleave/blur. Default 150. */
    closeDelay?: number;
    /** Where the card is anchored relative to the trigger. Default "bottom". */
    placement?: HoverCardPlacement;
}

export declare interface I18n {
    /** Currently active locale. */
    locale: string;
    /** Fallback locale (or `null` when not configured). */
    fallbackLocale: string | null;
    /**
     * Translate `key`, interpolating `{name}` placeholders from `params`.
     * Falls back to the configured fallback locale, then to `options.default`,
     * then to the key itself.
     */
    t: (key: string, params?: InterpolationValues, options?: TranslateOptions) => string;
    /**
     * Plural-aware translation. Tries `${key}_one` for `count === 1` and
     * `${key}_other` otherwise, with `{count}` available for interpolation.
     * Falls back to `options.default`, then to the key itself.
     */
    plural: (key: string, count: number, params?: InterpolationValues, options?: TranslateOptions) => string;
    /** Format a number using `Intl.NumberFormat` on the active locale. */
    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
    /** Format a Date using `Intl.DateTimeFormat` on the active locale. */
    formatDate: (value: Date | string, options?: Intl.DateTimeFormatOptions) => string;
    /** Build a new `I18n` instance pointing at a different locale. */
    withLocale: (locale: string) => I18n;
}

export declare interface I18nContextValue extends I18n {
    /** Switch the active locale. Persisted when `storageKey` is set. */
    setLocale: (locale: string) => void;
    /** Locales available in the catalog. */
    availableLocales: string[];
}

/**
 * React provider for the SDK's lightweight i18n. Exposes the translation
 * helpers and a `setLocale` setter to children.
 *
 * @tempest-limits empty-catch — remembering the chosen locale is best-effort. The
 * switch itself is React state and already happened by the time the write runs, so
 * a storage failure costs the preference on the next load and nothing in this one.
 */
export declare function I18nProvider({ children, locale: initialLocale, fallbackLocale, messages, storageKey, }: I18nProviderProps): JSX.Element;

export declare interface I18nProviderProps {
    children: ReactNode;
    /** Initial locale. */
    locale: string;
    /** Fallback locale used when a key is missing. */
    fallbackLocale?: string;
    /** Translation catalog. */
    messages: Catalog;
    /** localStorage key for persisting the user choice. Pass `null` to disable. Default: `"tempest-locale"`. */
    storageKey?: string | null;
}

/**
 * Renders an `<img>` with native lazy loading and a one-shot fallback.
 *
 * On the first load error the source is swapped to `fallback` (when provided),
 * guarded so a failing fallback cannot loop the `onError` handler.
 *
 * @param src - The primary image source URL.
 * @param fallback - Optional source used once when `src` fails to load.
 * @param alt - Accessible alternative text for the image.
 * @param lazy - Whether to use `loading="lazy"` (default `true`).
 * @returns The rendered image element.
 */
declare function Image_2({ src, fallback, alt, lazy, className, onError, ...props }: ImageProps): JSX.Element;
export { Image_2 as Image }

/**
 * Crop an image to a fixed aspect ratio.
 *
 * The frame stays put and the image pans and zooms behind it — the model an avatar
 * or document-photo flow wants, where the output shape is decided by the app and
 * the user only chooses what lands inside it. (A free-form draggable rectangle is a
 * different component; this one cannot produce an off-ratio crop by construction.)
 *
 * The export reads the *natural* pixels through a canvas, so a 4000 px photo is not
 * silently downsampled to whatever the on-screen preview measured. The image is
 * also always clamped to cover the frame, so an export can never contain the empty
 * bands you get from panning past an edge.
 *
 * Works by pointer, wheel and keyboard: arrows pan, `+`/`-` zoom, `0` resets.
 *
 * @example
 * const cropper = useRef<ImageCropperHandle>(null);
 *
 * <ImageCropper ref={cropper} src={file} aspect={1} shape="circle" maxSize={512} />
 * <Button onClick={async () => upload(await cropper.current?.crop())}>Salvar</Button>
 */
export declare function ImageCropper({ src, aspect, maxZoom, maxSize, outputType, outputQuality, shape, onCropChange, label, className, ref, ...rest }: ImageCropperProps): JSX.Element;

/** Imperative handle for exporting the current crop. */
export declare interface ImageCropperHandle {
    /**
     * Render the current crop and resolve with it.
     *
     * Resolves `null` when the image has not loaded yet or the browser refuses to
     * encode — never throws, so a submit handler does not need a try/catch.
     */
    crop: () => Promise<Blob | null>;
    /** Recentre at zoom 1. */
    reset: () => void;
}

export declare interface ImageCropperProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** The image to crop: a `File`/`Blob` from an input, or a URL. */
    src: File | Blob | string;
    /** Crop aspect ratio as `width / height`. Default `1` (square). */
    aspect?: number;
    /** Maximum zoom over the cover scale. Default `4`. */
    maxZoom?: number;
    /**
     * Cap on the longest edge of the exported image, in px.
     *
     * Without it the export keeps the source resolution, which is right for a
     * document scan and wasteful for an avatar.
     */
    maxSize?: number;
    /** Output MIME type. Default `"image/png"`. */
    outputType?: string;
    /** Output quality for lossy types, `0`–`1`. Default `0.92`. */
    outputQuality?: number;
    /** Overlay shape. `"circle"` for an avatar, `"rect"` for a document. Default `"rect"`. */
    shape?: "rect" | "circle";
    /** Called whenever the crop changes, e.g. to enable a submit button. */
    onCropChange?: (state: {
        zoom: number;
        offset: Offset;
    }) => void;
    /** Accessible name for the crop area. */
    label?: string;
    ref?: React.Ref<ImageCropperHandle>;
}

export declare interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> {
    /** Primary image source URL. */
    src: string;
    /** Fallback source swapped in once if the primary `src` fails to load. */
    fallback?: string;
    /** Alternative text describing the image (required for accessibility). */
    alt: string;
    /** When true (default) uses native lazy loading; otherwise loads eagerly. */
    lazy?: boolean;
}

/**
 * Records how long each stage of a pipeline took.
 *
 * Stages are measured **independently**, not as a tiling of the whole run:
 * two stages started concurrently are each charged their full wall-clock
 * span, so the sum can exceed {@link InferenceReport.totalMs}. That is the
 * honest reading for a pipeline that decodes an image while the model
 * sessions are still loading.
 */
export declare interface InferenceProfiler {
    /**
     * Run an async stage and record its duration.
     *
     * @param name Stage label used as the key in the report.
     * @param run The work to time.
     * @returns Whatever `run` resolved to.
     */
    stage<T>(name: string, run: () => Promise<T>): Promise<T>;
    /**
     * Run a synchronous stage and record its duration.
     *
     * @param name Stage label used as the key in the report.
     * @param run The work to time.
     * @returns Whatever `run` returned.
     */
    stageSync<T>(name: string, run: () => T): T;
    /**
     * Record a duration measured elsewhere — a `speed` breakdown returned by
     * `tempest-react-sdk/vision`, for instance.
     *
     * Repeated names accumulate, so folding two passes of the same kind into
     * one row is a matter of calling `mark` twice.
     *
     * @param name Stage label used as the key in the report.
     * @param durationMs How long it took, in milliseconds.
     */
    mark(name: string, durationMs: number): void;
    /**
     * Assemble the report for everything recorded so far.
     *
     * @param options Which models to size up in Cache Storage.
     * @returns The finished report.
     */
    report(options?: InferenceReportOptions): Promise<InferenceReport>;
}

/** What one profiled run cost. */
export declare interface InferenceReport {
    /** Duration in milliseconds per stage name, in the order first recorded. */
    timings: Readonly<Record<string, number>>;
    /** Milliseconds from profiler creation to the `report()` call. */
    totalMs: number;
    device: DeviceProfile;
    models: readonly ProfiledModelSize[];
    /** Epoch millis at which the report was assembled. */
    measuredAt: number;
}

/** Options for {@link InferenceProfiler.report}. */
export declare interface InferenceReportOptions {
    /** Models to measure in Cache Storage. Omit to report none. */
    models?: readonly ProfiledModel[];
}

export declare interface InMemoryFlagsOptions {
    initial?: Record<string, FlagValue>;
}

/**
 * Labelled text input with helper/error slots and optional adornment icons.
 * Forwards refs to the underlying `<input>` for integration with form libraries.
 */
export declare const Input: ForwardRefExoticComponent<InputProps & RefAttributes<HTMLInputElement>>;

export declare interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
    label?: string;
    helperText?: string;
    error?: string;
    leftIcon?: ReactNode;
    rightIcon?: ReactNode;
    wrapperClassName?: string;
    /** Visual size — drives height, padding and font via density-aware tokens. */
    size?: InputSize;
}

export declare type InputSize = "sm" | "md" | "lg";

/**
 * Report entry counts (and optionally byte sizes) for the Cache Storage
 * buckets whose name passes `filter`.
 *
 * @param options - `filter` narrows which caches to include; `measureBytes`
 *   (default `true`) reads each response to sum sizes — set `false` for a fast,
 *   count-only report.
 * @returns One {@link CacheReport} per matching cache. Empty when unsupported.
 *
 * @example
 * const reports = await inspectCaches({ filter: "tempest-" });
 * const totalMb = reports.reduce((n, r) => n + (r.bytes ?? 0), 0) / 1e6;
 */
export declare function inspectCaches(options?: {
    filter?: CacheFilter;
    measureBytes?: boolean;
}): Promise<CacheReport[]>;

/**
 * Install the background-sync queue: on a failed mutating request, the request
 * is serialized to IndexedDB and a sync is registered; the original fetch still
 * rejects (so your app can show an offline state), and the request is replayed
 * later when the network returns.
 *
 * @tempest-limits empty-catch — `registration.sync.register` is unavailable on
 * every non-Chromium browser and fails on a revoked background-sync permission.
 * The entry is already durable in IndexedDB at that point, and the queue is also
 * drained opportunistically on the next successful request, so losing the OS-level
 * wakeup degrades *when* the replay happens, not *whether* it happens.
 */
export declare function installBackgroundSync(options?: InstallBackgroundSyncOptions): void;

/**
 * Background-sync helper: queue failed mutating requests (POST/PUT/PATCH/DELETE)
 * while offline and replay them when connectivity returns. A dependency-free
 * take on Workbox's `BackgroundSyncPlugin`, backed by a tiny IndexedDB queue.
 *
 * Import inside your `sw.ts`. Uses the Background Sync API (`registration.sync`)
 * when available, and also replays opportunistically on the next request as a
 * fallback for browsers without it (e.g. Safari).
 *
 * @example
 *   import { installBackgroundSync } from "tempest-react-sdk/sw";
 *
 *   installBackgroundSync({ match: (url) => url.pathname.startsWith("/api/") });
 */
/** Options for {@link installBackgroundSync}. */
export declare interface InstallBackgroundSyncOptions {
    /**
     * Which requests to queue on failure. A `RegExp` against the URL or a
     * predicate. Only non-`GET` requests are ever considered. Default: all
     * non-`GET` requests.
     */
    match?: RegExp | ((url: URL, request: Request) => boolean);
    /** IndexedDB database name, also used as the sync tag. Default `tempest-bg-sync`. */
    queueName?: string;
    /** Drop queued requests older than this (minutes) on replay. Default `1440` (24h). */
    maxRetentionMinutes?: number;
    /**
     * Also drain the queue on the `periodicsync` event carrying this tag,
     * complementing the one-off `sync` replay so long-pending mutations retry
     * even without a fresh navigation. Register the periodic sync from the main
     * thread with {@link registerPeriodicSync}. Default `${queueName}-periodic`.
     */
    periodicSyncTag?: string;
}

/**
 * Dismissible bottom banner that invites the user to install the PWA, wired to
 * {@link useInstallPrompt}.
 *
 * Where the browser fires `beforeinstallprompt`, the button installs. Where it
 * does not — iOS Safari, and the Android Chromium forks that strip the API — the
 * banner shows that platform's instruction instead of disappearing. It used to
 * disappear: built on `useBeforeInstallPrompt`, it rendered `null` exactly where
 * the user has no other way to find the install entry, which is why every app
 * kept a local copy of this component just to add the two missing paths.
 *
 * @tempest-limits empty-catch — persisting the dismissal is a courtesy, not the
 * feature. When `localStorage` refuses the write (quota, private mode) the banner
 * still hides for this session; the worst case is that it comes back next visit,
 * which beats an error thrown out of a click handler that only closed a banner.
 *
 * @example
 * <InstallBanner
 *     title="Instale o FAMACHApp"
 *     description="Acesso offline e atalho na tela inicial."
 *     storageKey="famacha:install-dismissed"
 * />
 */
export declare function InstallBanner({ title, description, installLabel, hintLabel, dismissLabel, icon, storageKey, declineCooldownMs, renderHint, manualFallbackDelayMs, onResult, className, }: InstallBannerProps): JSX.Element | null;

export declare interface InstallBannerProps {
    /** Headline. Default `"Instale o app"`. */
    title?: ReactNode;
    /** Supporting copy under the title. */
    description?: ReactNode;
    /** Install button label. Default `"Instalar"`. */
    installLabel?: string;
    /** Accessible label for the dismiss button. Default `"Dispensar"`. */
    dismissLabel?: string;
    /** Optional leading icon. */
    icon?: ReactNode;
    /**
     * `localStorage` key used to remember dismissal across reloads. Omit to
     * make dismissal last only for the current session (component state).
     */
    storageKey?: string;
    /**
     * How long, in ms, a dismissal lasts before the banner may return.
     *
     * Omitted, a dismissal written to `storageKey` is permanent, which is what
     * the component always did and what a stored `"1"` keeps meaning. With a
     * cooldown the dismissal is stored as a timestamp instead, so the banner
     * comes back after the window — the same shape `useInstallPrompt` uses for
     * its own decline.
     */
    declineCooldownMs?: number;
    /**
     * Install button label used when the browser cannot be prompted and the
     * banner shows the manual instruction. Default `"Como instalar"`.
     */
    hintLabel?: string;
    /**
     * Replaces the instruction shown for the `"ios"` and `"manual"` methods.
     *
     * The default copy is in PT-BR and names the real menu entries.
     */
    renderHint?: RenderInstallHint;
    /**
     * How long, in ms, to wait for `beforeinstallprompt` before falling back to
     * the manual instruction. Forwarded to {@link useInstallPrompt}; defaults to
     * 3000 there.
     */
    manualFallbackDelayMs?: number;
    /** Called with the user's choice after the install prompt resolves. */
    onResult?: (outcome: InstallOutcome) => void;
    className?: string;
}

/**
 * Button wired to PWA installation, through {@link useInstallPrompt}.
 *
 * Where the browser fires `beforeinstallprompt`, the click installs. Where it
 * does not — iOS Safari, and the Android Chromium forks (Mi Browser, UC, Opera
 * Mini, Huawei) that strip the API — the click reveals the instruction for that
 * platform instead of the button disappearing.
 *
 * That disappearance was the defect: the component was built on
 * `useBeforeInstallPrompt`, so it rendered `null` exactly where the user needs
 * the most help, and every app re-implemented the iOS and manual paths locally.
 * Nothing renders only when there is genuinely nothing to offer — already
 * installed, running standalone, or inside the decline cooldown.
 *
 * Inherits every {@link Button} prop (`variant`, `size`, `leftIcon`, …).
 *
 * @example
 * <InstallButton variant="primary" leftIcon={<Download />} />
 *
 * @example
 * <InstallButton renderHint={({ method }) => (method === "ios" ? <IOSSteps /> : <MenuSteps />)} />
 */
export declare function InstallButton({ label, hintLabel, onResult, renderHint, manualFallbackDelayMs, wrapperClassName, ...props }: InstallButtonProps): JSX.Element | null;

export declare interface InstallButtonProps extends Omit<ButtonProps, "onClick" | "children"> {
    /** Button label. Default `"Instalar app"`. */
    label?: ReactNode;
    /**
     * Label used when the browser cannot be prompted and the button reveals the
     * manual instruction instead. Default `"Como instalar"`.
     */
    hintLabel?: ReactNode;
    /** Called with the user's choice after the install prompt resolves. */
    onResult?: (outcome: InstallOutcome) => void;
    /**
     * Replaces the instruction shown for the `"ios"` and `"manual"` methods.
     *
     * The default copy is in PT-BR and names the real menu entries. Pass this to
     * translate it, to shorten it, or to point at a screenshot of your own.
     */
    renderHint?: RenderInstallHint;
    /**
     * How long, in ms, to wait for `beforeinstallprompt` before falling back to
     * the manual instruction. Forwarded to {@link useInstallPrompt}; defaults to
     * 3000 there.
     */
    manualFallbackDelayMs?: number;
    /** Class applied to the wrapper that holds the button and the instruction. */
    wrapperClassName?: string;
}

/** What an install affordance needs to render the instruction for a method. */
export declare interface InstallHintInput {
    /** The strategy `useInstallPrompt` resolved. */
    method: InstallMethod;
    /** An `intent://` URL that re-opens the page in Chrome on Android, if any. */
    openInChromeIntent: string | null;
}

/**
 * Strategy the UI should use to install the app:
 *
 * - `"native"`: trigger `BeforeInstallPromptEvent.prompt()`.
 * - `"ios"`: show iOS Safari Share → Add to Home Screen instructions.
 * - `"manual"`: show generic browser-menu instructions (Chromium forks that
 *   strip the prompt API, plus the timeout fallback when no event arrives).
 * - `"none"`: nothing to offer (already installed or unsupported runtime).
 */
export declare type InstallMethod = "native" | "ios" | "manual" | "none";

/**
 * Install a `notificationclick` handler that focuses an existing client when
 * possible and falls back to opening a new window.
 */
export declare function installNotificationClickHandler(options?: InstallNotificationClickHandlerOptions): void;

export declare interface InstallNotificationClickHandlerOptions {
    /** Resolve the destination URL from the notification data. Default: `data.url`. */
    resolveUrl?: (data: unknown) => string;
}

export declare type InstallOutcome = "accepted" | "dismissed" | "unsupported";

/**
 * Precache the app shell at `install` and serve it offline:
 *  - reads `precache-manifest.json` (emitted by `tempestPwaManifest()`),
 *  - caches every listed URL under a versioned cache,
 *  - on `activate`, deletes stale precache versions and claims open clients,
 *  - on `fetch`, serves precached assets cache-first and falls back to the
 *    `navigateFallback` document for offline navigations (SPA routing).
 *
 * Same-origin only. Register this LAST, after any {@link installRuntimeCache}.
 */
export declare function installPrecache(options?: InstallPrecacheOptions): void;

/** Options for {@link installPrecache}. */
export declare interface InstallPrecacheOptions {
    /** URL of the manifest emitted by `tempestPwaManifest()`. Default `/precache-manifest.json`. */
    manifestUrl?: string;
    /** Cache name prefix; the manifest `version` is appended. Default `tempest-precache`. */
    cacheName?: string;
    /** App-shell document served for navigation requests offline. Default `/index.html`. */
    navigateFallback?: string;
    /** Navigation paths that should NOT use the fallback (e.g. `[/^\/api\//]`). */
    navigateFallbackDenylist?: RegExp[];
    /** Activate the new worker immediately after precaching. Default `true`. */
    skipWaiting?: boolean;
    /**
     * Enable the Navigation Preload API on `activate`, so the browser fetches
     * the navigation request in parallel with the worker boot and the handler
     * serves `event.preloadResponse` — cutting first-navigation latency after
     * the worker starts. Silently ignored where unsupported. Default `true`.
     */
    navigationPreload?: boolean;
}

/**
 * Install a `push` event listener that parses the payload as JSON (with a
 * plain-text fallback) and shows a notification.
 */
export declare function installPushHandler(options?: InstallPushHandlerOptions): void;

export declare interface InstallPushHandlerOptions {
    /** Title used when the payload omits one. */
    defaultTitle?: string;
    /** Icon used when the payload omits one. */
    defaultIcon?: string;
    /** Badge image (mobile). */
    defaultBadge?: string;
    /**
     * Transform the raw payload before showing the notification. Return `null`
     * to suppress the notification entirely (e.g. silent pings).
     */
    transform?: (payload: PushPayload) => PushPayload | null;
}

/**
 * Install a `fetch` handler that resolves matching `GET` requests with the
 * given runtime strategies. Non-matching requests are left untouched (no
 * `respondWith`), so a later {@link installPrecache} can handle them.
 *
 * Register this BEFORE `installPrecache` so specific routes win over the
 * precache catch-all.
 *
 * @param routes Ordered rules; the first whose `match` passes handles the request.
 */
export declare function installRuntimeCache(routes: RuntimeRoute[]): void;

/**
 * Install a `message` listener that activates a waiting worker when the host
 * app sends `{ type: "SKIP_WAITING" }`.
 */
export declare function installSkipWaitingListener(): void;

export declare type InterpolationValues = Record<string, string | number>;

/**
 * Detects any Android browser.
 *
 * @returns `true` when the user agent reports Android.
 */
export declare function isAndroid(): boolean;

/**
 * Detects Android browsers that ship a Chromium fork with the
 * `beforeinstallprompt` event stripped or unreliable. Those users must install
 * via the browser menu manually, identical to iOS Safari.
 *
 * @returns `true` when running on such an Android browser.
 */
export declare function isAndroidWithoutPromptApi(): boolean;

/**
 * Type guard for the {@link ApiError} shape. Matches both {@link TempestApiError}
 * instances and plain objects carrying `status` + `detail`.
 *
 * @param error - The unknown value (typically a caught error).
 * @returns Whether `error` conforms to the `ApiError` contract.
 */
export declare function isApiError(error: unknown): error is ApiError;

/**
 * Whether this browser can route audio to a chosen output device.
 *
 * Chromium-only at the time of writing: Firefox has `setSinkId` behind a preference
 * that is off by default, and Safari does not implement it at all. Check this before
 * rendering an output picker, or the control is a lie on two of three engines.
 */
export declare function isAudioOutputSelectionSupported(): boolean;

/** Whether `MediaRecorder` exists and can produce at least one audio container. */
export declare function isAudioRecordingSupported(): boolean;

/**
 * Whether this browser can decode barcodes on its own.
 *
 * **Expect `false` on a lot of real devices, and design for it.** `BarcodeDetector` is
 * a Chromium-only API backed by a platform decoder, so it is there on Android and
 * ChromeOS, usually there on macOS, and **absent** on Chromium for Windows and Linux,
 * in Firefox, and in every browser on iOS (all of which are WebKit underneath,
 * including Chrome for iOS).
 *
 * This SDK ships **no** decoder of its own and no bundled fallback: a QR reader is
 * Reed–Solomon error correction plus perspective correction plus a finder-pattern
 * search, and the honest options are a WASM build every consumer of this SDK would pay
 * for, or nothing. So the escape hatch is injection instead — pass any
 * {@link BarcodeDetectorLike} (the `barcode-detector` polyfill, your own `zxing-wasm`
 * wrapper) as `detector` to `useBarcodeScanner`, and the SDK drives it exactly like
 * the native one.
 *
 * @returns `true` when `new BarcodeDetector()` will work.
 */
export declare function isBarcodeDetectionSupported(): boolean;

/**
 * Whether autofill-driven passkeys (`mediation: "conditional"`) are available.
 *
 * @returns `false` when the API is missing or throws.
 */
export declare function isConditionalMediationAvailable(): Promise<boolean>;

/**
 * Type guard for {@link Coordinate}: an object with finite, in-range
 * `latitude` and `longitude`.
 */
export declare function isCoordinate(value: unknown): value is Coordinate;

/**
 * Type guard for a {@link CursorPage} envelope.
 *
 * @param value - The unknown value to test.
 * @returns Whether it carries `items` + `has_more` + a `next_cursor` key.
 */
export declare function isCursorPage<T = unknown>(value: unknown): value is CursorPage<T>;

/**
 * Type guard asserting a value is neither `null` nor `undefined`.
 *
 * Useful for narrowing in `Array.prototype.filter` to drop nullish entries
 * while preserving the element type.
 *
 * @example
 * const xs: (number | null)[] = [1, null, 2];
 * const clean: number[] = xs.filter(isDefined); // [1, 2]
 */
export declare function isDefined<T>(value: T | null | undefined): value is T;

/**
 * Check whether a value is considered "empty".
 *
 * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty
 * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers
 * (including `0` and `NaN`), booleans, and dates, which are never empty.
 *
 * @example
 * isEmpty(null);       // true
 * isEmpty("");         // true
 * isEmpty([]);         // true
 * isEmpty({});         // true
 * isEmpty(new Map());  // true
 * isEmpty(0);          // false
 * isEmpty(false);      // false
 * isEmpty(new Date()); // false
 */
export declare function isEmpty(value: unknown): boolean;

/**
 * Whether this environment can present anything fullscreen at all.
 *
 * Two independent reasons for `false`, and skipping either one ships a button
 * that does nothing when pressed: the API can be missing (older WebKit, and every
 * browser on iOS for non-`<video>` elements), or present and **disabled** — a
 * document inside an `<iframe>` without the `allowfullscreen` attribute exposes
 * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`
 * reports up front.
 *
 * An engine that exposes the methods and no flag at all is treated as capable:
 * the flag is the newer half of the API, so its absence says nothing.
 *
 * @returns `true` when a fullscreen request stands a chance of being honoured.
 */
export declare function isFullscreenSupported(): boolean;

/** Whether any turn in the thread is still streaming. */
export declare function isGenerating(messages: readonly AIChatMessage[]): boolean;

/**
 * Detects iOS / iPadOS Safari, including modern iPads that report `MacIntel`
 * plus multi-touch instead of an `iPad` user agent.
 *
 * @returns `true` when running on iOS/iPadOS.
 */
export declare function isIOS(): boolean;

/**
 * Return true when the JWT's `exp` claim is in the past (or missing).
 *
 * @param token - JWT to inspect.
 * @param leewaySeconds - Treat tokens expiring within this window as expired.
 */
export declare function isJWTExpired(token: string, leewaySeconds?: number): boolean;

/**
 * Whether `getUserMedia` is reachable at all.
 *
 * Separate from the classifier because a page often wants to hide a "record" button
 * entirely rather than render it and fail on click.
 */
export declare function isMediaCaptureSupported(): boolean;

/**
 * Type guard asserting a value is a number, excluding `NaN`.
 *
 * @example
 * isNumber(42);       // true
 * isNumber(NaN);      // false
 * isNumber("42");     // false
 */
export declare function isNumber(value: unknown): value is number;

/**
 * Type guard for an {@link OffsetPage} envelope.
 *
 * @param value - The unknown value to test.
 * @returns Whether it carries `items` + `total` + `page` + `pages`.
 */
export declare function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T>;

/**
 * Whether this browser exposes WebAuthn at all.
 *
 * Note that "supported" is not "usable": WebAuthn also requires a secure context,
 * and a device may have no authenticator. Use
 * {@link isPlatformAuthenticatorAvailable} before offering a passkey button.
 */
export declare function isPasskeySupported(): boolean;

/**
 * Type guard asserting a value is a plain object literal.
 *
 * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —
 * only objects created from `{}` / `Object.create(null)` / object literals pass.
 *
 * @example
 * isPlainObject({ a: 1 });     // true
 * isPlainObject([]);           // false
 * isPlainObject(null);         // false
 * isPlainObject(new Date());   // false
 */
export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

/**
 * Whether the device has a **built-in** authenticator — Face ID, Touch ID,
 * Windows Hello, an Android screen lock.
 *
 * This is the check that decides whether "Entrar com passkey" may be shown at
 * all. `isPasskeySupported()` is true on a desktop with no biometrics and no
 * security key, and offering a passkey there sends the user into a sheet that can
 * only be cancelled. A `false` here does not forbid passkeys — a phone can still
 * be used over hybrid/QR — it means the flow needs a second step, so present it
 * as "usar meu celular", not as one tap.
 *
 * @returns `false` when the API is missing, so a caller never has to null-check.
 */
export declare function isPlatformAuthenticatorAvailable(): Promise<boolean>;

/**
 * Convenience check for environments where the Push API is unavailable
 * (Safari iOS without PWA install, older browsers, SSR, etc.).
 */
export declare function isPushSupported(): boolean;

/**
 * Whether a close code means the server refused this client for good.
 *
 * @param code - The `CloseEvent.code`.
 * @returns `true` when reconnecting can only reproduce the refusal.
 *
 * @example
 * isRejectionCloseCode(4401); // true — unauthorized
 * isRejectionCloseCode(4408); // false — heartbeat timeout, retry it
 */
export declare function isRejectionCloseCode(code: number): boolean;

/**
 * Whether an HTTP status describes a condition a replay can plausibly fix.
 *
 * The single owner of that decision. It used to be spelled out in three places —
 * the client's own policy, the react-query default and the bare `retry()` helper
 * — and they had already drifted: the query default was missing `425`, so the
 * same `425 Too Early` was replayed through `createApiClient({ retry: true })`
 * and not replayed through `useQuery`. Same app, same error, two behaviours, and
 * no test caught it because each file asserted against its own copy.
 *
 * Deliberately about the status and nothing else. Whether a *non*-API error is
 * worth replaying, and whether the request's method may be replayed at all, are
 * the caller's calls: {@link createApiClient} refuses a non-idempotent method,
 * while a bare `retry()` has no method to inspect.
 *
 * @example
 * await api.get("/report", {
 *     retry: { shouldRetry: (error) => isApiError(error) && isRetriableStatus(error.status) },
 * });
 *
 * @param status - The HTTP status, where `0` means the request never landed.
 * @returns Whether a retry is worth attempting.
 */
export declare function isRetriableStatus(status: number): boolean;

/** Whether `getDisplayMedia` is reachable at all. */
export declare function isScreenCaptureSupported(): boolean;

/** True when the Web Share API is available in this environment. */
export declare function isShareSupported(): boolean;

/** Whether this browser exposes the Web Speech recognition API at all. */
export declare function isSpeechRecognitionSupported(): boolean;

/**
 * Reports whether the app is running as an installed PWA (Android Chrome, iOS,
 * or desktop). Use it to suppress install CTAs once the user is already in the
 * standalone shell.
 *
 * @returns `true` when the display mode is standalone or iOS reports standalone.
 */
export declare function isStandalone(): boolean;

/**
 * Type guard asserting a value is a string primitive.
 *
 * @example
 * isString("hi"); // true
 * isString(42);   // false
 */
export declare function isString(value: unknown): value is string;

/** A path segment as Standard Schema reports it: a key, or an object holding one. */
declare type IssuePathSegment = PropertyKey | {
    readonly key: PropertyKey;
};

/**
 * Whether a request to `target` may carry the caller's credential.
 *
 * The SDK writes `Authorization: Bearer` in three places, and until 0.66.0 none
 * of them looked at where the request was going. That is only safe while every
 * target URL is written by the app: a resumable upload takes its URL from the
 * server's `Location` header, and `createApiClient` lets an absolute path
 * override `baseURL` entirely, so a URL arriving over the network could decide
 * which origin received the token — and the file bytes with it.
 *
 * Handing an upload off to object storage on another host is ordinary `tus`
 * deployment, not an attack, which is exactly why the credential must be scoped
 * rather than the request blocked: the upload still goes through, it just goes
 * without the API's bearer token.
 *
 * Both sides are resolved against the document first, so a relative `baseURL`
 * or `endpoint` — the shape behind a dev-server or reverse proxy — compares
 * equal to the absolute URL the request actually goes to. Outside a browsing
 * context a relative target resolves to nothing and is allowed: there is no
 * origin for it to cross.
 *
 * @param target - The URL the request is about to go to.
 * @param reference - The origin the credential belongs to, normally the
 *     client's `baseURL` or the upload `endpoint`.
 * @param trustedOrigins - Extra origins the app declared, for the legitimate
 *     second host: a CDN, a signed upload endpoint.
 * @returns Whether the credential may be attached.
 *
 * @example
 * isTrustedCredentialTarget("https://api.acme.com/me", "https://api.acme.com");
 * // true
 * isTrustedCredentialTarget("https://cdn.other/u/1", "https://api.acme.com");
 * // false
 */
export declare function isTrustedCredentialTarget(target: string, reference: string, trustedOrigins?: readonly string[]): boolean;

/** True when `value` is a finite latitude in `[-90, 90]`. */
export declare function isValidLatitude(value: number): boolean;

/** True when `value` is a finite longitude in `[-180, 180]`. */
export declare function isValidLongitude(value: number): boolean;

/** Whether `MediaRecorder` exists and can produce at least one video container. */
export declare function isVideoRecordingSupported(): boolean;

/**
 * Whether any of this would change the signal.
 *
 * A chain that only passes audio through still costs a re-encode and a handful of
 * nodes, so a caller that rebuilds on every settings change should ask first —
 * and {@link createVoiceChain} asks too, handing back `source` rather than
 * building a graph that does nothing.
 *
 * @param settings - The stages under consideration.
 * @param gain - The output multiplier that would be applied. Default `1`.
 * @returns `true` when the chain would be audibly transparent.
 */
export declare function isVoiceChainIdle(settings: VoiceChainSettings, gain?: number): boolean;

/** The surface every store built by {@link createJsonStorage} exposes. */
export declare interface JsonStorage {
    /**
     * Read and decode a key.
     *
     * The value is decoded by the store's codec — JSON for {@link storage} —
     * which is what makes a key written as a bare string unreadable here: it is
     * not the shape this method writes. {@link JsonStorage.getRaw} reads those.
     *
     * @typeParam T - The expected value shape.
     * @param key - Storage key.
     * @param fallback - Returned when the key is absent, unreadable, or corrupt.
     * @returns The stored value, or `fallback`.
     */
    get<T>(key: string, fallback: T): T;
    /**
     * Encode and write a key.
     *
     * The value is **encoded** — `set("theme", "dark")` stores `"dark"` with the
     * quotes, not `dark`. That matters when an existing key is being adopted:
     * whatever read it before will no longer recognise what this writes, and the
     * old value will no longer parse here. {@link JsonStorage.setRaw} is the
     * passthrough.
     *
     * @typeParam T - The value being stored.
     * @param key - Storage key.
     * @param value - Any value the codec can represent.
     */
    set<T>(key: string, value: T): void;
    /**
     * Read a key exactly as `localStorage` holds it, with no decoding.
     *
     * The escape hatch {@link JsonStorage.get} cannot be: `get` runs the codec,
     * so a key holding a bare `dark` — written by another library, by the app
     * before it adopted this wrapper, or by the SDK's own `ThemeProvider` —
     * fails to parse and comes back as the fallback. Reading that key is a
     * different operation, not a variant of the same one.
     *
     * @param key - Storage key.
     * @returns The stored string, or `null` when the key is absent or storage is
     *   unavailable.
     */
    getRaw(key: string): string | null;
    /**
     * Write a string exactly as given, with no encoding.
     *
     * The counterpart of {@link JsonStorage.getRaw}, and what keeps adoption from
     * being a silent migration: `set("theme", "dark")` stores `"dark"` **with the
     * quotes**, which the app's previous reader no longer recognises.
     *
     * @param key - Storage key.
     * @param value - The exact string to store.
     */
    setRaw(key: string, value: string): void;
    /**
     * Delete a key.
     *
     * @param key - Storage key.
     */
    remove(key: string): void;
}

/**
 * Kanban board: columns of cards, reorderable within a column and movable across
 * columns, by pointer **or** keyboard.
 *
 * The drag machine is `useSortable` — the board does not reimplement it. Cards are
 * indexed globally across columns so a single sortable can span the whole board;
 * the component translates that flat index back into `{ column, index }` for
 * `onMove`, which is the shape an app actually needs.
 *
 * Nothing is mutated here: `onMove` reports the intent once and the parent applies
 * it. That keeps the board a controlled value and avoids a re-render per pointer
 * frame.
 *
 * ARIA shape: **one `listbox` per column**, named by the column title, containing
 * only `option` cards. A single board-wide listbox does not survive the markup a
 * board needs — `listbox` requires `option`/`group` children, and the column header
 * and card wrapper in between break that ownership. Per-column listboxes also read
 * better: a screen reader announces which column it is in and how many cards it
 * holds. The column header is a plain `div`, not a `<header>`, because outside a
 * sectioning element every `<header>` becomes a page-level banner landmark — with
 * three columns that is three duplicate banners. An **empty** column is not marked
 * as a listbox at all: a listbox with zero options fails `aria-required-children`,
 * and "no cards" is exactly zero options.
 *
 * Known limitation: a **keyboard** move can only target positions that hold a card,
 * because the move walks the flat index space of existing cards. Dropping into an
 * empty column works by pointer; by keyboard it does not. Moving a card to a column
 * that already has one card, then reordering, is the workaround until column-switch
 * keys land.
 *
 * @example
 * ```tsx
 * const [columns, setColumns] = useState<KanbanColumn[]>([
 *   { id: "todo", title: "A fazer", cards: [{ id: "1", content: "Corrigir login" }] },
 *   { id: "doing", title: "Fazendo", cards: [] },
 *   { id: "done", title: "Feito", cards: [], locked: true },
 * ]);
 *
 * <Kanban
 *   columns={columns}
 *   onMove={({ cardId, fromColumn, toColumn, toIndex }) =>
 *     setColumns((current) => applyKanbanMove(current, { cardId, fromColumn, toColumn, toIndex }))
 *   }
 * />
 * ```
 */
export declare function Kanban({ columns, onMove, renderCard, emptyLabel, cardRoleDescription, label, disabled, className, }: KanbanProps): JSX.Element;

/** One card on the board. */
export declare interface KanbanCard {
    /** Stable identifier, unique across the whole board. */
    id: string;
    /** Card body. A string renders as the card's title. */
    content: ReactNode;
}

/** One column of the board. */
export declare interface KanbanColumn {
    /** Stable identifier, used as the drop group. */
    id: string;
    /** Column heading. */
    title: ReactNode;
    /** Cards in display order. */
    cards: KanbanCard[];
    /**
     * Refuses drops into this column. The cards inside can still be picked up and
     * moved elsewhere — a "done" column that no longer accepts work, for instance.
     */
    locked?: boolean;
}

/** Where a card ended up. */
export declare interface KanbanMove {
    cardId: string;
    fromColumn: string;
    toColumn: string;
    /** Index within the destination column. */
    toIndex: number;
}

export declare interface KanbanProps {
    columns: KanbanColumn[];
    /**
     * Called once per committed move — on pointer release or on a keyboard drop.
     * You own the data: apply the move and pass the new `columns` back.
     */
    onMove: (move: KanbanMove) => void;
    /** Renders a card. Defaults to its `content`. */
    renderCard?: (card: KanbanCard, column: KanbanColumn) => ReactNode;
    /** Text shown in a column with no cards. */
    emptyLabel?: ReactNode;
    /** Announced per card, so a screen reader user learns the keyboard contract. */
    cardRoleDescription?: string;
    /**
     * Accessible name of the board. A `listbox` without a name is unusable with a
     * screen reader, so this has a default rather than being optional in practice.
     */
    label?: string;
    /** Blocks all dragging. */
    disabled?: boolean;
    className?: string;
}

/**
 * Renders a `<kbd>` styled like a keyboard key — useful for shortcut hints.
 * Compose multiple keys by rendering siblings: `<Kbd>Ctrl</Kbd> + <Kbd>K</Kbd>`.
 */
export declare function Kbd({ size, className, children, ...props }: KbdProps): JSX.Element;

export declare interface KbdProps extends HTMLAttributes<HTMLElement> {
    size?: KbdSize;
}

export declare type KbdSize = "sm" | "md" | "lg";

/**
 * Convert `value` to `kebab-case`.
 *
 * Splits camelCase boundaries and non-alphanumeric runs, then joins with `-`
 * and lowercases.
 *
 * @example
 * kebabCase("helloWorld");   // "hello-world"
 * kebabCase("foo_bar baz");  // "foo-bar-baz"
 * kebabCase("APIResponse");  // "api-response"
 */
export declare function kebabCase(value: string): string;

export declare interface KeyboardShortcut {
    /** Key name (`"k"`, `"Enter"`, `"Escape"`, `"ArrowDown"`, etc.). Case-insensitive. */
    key: string;
    ctrl?: boolean;
    meta?: boolean;
    shift?: boolean;
    alt?: boolean;
    /** Match either Ctrl or Cmd. Useful for cross-OS shortcuts. */
    mod?: boolean;
}

declare type KeyBuilder = (...args: any[]) => readonly unknown[];

/**
 * A form `<label>`. Associate it with a control via `htmlFor`. When `required`
 * is set, a decorative asterisk (`aria-hidden`) is appended.
 *
 * @param props - {@link LabelProps}.
 * @returns The label element.
 */
export declare const Label: ForwardRefExoticComponent<LabelProps & RefAttributes<HTMLLabelElement>>;

export declare interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
    /** When `true` appends a danger-colored asterisk marking the field as required. */
    required?: boolean;
}

/**
 * Id of the newest assistant turn, or `null` when there is none.
 *
 * Only that turn gets the regenerate control: re-asking an older one would throw
 * away every turn after it, which is a different operation ("branch here") and
 * needs its own confirmation.
 */
export declare function lastAssistantId(messages: readonly AIChatMessage[]): string | null;

/**
 * Conflict-resolution helpers for the `applyRemote` callback of
 * {@link createOfflineSync}. Each takes the current local record (or
 * `undefined` when the record is new locally) and the incoming remote record,
 * and returns the winner. Ties resolve to the remote copy, treating the server
 * as authoritative.
 */
/**
 * Resolve a conflict by keeping whichever record was written last, comparing a
 * timestamp field. The remote record wins ties.
 *
 * @typeParam T - The record shape.
 * @param local - The current local record, or `undefined` when new.
 * @param remote - The incoming remote record.
 * @param getTimestamp - Reads the comparison timestamp (epoch ms, ISO string or `Date`).
 * @returns The winning record.
 *
 * @example
 * applyRemote: async (dto) => {
 *     const local = await store.get(dto.id);
 *     await store.save(lastWriteWins(local, dto, (r) => r.updatedAt));
 * }
 */
export declare function lastWriteWins<T>(local: T | undefined, remote: T, getTimestamp: (record: T) => number | string | Date): T;

declare interface LayoutProps {
    /** Field arrangement. `stack` stacks fields vertically, `inline` lines them up in a wrapping row, `grid` arranges them in `columns` equal-width tracks. Default `stack`. */
    layout?: FormLayout;
    /** Number of columns when `layout="grid"`, or a custom `grid-template-columns` value. Default `2`. */
    columns?: number | string;
    /** Gap between fields. Numbers map to a multiple of the 4px scale (default `4` → 16px). */
    gap?: number | string;
}

/**
 * Wrap `React.lazy` with automatic retry and a `preload()` method.
 *
 * Common cause of failure: deployed-then-cached `index.html` references chunk
 * filenames that no longer exist. Retrying after a short delay typically picks
 * up the new bundle; a final `location.reload()` recovers from stale
 * `index.html`.
 *
 * The wrapped component keeps its own props: `T` is inferred from the module
 * the factory resolves to, so a page declaring required, optional or no props
 * all pass through and the rendered element is still checked against them. See
 * {@link AnyComponent} for why the constraint has to be written the way it is.
 *
 * @param factory Dynamic import of the module whose `default` is the component.
 * @param options Retry count, initial backoff and the final-failure reload.
 * @returns The lazy component, carrying an extra `preload()`.
 *
 * @example
 * const Settings = lazyWithRetry(() => import("./Settings"));
 *
 * // Warm the chunk when the route becomes likely, not when it is needed.
 * <a href="/settings" onMouseEnter={() => void Settings.preload()}>Settings</a>
 */
export declare function lazyWithRetry<T extends AnyComponent>(factory: () => Promise<{
    default: T;
}>, options?: LazyWithRetryOptions): PreloadableLazy<T>;

export declare interface LazyWithRetryOptions {
    /** Max attempts. Default: 3. */
    retries?: number;
    /** Initial delay (ms) before retrying. Default: 400. */
    initialDelay?: number;
    /**
     * Reload the page after every retry fails. Helps when the stale chunk
     * error is caused by an old `index.html` referencing deleted bundles.
     * Default: true.
     */
    reloadOnFinalFailure?: boolean;
}

/**
 * Minimal subset of [`launchdarkly-js-client-sdk`](https://docs.launchdarkly.com/sdk/client-side/javascript)
 * used by the adapter. Pass an existing `LDClient`.
 */
export declare interface LDClientLike {
    variation: <T = unknown>(key: string, defaultValue: T) => T;
    on?: (event: string, handler: () => void) => void;
    off?: (event: string, handler: () => void) => void;
}

/** A running level meter. */
export declare interface LevelMeter {
    /** Latest level, 0–1. Read it on your own frame loop. */
    level: () => number;
    /** Stop sampling and release the Web Audio graph. */
    stop: () => void;
}

/** Options for {@link createLevelMeter}. */
export declare interface LevelMeterOptions {
    /**
     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable
     * and short enough to react to a syllable.
     */
    fftSize?: number;
    /**
     * Extra smoothing on the way down, 0–1. Default `0.7`.
     *
     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left
     * instant — a meter that lags the voice going *up* reads as "not recording" —
     * while the decay is eased, which is how every hardware meter behaves.
     *
     * `0` turns the smoothing off and reports the window's RMS as measured, which is
     * what a detector wants: {@link monitorVoiceActivity} applies its own release,
     * and two of them stacked would hold the indicator open long past the speech.
     */
    decay?: number;
    /**
     * Reuse an existing `AudioContext` instead of creating one.
     *
     * Browsers cap live contexts (Chrome allows around six), and a meter per remote
     * participant reaches that in a five-person call. A caller measuring several
     * streams should open one context and hand it to every meter. `stop()` closes
     * only a context this meter created — an injected one belongs to the caller.
     */
    context?: AudioContext;
}

/**
 * Full-screen image viewer with keyboard navigation.
 *
 * `Esc` closes, `←`/`→` walk the gallery, `Home`/`End` jump to the ends. Focus is
 * trapped inside while open and the page behind is scroll-locked, so the overlay
 * behaves like the dialog it is instead of a fancy `<div>` the keyboard can escape.
 *
 * Only the current image is mounted; neighbours are **preloaded** via `Image()` so
 * pressing `→` does not flash an empty frame.
 *
 * @example
 * ```tsx
 * const [open, setOpen] = useState(false);
 * const [index, setIndex] = useState(0);
 *
 * <Lightbox
 *   open={open}
 *   items={photos.map((p) => ({ src: p.url, alt: p.description }))}
 *   index={index}
 *   onIndexChange={setIndex}
 *   onClose={() => setOpen(false)}
 * />
 * ```
 */
export declare function Lightbox({ items, open, index, onIndexChange, onClose, showThumbnails, showCounter, loop, closeLabel, previousLabel, nextLabel, className, }: LightboxProps): JSX.Element | null;

/** One item of the gallery. */
export declare interface LightboxItem {
    /** Full-size image URL. */
    src: string;
    /** Alt text. Required: a gallery of unlabeled images is unusable with a screen reader. */
    alt: string;
    /** Caption rendered under the image. */
    caption?: string;
    /** Thumbnail URL for the strip. Falls back to `src`. */
    thumbnail?: string;
}

export declare interface LightboxProps {
    items: LightboxItem[];
    /** Whether the overlay is open. */
    open: boolean;
    /** Index shown while open. Default `0`. */
    index?: number;
    onIndexChange?: (index: number) => void;
    onClose: () => void;
    /** Renders the thumbnail strip. Default `true` when there is more than one item. */
    showThumbnails?: boolean;
    /** Renders the `3 / 12` counter. Default `true`. */
    showCounter?: boolean;
    /**
     * Wrap around at the ends. Default `true` — in a photo viewer, hitting a dead
     * end at the last image reads as a bug more often than as a boundary.
     */
    loop?: boolean;
    closeLabel?: string;
    previousLabel?: string;
    nextLabel?: string;
    className?: string;
}

/** Shape of the master limiter. Matches `DynamicsCompressorNode`'s params. */
export declare interface LimiterSettings {
    /** dBFS above which the compressor starts working. */
    threshold: number;
    /** dB range over which the curve bends. `0` is a hard knee. */
    knee: number;
    /** Input/output ratio above the threshold. 20 is limiting, not compression. */
    ratio: number;
    /** Seconds to clamp a peak. */
    attack: number;
    /** Seconds to let go. */
    release: number;
}

export { Link }

/**
 * One link's outbound picture, in the shape a call UI actually renders.
 *
 * Everything here is derived, not reported: WebRTC hands out cumulative
 * counters and a graph of candidate pairs, and turning that into
 * `"1,2 Mbps · 42 ms · 1080p60"` is the work {@link createLinkStatsSampler}
 * does.
 */
export declare interface LinkStats {
    /** Throughput since the previous sample. `0` on the first one — there is no delta yet. */
    kbps: number;
    /** Width of the largest stream being sent, or `0` before one is reported. */
    width: number;
    /** Height of the largest stream being sent, or `0` before one is reported. */
    height: number;
    /** Frame rate of the largest stream being sent, or `0` when the browser omits it. */
    fps: number;
    /** Round trip to the peer in milliseconds, or `null` before the first reading. */
    rttMs: number | null;
    /**
     * Uplink the transport estimates for this path, in kbps, or `null`.
     *
     * `null` and not `0`, because the two mean opposite things: no estimate yet
     * is the normal state for the first seconds of every call and the permanent
     * state on an engine that publishes none, while `0` is indistinguishable
     * from a path that died. A consumer that reads absence as zero drops the
     * quality at the start of every call.
     *
     * This is the field that separates "healthy at 2.5 Mbps" from "capped at
     * 2.5 Mbps and drowning" — `kbps` reports the cap being honoured either
     * way, while the queue behind it grows.
     */
    availableKbps: number | null;
    /**
     * What the encoder says is holding the picture back, or `null` for nothing.
     *
     * `"bandwidth"` wins over the other values when senders disagree, because
     * it is the only one a lower cap answers. Reacting to bandwidth on a
     * machine that is actually CPU-bound buys a worse picture and no relief.
     *
     * The spec's `"none"` is reported as `null`: a consumer should not have to
     * know that one of the truthy strings means "nothing".
     */
    limitedBy: RTCQualityLimitationReason | null;
    /**
     * Whether the link is travelling through a TURN relay.
     *
     * On a self-hosted mesh this is the hosting bill: a relayed stream goes up
     * and down through the machine somebody is paying for, and the person who
     * picked 4K is not that somebody.
     *
     * Resolved only from the pair the transport **names**, never from a merely
     * `succeeded` one — guessing the route from a pair that carries nothing
     * would report a cost nobody is paying.
     */
    relayed: boolean;
}

/** Which media a sampler counts. */
export declare type LinkStatsKind = "video" | "audio" | "all";

/**
 * A sampler bound to one connection.
 *
 * Holds the previous byte counter and timestamp, which is the whole reason this
 * is an object rather than a function: the rate is a delta, so somebody has to
 * remember the last reading. One sampler per link — sharing one across peers
 * subtracts one connection's counter from another's and reports nonsense.
 */
export declare interface LinkStatsSampler {
    /**
     * Reduce a report you already have.
     *
     * @param report - A report from `RTCPeerConnection.getStats()`.
     * @returns The stats for this sample.
     */
    read: (report: RTCStatsReport) => LinkStats;
    /**
     * Fetch a report and reduce it.
     *
     * @param connection - The connection to sample.
     * @returns The stats for this sample.
     */
    sample: (connection: RTCPeerConnection) => Promise<LinkStats>;
    /**
     * Drop the baseline the rate is derived from.
     *
     * Call it after an ICE restart, a reconnect, or a pause — otherwise the next
     * sample divides the bytes of the whole gap by the whole gap and reports the
     * average of a period nobody is asking about. The next reading comes back at
     * `0` kbps and starts a fresh baseline; the resolution and round trip already
     * on screen are kept, so the badge does not blank out.
     */
    reset: () => void;
}

/** Options for {@link createLinkStatsSampler}. */
export declare interface LinkStatsSamplerOptions {
    /**
     * Which media the throughput counts. Default `"video"`.
     *
     * Video is the default because it is what saturates an uplink — audio is an
     * order of magnitude cheaper, and mixing it in moves the number by less than
     * the noise between two samples. Use `"all"` when the figure is meant to be
     * the connection's real cost rather than the picture's.
     */
    kind?: LinkStatsKind;
}

export declare interface ListOptions<TItem> {
    /** Property to order by. Default: `keyPath`. */
    orderBy?: keyof TItem & string;
    /** Reverse the ordering. Default: false. */
    reverse?: boolean;
    /** Maximum number of items to return. */
    limit?: number;
    /** Skip this many items from the start of the result set. */
    offset?: number;
    /** Custom predicate applied after the index query. */
    filter?: (item: TItem) => boolean;
}

/**
 * Build the cache key for a resource list query.
 *
 * @param resource - The resource name.
 * @param params - The list params (page/sort/filters).
 * @returns A stable TanStack Query key.
 */
export declare function listQueryKey(resource: string, params?: GetListParams): unknown[];

export declare interface ListStateHandlers<T> {
    append: (...items: T[]) => void;
    prepend: (...items: T[]) => void;
    insert: (index: number, ...items: T[]) => void;
    remove: (...indices: number[]) => void;
    reorder: (payload: ReorderPayload) => void;
    setItem: (index: number, item: T) => void;
    setState: (items: T[]) => void;
    apply: (fn: (item: T, index: number) => T) => void;
    clear: () => void;
}

/**
 * The canonical Material list row: an optional leading slot, a title with an
 * optional subtitle, and an optional trailing slot. When `onClick` is supplied
 * the tile renders as a full-width, keyboard-accessible `<button>`; otherwise it
 * renders as a static `<div>`.
 *
 * @example
 * <ListTile
 *     leading={<User />}
 *     title="Maria Silva"
 *     subtitle="maria@example.com"
 *     trailing={<ChevronRight />}
 *     onClick={() => open(user)}
 * />
 */
export declare function ListTile({ leading, title, subtitle, trailing, onClick, disabled, selected, className, }: ListTileProps): JSX.Element;

export declare interface ListTileProps {
    /** Left slot — typically an icon or avatar. */
    leading?: ReactNode;
    /** Primary line. Required. */
    title: ReactNode;
    /** Secondary line rendered under the title. */
    subtitle?: ReactNode;
    /** Right slot — typically an icon, switch or meta text. */
    trailing?: ReactNode;
    /** When provided, the tile becomes an interactive button. */
    onClick?: () => void;
    /** When true, the tile is dimmed and non-interactive. */
    disabled?: boolean;
    /** When true, the tile is highlighted as the active row. */
    selected?: boolean;
    /** Extra class names merged onto the root. */
    className?: string;
}

export declare type LocalStorageOptions<T> = {
    serialize?: (value: T) => string;
    deserialize?: (raw: string) => T;
};

export declare interface LogEntry {
    level: LogLevel;
    message: string;
    context?: Record<string, unknown>;
    timestamp: number;
}

export declare interface Logger {
    debug: (message: string, context?: Record<string, unknown>) => void;
    info: (message: string, context?: Record<string, unknown>) => void;
    warn: (message: string, context?: Record<string, unknown>) => void;
    error: (message: string, context?: Record<string, unknown>) => void;
    /** Build a child logger that prefixes the namespace to each message. */
    child: (namespace: string) => Logger;
}

export declare interface LoggerSink {
    (entry: LogEntry): void;
}

export declare type LogLevel = "debug" | "info" | "warn" | "error";

/**
 * DOM event handlers produced by {@link useLongPressHandlers}, ready to spread
 * onto a JSX element (`<div {...handlers}>`).
 */
export declare interface LongPressHandlers {
    /** Starts the hold timer on mouse press. */
    onMouseDown: (event: MouseEvent_2) => void;
    /** Cancels the pending hold when the mouse is released. */
    onMouseUp: () => void;
    /** Cancels the pending hold when the pointer leaves the element. */
    onMouseLeave: () => void;
    /** Starts the hold timer on touch start. */
    onTouchStart: (event: TouchEvent_2) => void;
    /** Cancels the pending hold when the touch ends. */
    onTouchEnd: () => void;
    /** Cancels the pending hold when the finger moves. */
    onTouchMove: () => void;
    /** Fires the long-press immediately (desktop right-click parity). */
    onContextMenu: (event: MouseEvent_2) => void;
}

/**
 * Rendered Markdown, from a node tree — never from an HTML string.
 *
 * `dangerouslySetInnerHTML` appears nowhere in this component. That is what makes
 * rendering somebody else's Markdown safe by construction rather than by a promise
 * about escaping: a `<script>` in a comment is four characters of text, because text
 * is all a React child can be.
 *
 * Link and image URLs go through a scheme **allowlist** (`http`, `https`, `mailto`,
 * `tel`, `sms`, plus relative), so `[click](javascript:alert(1))` renders as plain
 * text. A blocklist would have to enumerate every spelling of `javascript:` and
 * would miss one.
 *
 * @example
 * <Markdown source={comentario.corpo} linkProps={{ target: "_blank", rel: "noreferrer" }} />
 */
export declare function Markdown({ source, headingOffset, highlightCode, showLineNumbers, linkProps, className, ...rest }: MarkdownProps): JSX.Element;

/** Column alignment of a table, from the delimiter row. */
export declare type MarkdownAlign = "left" | "center" | "right" | null;

/** Block content. */
export declare type MarkdownBlock = {
    type: "heading";
    level: number;
    children: MarkdownInline[];
} | {
    type: "paragraph";
    children: MarkdownInline[];
} | {
    type: "code";
    language: string | null;
    value: string;
} | {
    type: "quote";
    children: MarkdownBlock[];
} | {
    type: "list";
    ordered: boolean;
    start: number;
    items: MarkdownBlock[][];
} | {
    type: "table";
    align: MarkdownAlign[];
    head: MarkdownInline[][];
    rows: MarkdownInline[][][];
} | {
    type: "rule";
};

/**
 * @tempest-limits file-lines, function-lines — a Markdown block parser is a state
 * machine over line kinds: paragraph, heading, fence, list, quote, table and
 * thematic break each need to see the lines around them to know where they end.
 * parseBlocks is that loop, and cutting it into per-kind functions would hand each
 * one the same lookahead cursor.
 */
/** Inline content. */
export declare type MarkdownInline = {
    type: "text";
    value: string;
} | {
    type: "strong";
    children: MarkdownInline[];
} | {
    type: "em";
    children: MarkdownInline[];
} | {
    type: "del";
    children: MarkdownInline[];
} | {
    type: "code";
    value: string;
} | {
    type: "link";
    href: string;
    children: MarkdownInline[];
} | {
    type: "image";
    src: string;
    alt: string;
} | {
    type: "break";
};

export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_12> {
    /** The Markdown source. */
    source: string;
    /**
     * Heading level the document's `#` maps to. Default 2.
     *
     * A comment body rendered inside a page whose `<h1>` is the page title must not
     * emit a second `<h1>`; shifting the whole scale keeps the outline valid.
     */
    headingOffset?: number;
    /** Render fenced code with `CodeBlock` (copy button, line numbers). Default `true`. */
    highlightCode?: boolean;
    /** Show line numbers in fenced code. Default `false`. */
    showLineNumbers?: boolean;
    /** Extra props for every link — `target="_blank"`, an analytics handler. */
    linkProps?: HTMLAttributes<HTMLAnchorElement> & {
        target?: string;
        rel?: string;
    };
}

/**
 * Masonry layout: cards of uneven height packed into columns with an even bottom
 * edge.
 *
 * Measures the rendered cards and deals each one into the shortest column, rather
 * than using CSS `columns` or `grid-auto-flow: dense`. Both of those are one line
 * of CSS and neither does this job: CSS `columns` breaks a card across the column
 * boundary, and a dense grid keeps every row the height of its tallest cell, which
 * is the ragged bottom edge people reach for masonry to avoid.
 *
 * @example
 * <Masonry items={fotos} itemKey={(foto) => foto.id} columns={{ 0: 1, 700: 2, 1100: 4 }}>
 *     {(foto) => <img src={foto.url} alt={foto.alt} />}
 * </Masonry>
 */
export declare function Masonry<T>({ items, children, itemKey, columns, gap, className, style, ...rest }: MasonryProps<T>): JSX.Element;

export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_11> {
    /** What to lay out. */
    items: readonly T[];
    /** Render one card. */
    children: (item: T, index: number) => ReactNode;
    /** Stable key per item. Index is a fallback nobody should rely on. */
    itemKey?: (item: T, index: number) => string | number;
    /**
     * Column count: a fixed number, or a `width → columns` map read as
     * "from this width up". Default `{ 0: 1, 640: 2, 1024: 3 }`.
     */
    columns?: number | Record<number, number>;
    /** Gap between cards, any CSS length. Default `var(--tempest-space-4)`. */
    gap?: string;
}

/**
 * The matrix as an SVG path, one `M…h…v…h…z` rectangle per dark module.
 *
 * A path beats one `<rect>` per module: a version-10 symbol is 3 481 modules,
 * and that many elements is a real cost to parse and to paint. Coordinates are
 * whole numbers in module space, so the shape stays crisp at any size.
 *
 * @param matrix - An encoded matrix.
 * @param margin - Quiet zone in modules. The standard asks for 4.
 * @returns The `d` attribute, empty when there is nothing dark.
 */
export declare function matrixToPath(matrix: QRMatrix, margin?: number): string;

/**
 * Listen to a room at rest and report how loud its silence is.
 *
 * The number a person cannot guess. Setting a gate by ear means switching it on
 * and hearing what disappeared, which only works if you already know what should
 * have disappeared — so the usual outcome is leaving it at a default that is
 * wrong for that room. Measuring replaces the guess.
 *
 * The result is the **peak** RMS window observed, not the average: a threshold
 * under the loudest thing the quiet room did will be opened by that thing.
 *
 * @param stream - A live capture of the room while nobody speaks.
 * @param options - See {@link NoiseFloorOptions}.
 * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio
 *   or the stream carries no audio track — which {@link suggestGateThreshold}
 *   turns into its own floor rather than into a gate that never opens.
 *
 * @example
 * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });
 * setThreshold(suggestGateThreshold(floor));
 */
export declare function measureNoiseFloor(stream: MediaStream, { onProgress, durationMs, context: injectedContext, }?: NoiseFloorOptions): Promise<number>;

/** A classified capture error with a human-readable, English message. */
export declare interface MediaAccessError {
    kind: MediaAccessErrorKind;
    message: string;
}

/** Classified reason a capture device could not be acquired. */
export declare type MediaAccessErrorKind = "unsupported" | "insecure" | "permission-denied" | "not-found" | "in-use" | "unknown";

/**
 * What a media error is about.
 *
 * `"screen"` is not a device in the `getUserMedia` sense — it is what
 * `getDisplayMedia` captures — but it fails through the same `DOMException` names, so
 * it is classified by the same function rather than by a second copy of the table.
 */
export declare type MediaDeviceKindLabel = "microphone" | "camera" | "screen";

/** One device the browser is willing to tell us about. */
export declare interface MediaDeviceOption {
    deviceId: string;
    /**
     * Human label, or `""` until permission has been granted.
     *
     * See {@link UseMediaDevicesResult.labelsAvailable} — an empty label is not a
     * bug, it is the browser refusing to fingerprint the machine.
     */
    label: string;
    kind: MediaDeviceKind;
    groupId: string;
}

/** Which capture permission to observe. */
export declare type MediaPermissionName = "microphone" | "camera";

/**
 * Permission state, including the two cases the browser prompt cannot tell you
 * apart on its own.
 *
 * - `"unknown"` — the Permissions API is unavailable (Safari does not report
 *   `microphone`), so the only way to learn the answer is to ask for the device.
 * - `"prompt"` — never asked. Asking now shows the browser prompt.
 * - `"granted"` / `"denied"` — settled. `"denied"` is **sticky**: calling
 *   `getUserMedia` again does not re-prompt, it rejects immediately.
 */
export declare type MediaPermissionState = "unknown" | "prompt" | "granted" | "denied";

/** Imperative recorder over one `MediaStream`. */
export declare interface MediaRecorderHandle {
    /** Begin recording. No-op when already recording or paused. */
    start: () => void;
    /** Pause. The clock stops; `durationMs` freezes. */
    pause: () => void;
    /** Resume after `pause()`. */
    resume: () => void;
    /** Stop and resolve with the assembled recording. */
    stop: () => Promise<MediaRecording>;
    /** Stop and throw the bytes away. */
    cancel: () => void;
    status: () => MediaRecorderStatus;
    /** Recorded length so far, excluding paused time. */
    durationMs: () => number;
    /** The negotiated container. */
    mimeType: string;
}

/**
 * @tempest-limits function-lines — the engine behind both the audio and the video
 * recorder: MIME negotiation, the state machine MediaRecorder does not give you, and
 * the clock kept by hand because a fresh WebM reports no duration. The clock has to
 * pause and resume with the state machine, so they are one closure.
 */
/** Lifecycle of a recording. */
export declare type MediaRecorderStatus = "idle" | "recording" | "paused" | "stopped";

/** A finished recording, whatever it was made of. */
export declare interface MediaRecording {
    /** The bytes. Wrap with `useObjectUrl` to play it, or POST it as-is. */
    blob: Blob;
    /** What the browser actually produced — not necessarily what you asked for. */
    mimeType: string;
    /** Recorded length, excluding time spent paused. */
    durationMs: number;
}

/** What a track carries — used only to word the errors this engine throws. */
export declare type MediaRecordingKind = "audio" | "video";

/** Options for {@link createMediaRecorder}. */
export declare interface MediaRecordingOptions {
    /**
     * Container candidates, best first. Required: this engine has no opinion about
     * codecs — the audio and video wrappers own that list.
     */
    candidates: readonly string[];
    /** Wording for the thrown messages ("cannot record any supported *video* container"). */
    kind: MediaRecordingKind;
    /** Force a container, bypassing the negotiation. Throws when unsupported. */
    mimeType?: string;
    /** Target audio bitrate. */
    audioBitsPerSecond?: number;
    /** Target video bitrate. Ignored by the browser on an audio-only stream. */
    videoBitsPerSecond?: number;
    /**
     * Emit a chunk every N ms through `onChunk`, for streaming upload.
     *
     * Without it the whole recording is buffered in memory until `stop()`.
     */
    timesliceMs?: number;
    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
    onChunk?: (chunk: Blob) => void;
    /** Recorder-level failure (device unplugged mid-recording, encoder error). */
    onError?: (error: unknown) => void;
}

/**
 * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.
 *
 * If the next call has the same arguments (compared with `Object.is` per
 * position and equal length), the cached result is returned without re-running
 * `fn`. Any different argument list recomputes and replaces the cache.
 *
 * @example
 * const select = memoizeOne((a: number, b: number) => a + b);
 * select(1, 2); // computes 3
 * select(1, 2); // cached 3
 * select(2, 2); // recomputes 4
 */
export declare function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;

export { MemoryRouter }

/**
 * Application menubar (File / Edit-style).
 *
 * - `role="menubar"`; each menu is a button that opens a dropdown.
 * - Arrow Left/Right moves between menus (wrapping); opening one closes others.
 * - Closes on outside click, Escape, or selecting an item.
 * - Items may carry a `shortcut` (right-aligned) or be a `{ separator: true }`.
 *
 * @example
 * <Menubar
 *     menus={[
 *         {
 *             label: "File",
 *             items: [
 *                 { label: "New", shortcut: "⌘N", onSelect: () => create() },
 *                 { separator: true },
 *                 { label: "Quit", onSelect: () => quit() },
 *             ],
 *         },
 *     ]}
 * />
 */
export declare function Menubar({ menus, className, ...props }: MenubarProps): JSX.Element;

export declare type MenubarItem = {
    /** Visible label for the action. */
    label: ReactNode;
    /** Invoked when the action is selected. */
    onSelect?: () => void;
    /** Disable the action. */
    disabled?: boolean;
    /** Optional shortcut hint rendered right-aligned (e.g. `"⌘S"`). */
    shortcut?: string;
} | {
    separator: true;
};

export declare interface MenubarMenu {
    /** Top-level menu label (e.g. `"File"`). */
    label: ReactNode;
    /** Items shown in the menu's dropdown. */
    items: MenubarItem[];
}

export declare interface MenubarProps extends HTMLAttributes<HTMLDivElement> {
    /** Top-level menus rendered left-to-right. */
    menus: MenubarMenu[];
}

/**
 * A point projected onto the unit Web Mercator plane. Both axes are in `[0, 1]`
 * — `x` grows east, `y` grows south (screen convention).
 */
export declare interface MercatorPoint {
    x: number;
    y: number;
}

/** A message the mesh produces and accepts. The transport is the caller's. */
export declare type MeshMessage = {
    type: "offer";
    to: string;
    from?: string;
    sdp: string;
} | {
    type: "answer";
    to: string;
    from?: string;
    sdp: string;
} | {
    type: "ice";
    to: string;
    from?: string;
    candidate: string | null;
    sdpMid: string | null;
    sdpMLineIndex: number | null;
};

/** One remote participant, as the mesh currently sees it. */
export declare interface MeshPeer {
    /** The id the caller registered this peer under. */
    peerId: string;
    /** The connection's own state, straight from `RTCPeerConnection`. */
    connection: RTCPeerConnectionState;
    /** Inbound stream per slot name, `null` for a slot the peer is not sending. */
    streams: Record<string, MediaStream | null>;
    /**
     * The last sample for this link, when the mesh was asked to measure.
     *
     * Absent unless {@link PeerMeshOptions.stats} was given: measuring costs a
     * `getStats()` per link per tick, and a mesh that shows no badge should not
     * pay it.
     */
    stats?: LinkStats;
}

/** Encoder limits, before the room divides them. */
export declare interface MeshQuality {
    /**
     * Cap per video slot, in kbps. `null` leaves that slot uncapped.
     *
     * Divided by the size of the room — see {@link PeerMesh.applyQuality}.
     */
    video?: Record<string, number | null>;
    /**
     * Cap per audio slot, in **bps**, matching `setSenderBitrate`.
     *
     * Never divided. Audio is an order of magnitude cheaper than video and is
     * the part of a call that has to survive: dividing it buys back a few
     * percent of the uplink in exchange for the only thing everyone needs.
     */
    audio?: Record<string, number>;
    /** Frame ceiling written onto every video encoding. */
    maxFramerate?: number;
    /** What a video encoder gives up first. */
    degradationPreference?: RTCDegradationPreference;
    /**
     * Which video slot decides whether `maintain-framerate` still holds.
     *
     * Without it the decision reads the **largest** cap across every video
     * slot, which is right for a mesh whose slots are interchangeable and wrong
     * for one where they are not. Somebody who picked fluidity was thinking
     * about the screen — code, a spreadsheet, a video at 60 fps — and with only
     * a camera on, that choice ends up being decided by a stream it was never
     * about.
     *
     * Name the slot the choice was about and it decides alone. A slot the caps
     * do not mention keeps the preference: nothing has been said about the
     * thing being asked about, and a modest camera beside it is not an answer.
     */
    degradationAnchor?: string;
    /**
     * Total uplink to divide among the peers, in kbps.
     *
     * A mesh sends one copy of everything **per participant**, so a cap that is
     * comfortable one-to-one saturates a home connection with four people.
     */
    uplinkBudgetKbps?: number;
    /**
     * Floor each video slot keeps after the division, in kbps.
     *
     * Dividing without a floor eventually allocates tens of kbps per stream,
     * which buys a blur that updates once a second: everybody loses the picture
     * instead of the excess giving way.
     */
    minVideoKbps?: number;
    /**
     * Budget below which `maintain-framerate` is overridden.
     *
     * Somebody who asked for fluidity wants a good picture in motion, not the
     * number 60. Once the share of the uplink is this small, holding the frame
     * rate halves what each frame gets and the result is worse than the lower
     * rate it replaced.
     */
    fluidFloorKbps?: number;
}

/**
 * One media lane, negotiated once and reused for the life of the link.
 *
 * The order of the slot list is the wire protocol: the offerer allocates one
 * m-line per slot in this order, so a slot's `mid` is its ordinal and both ends
 * read the same identity off it. Reorder the list and the two sides disagree
 * about which lane carries the camera.
 */
export declare interface MeshSlot {
    /** Stable name the caller uses in {@link PeerMesh.setLocalTrack}. */
    name: string;
    /** Whether the lane carries audio or video. */
    kind: MeshSlotKind;
}

/** What a slot carries. */
export declare type MeshSlotKind = "audio" | "video";

/**
 * The single state a call badge shows.
 *
 * `connected` covers being alone in the room: a mesh with no peers has nothing
 * to connect to and is not failing, which is the case a naive "any link
 * connected?" check reports as broken for as long as nobody else joins.
 */
export declare type MeshState = "connecting" | "connected" | "reconnecting" | "failed" | "closed";

/** Options for `createPeerMesh`. */
/**
 * Ask the mesh to measure its own links.
 *
 * The rule this exists to keep is the one a hand-rolled loop gets wrong: **one
 * sampler per connection**. The rate is a delta, so a sampler shared across
 * peers subtracts one connection's counter from another's and reports nonsense
 * — and the mesh is the only place that knows how many links there are and when
 * one goes away. It also owns a single timer instead of one per peer.
 *
 * Sampling only runs for a link whose connection is `connected`. A link still
 * gathering candidates has no traffic to measure, and asking anyway spends a
 * `getStats()` to learn that.
 */
export declare interface MeshStatsOptions {
    /** How often to sample each connected link, in milliseconds. Default `2000`. */
    intervalMs?: number;
    /** Which media the throughput counts. Passed straight to the sampler. */
    kind?: LinkStatsKind;
    /**
     * Called with each link's sample, as it is taken.
     *
     * The same value lands on {@link MeshPeer.stats}, so a consumer that reads
     * the peer list needs no callback at all. Note that measuring therefore
     * makes {@link PeerMeshOptions.onPeers} fire on the interval — which is the
     * point for a badge, and worth knowing for anything that does real work in
     * that handler.
     */
    onStats?: (peerId: string, stats: LinkStats) => void;
}

export declare type Messages = Record<string, string>;

/** Lifecycle of a microphone stream. */
export declare type MicrophoneStatus = "idle" | "requesting" | "ready" | "error";

/**
 * Portal-rendered modal dialog with backdrop, Esc handler, and slots for
 * header/body/footer. Locks body scroll while open.
 *
 * The `dialog` role needs an accessible name: a `title` supplies it via
 * `aria-labelledby`, and a titleless dialog should pass `aria-label`. The
 * header heading is only rendered when there is a title, so a close-button-only
 * header does not leave an empty `h3` behind.
 */
export declare function Modal({ open, onClose, title, children, footer, size, closeOnBackdrop, closeOnEsc, className, hideCloseButton, fullscreen, fullscreenOnMobile, "aria-label": ariaLabel, }: ModalProps): ReactPortal | null;

export declare interface ModalProps {
    open: boolean;
    onClose: () => void;
    title?: ReactNode;
    children?: ReactNode;
    footer?: ReactNode;
    size?: ModalSize;
    closeOnBackdrop?: boolean;
    closeOnEsc?: boolean;
    className?: string;
    hideCloseButton?: boolean;
    /** Force fullscreen at all breakpoints. */
    fullscreen?: boolean;
    /** Auto-fullscreen on mobile viewports (< 640px). Default `false`. */
    fullscreenOnMobile?: boolean;
    /**
     * Accessible name for the dialog. Only needed when there is no `title` —
     * with a `title` the dialog is named by it through `aria-labelledby`.
     */
    "aria-label"?: string;
}

/** Imperative API returned by {@link useModals}. */
export declare interface ModalsApi {
    /** Push a content modal. Returns its stack id. */
    open: (options: OpenModalOptions) => string;
    /** Push a confirmation dialog. Returns its stack id. */
    confirm: (options: ConfirmModalOptions) => string;
    /** Remove the modal with the given id. */
    close: (id: string) => void;
    /** Remove every modal from the stack. */
    closeAll: () => void;
}

export declare type ModalSize = "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";

/**
 * Provides imperative modal control via {@link useModals} and renders the open
 * modal stack. Mount once near the app root.
 *
 * @example
 * <ModalsProvider>
 *     <App />
 * </ModalsProvider>
 */
export declare function ModalsProvider({ children }: ModalsProviderProps): JSX.Element;

/** Props for {@link ModalsProvider}. */
export declare interface ModalsProviderProps {
    children: ReactNode;
}

/**
 * Render a monetary amount given in cents as a localized currency string
 * inside a `<span>`.
 *
 * The integer cents are divided by 100 and formatted with `Intl.NumberFormat`.
 *
 * @example
 * <Money cents={1990} />            // "R$ 19,90"
 * <Money cents={500} currency="USD" locale="en-US" /> // "$5.00"
 */
export declare function Money({ cents, currency, locale, ...props }: MoneyProps): JSX.Element;

/**
 * Currency-masked input. Stores the value as an integer number of cents to
 * avoid floating-point error. Suitable for `react-hook-form` once you adapt
 * the field to expose cents.
 */
export declare const MoneyInput: ForwardRefExoticComponent<MoneyInputProps & RefAttributes<HTMLInputElement>>;

export declare interface MoneyInputProps extends Omit<InputProps, "value" | "onChange" | "type"> {
    /** Cents (integer). Internally treated as 1/100 of the currency unit. */
    value: number;
    onChange: (cents: number) => void;
    /** Currency code for `Intl.NumberFormat`. Default: `"BRL"`. */
    currency?: string;
    /** Locale for `Intl.NumberFormat`. Default: `"pt-BR"`. */
    locale?: string;
}

export declare interface MoneyProps extends HTMLAttributes<HTMLSpanElement> {
    /** Amount in the smallest currency unit (e.g. cents). */
    cents: number;
    /** ISO 4217 currency code. Defaults to "BRL". */
    currency?: string;
    /** BCP 47 locale used for formatting. Defaults to "pt-BR". */
    locale?: string;
}

/**
 * Report when a track is carrying speech.
 *
 * Runs entirely on the **receiving** side, over a track the connection already
 * delivers, and that is the whole point: a speaking indicator changes several
 * times per second, so signalling it through a server floods the room with
 * messages carrying information every client can derive for free.
 *
 * Two details separate this from a threshold on a level meter:
 *
 * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare
 *    comparison strobes on every syllable. The state only falls after
 *    `releaseMs` of quiet.
 * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll
 *    would re-render a participant list ten times a second to say the same thing.
 *
 * The meter underneath runs with smoothing off: its eased decay plus this release
 * would hold the indicator open long after the speech stopped.
 *
 * @param stream - The stream whose first audio track is measured.
 * @param onChange - Called only when the speaking state actually flips.
 * @param options - See {@link VoiceActivityOptions}.
 * @returns A handle carrying the current state and the teardown.
 *
 * @example
 * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));
 * // later
 * vad.stop();
 */
export declare function monitorVoiceActivity(stream: MediaStream, onChange: (speaking: boolean) => void, { threshold, releaseMs, pollMs, context, }?: VoiceActivityOptions): VoiceActivityMonitor;

/**
 * Play your own processed microphone back to you.
 *
 * The only way to hear what these filters do without a second person on the call.
 * Every number the chain is tuned by — how deep the de-esser cuts, where the gate
 * sits, how much presence is too much — is a judgement made by ear, and without
 * this the only available ear belongs to somebody else.
 *
 * **Feedback is the hazard, and the reason this is a held, explicit action rather
 * than a setting:** without headphones the speakers feed the microphone that feeds
 * the speakers. Say so in the UI that offers it.
 *
 * @param source - The raw captured track to listen to. It is never stopped here.
 * @param settings - The stages to hear it through. Default {@link DEFAULT_VOICE_CHAIN}.
 * @param options - See {@link VoiceChainOptions}; `ownsSource` is forced to `false`.
 * @returns A handle that stops the monitor.
 */
export declare function monitorVoiceChain(source: MediaStreamTrack, settings?: VoiceChainSettings, options?: Omit<VoiceChainOptions, "ownsSource">): VoiceMonitor;

/** Reorder helper: move `from` to `to`, returning a new array. */
export declare function moveItem<T>(items: T[], from: number, to: number): T[];

/**
 * MultiSelect — a filterable dropdown that selects many options, shown as
 * removable chips inside the field. Selecting toggles a value; Backspace on an
 * empty query removes the last chip.
 *
 * Keyboard: ArrowUp/ArrowDown navigate, Enter toggles the active option, Esc
 * closes, Backspace (empty input) pops the last chip.
 */
export declare function MultiSelect({ options, value, onChange, label, placeholder, helperText, error, disabled, maxItems, filter, emptyMessage, className, }: MultiSelectProps): JSX.Element;

export declare interface MultiSelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}

export declare interface MultiSelectProps {
    options: MultiSelectOption[];
    /** Currently selected values. */
    value: string[];
    onChange: (value: string[]) => void;
    label?: string;
    placeholder?: string;
    helperText?: string;
    error?: string;
    disabled?: boolean;
    /** Cap the number of selectable items. */
    maxItems?: number;
    /** Custom filter — return true to keep the option. Default: case-insensitive substring on label. */
    filter?: (option: MultiSelectOption, query: string) => boolean;
    /** Message shown when no option matches. */
    emptyMessage?: string;
    className?: string;
}

declare interface MutationContext<TData> {
    previous: TData | undefined;
}

/**
 * Top app bar. Three-slot layout (logo / nav / actions) that collapses
 * gracefully on mobile (nav slot wraps below).
 *
 * @example
 * <Navbar
 *     logo={<img src="/logo.svg" alt="App" />}
 *     nav={<NavLinks />}
 *     actions={<UserMenu />}
 * />
 */
export declare function Navbar({ logo, nav, actions, sticky, tone, bordered, className, ...props }: NavbarProps): JSX.Element;

export declare interface NavbarProps extends HTMLAttributes<HTMLElement> {
    /** Left slot — typically logo + brand name. */
    logo?: ReactNode;
    /** Center slot — typically nav links. */
    nav?: ReactNode;
    /** Right slot — typically user menu / actions. */
    actions?: ReactNode;
    /** Make the bar sticky at the top of the scroll container. Default `true`. */
    sticky?: boolean;
    /** Visual tone. Default `"surface"`. */
    tone?: NavbarTone;
    /** When set, renders a thin bottom border. Default `true`. */
    bordered?: boolean;
}

export declare type NavbarTone = "surface" | "primary" | "transparent";

export { Navigate }

export { NavigateOptions }

/**
 * Horizontal navigation menu with hover/click/focus dropdown submenus.
 *
 * - Top-level items render in a `<nav><ul>`.
 * - Items with `children` open a submenu panel (`role="menu"`) on hover, focus,
 *   or click. Only one panel is open at a time.
 * - Closes on outside click, Escape, or selecting a leaf entry.
 *
 * @example
 * <NavigationMenu
 *     items={[
 *         { label: "Home", href: "/" },
 *         {
 *             label: "Products",
 *             children: [
 *                 { label: "Analytics", href: "/analytics" },
 *                 { label: "Billing", onSelect: () => openBilling() },
 *             ],
 *         },
 *     ]}
 * />
 */
export declare function NavigationMenu({ items, className, ...props }: NavigationMenuProps): JSX.Element;

export declare interface NavigationMenuItem {
    /** Visible label for the entry. */
    label: ReactNode;
    /** When set, the entry renders as an anchor. */
    href?: string;
    /** Invoked when the entry is activated (click / Enter). */
    onSelect?: () => void;
    /** Nested entries — presence turns the item into a submenu trigger. */
    children?: NavigationMenuItem[];
}

export declare interface NavigationMenuProps extends HTMLAttributes<HTMLElement> {
    /** Top-level navigation entries. */
    items: NavigationMenuItem[];
}

/**
 * Vertical, compact navigation column for desktop and tablet layouts. Each item
 * stacks an icon over its label, with the active item flagged via
 * `aria-current="page"`. Use `labelVisibility="selected"` to show only the
 * active item's label, or `"none"` for an icon-only rail.
 *
 * @example
 * <NavigationRail
 *     header={<FloatingActionButton icon={<Plus />} position="none" />}
 *     items={[
 *         { key: "home", label: "Início", icon: <Home /> },
 *         { key: "inbox", label: "Caixa", icon: <Inbox />, badge: 3 },
 *     ]}
 *     value={tab}
 *     onChange={setTab}
 * />
 */
export declare function NavigationRail({ items, value, onChange, header, footer, labelVisibility, className, ...props }: NavigationRailProps): JSX.Element;

export declare interface NavigationRailItem {
    /** Unique identifier — used as React key and for value matching. */
    key: string;
    /** Visible label. */
    label: ReactNode;
    /** Icon rendered above the label. */
    icon?: ReactNode;
    /** Optional badge content rendered over the icon. */
    badge?: ReactNode;
    /** When true, the item is not selectable. */
    disabled?: boolean;
}

declare type NavigationRailLabelVisibility = "all" | "selected" | "none";

export declare interface NavigationRailProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
    items: NavigationRailItem[];
    /** Selected key. */
    value: string;
    /** Called with the new selected key on click. */
    onChange: (key: string) => void;
    /** Top slot — e.g. a FAB or logo. */
    header?: ReactNode;
    /** Bottom slot — pushed to the bottom of the rail. */
    footer?: ReactNode;
    /** Which item labels to show. Default `"all"`. */
    labelVisibility?: NavigationRailLabelVisibility;
    /** Extra class names merged onto the root. */
    className?: string;
}

export { NavLink }

/** Options for {@link measureNoiseFloor}. */
export declare interface NoiseFloorOptions {
    /** Called with `0..1` so a dialog can show the wait. */
    onProgress?: (fraction: number) => void;
    /** How long to listen. Default `3000`. */
    durationMs?: number;
    /** Reuse an existing `AudioContext` rather than opening one. */
    context?: AudioContext;
}

/**
 * Turn one raw detection into a {@link BarcodeScanResult}.
 *
 * An unrecognised `format` string becomes `"unknown"` rather than being passed through
 * as a lie about the union, and missing geometry becomes `null`/`[]` rather than
 * `undefined`, so a consumer never has to branch on three kinds of absence.
 *
 * @param raw - What the detector resolved with.
 * @param known - The formats considered valid. Defaults to the whole spec list.
 * @returns The normalised result.
 */
export declare function normalizeBarcode(raw: DetectedBarcodeLike, known?: readonly BarcodeFormat[]): BarcodeScanResult;

/**
 * Normalize a longitude into the `[-180, 180]` range, wrapping values that
 * cross the antimeridian (e.g. `190` → `-170`).
 */
export declare function normalizeLongitude(longitude: number): number;

/**
 * Inbox panel for notifications the app has received.
 *
 * Deliberately presentational and controlled: it takes a list and emits intent.
 * Where the list comes from — an API, a service-worker push, `localStorage` — and
 * where read state is written are app decisions, and a component that assumed any
 * of them would be wrong for most apps. `useNotificationInbox` is the companion
 * that holds the state, including the service-worker bridge.
 *
 * It is also just the panel, not a popover: apps mount it inside their own
 * `Popover`, `Drawer` or route. That keeps one component from owning both the
 * inbox and a positioning strategy.
 *
 * @example
 * const inbox = useNotificationInbox();
 *
 * <Popover trigger={<Button>Notificações ({inbox.unreadCount})</Button>}>
 *     <NotificationCenter
 *         items={inbox.items}
 *         onMarkRead={inbox.markRead}
 *         onMarkAllRead={inbox.markAllRead}
 *         onDismiss={inbox.remove}
 *         onSelect={(item) => item.url && navigate(item.url)}
 *     />
 * </Popover>
 */
export declare function NotificationCenter({ items, title, onSelect, onMarkRead, onMarkAllRead, onDismiss, renderIcon, locale, emptyState, now, className, ...rest }: NotificationCenterProps): JSX.Element;

export declare interface NotificationCenterProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps> {
    /** Entries to show. Rendered in the order given — `useNotificationInbox` sorts newest first. */
    items: readonly NotificationItem[];
    /**
     * Panel heading. Pass `null` to render the list with no header.
     *
     * Widened from the DOM `title` attribute (a `string`) on purpose: this is a
     * rendered heading, not a tooltip, so it takes a node.
     */
    title?: ReactNode;
    /** Activate an entry: click, `Enter` or `Space`. Also marks it read when `onMarkRead` is set. */
    onSelect?: (item: NotificationItem) => void;
    /** Mark one entry as read. Enables the per-item read control. */
    onMarkRead?: (id: string) => void;
    /** Mark every entry as read. Enables the header action. */
    onMarkAllRead?: () => void;
    /** Remove one entry. Enables the per-item dismiss control. */
    onDismiss?: (id: string) => void;
    /** Icon rendered at the leading edge of each row — an `<Icon name={…} />`, say. */
    renderIcon?: (item: NotificationItem) => ReactNode;
    /** Locale for the relative timestamps. Default `"pt-BR"`. */
    locale?: RelativeTimeLocale;
    /** Shown when `items` is empty. */
    emptyState?: ReactNode;
    /** Reference point for the relative timestamps. Default: now, at render time. */
    now?: number;
}

/** One entry in the inbox. */
export declare interface NotificationItem {
    /** Stable id. Re-adding an existing id updates that entry instead of duplicating it. */
    id: string;
    title: string;
    /** Body text. Optional — a title-only notification is a legitimate shape. */
    body?: string;
    /** Epoch milliseconds. Used for ordering and for the relative timestamp. */
    receivedAt: number;
    read?: boolean;
    /** Where activating the notification should take the user. */
    url?: string;
    /** Free-form payload the app passes through, e.g. the entity it refers to. */
    data?: Record<string, unknown>;
}

/**
 * Module-level singleton progress controller. Drive it imperatively from
 * anywhere (router transitions, fetch interceptors) and render the visual bar
 * with {@link NProgressBar}.
 *
 * @example
 * nprogress.start();
 * await loadData();
 * nprogress.done();
 */
export declare const nprogress: NProgressController;

/**
 * Fixed top loading bar bound to the {@link nprogress} singleton. Mount once
 * near the app root; it renders nothing while inactive.
 *
 * @example
 * <NProgressBar />
 */
export declare function NProgressBar({ color, height, className }: NProgressBarProps): JSX.Element | null;

/** Props for {@link NProgressBar}. */
export declare interface NProgressBarProps {
    /** Bar color. Defaults to `var(--tempest-primary)`. */
    color?: string;
    /** Bar height in pixels. Default `3`. */
    height?: number;
    /** Extra class applied to the bar element. */
    className?: string;
}

/** Imperative top-loading-bar controller. */
export declare interface NProgressController {
    /** Show the bar and start trickling toward ~0.9. */
    start: () => void;
    /** Complete to `1`, then hide the bar shortly after. */
    done: () => void;
    /** Set the progress explicitly. Values are clamped to `0..1`. */
    set: (n: number) => void;
    /** Increment progress by `amount` (default a small trickle step). */
    inc: (amount?: number) => void;
    /** Subscribe to state changes. Returns an unsubscribe function. */
    subscribe: (listener: NProgressListener) => () => void;
}

/** Listener invoked whenever the progress state changes. */
export declare type NProgressListener = (state: NProgressState) => void;

/** Snapshot of the progress controller state delivered to subscribers. */
export declare interface NProgressState {
    /** Current progress, `0` (empty) to `1` (complete). */
    value: number;
    /** Whether the bar should be visible. */
    active: boolean;
}

export declare interface OAuthCredential {
    /** Provider-issued ID token (JWT). */
    idToken: string;
    /** Provider name (e.g. `"google"`, `"facebook"`). */
    provider: string;
    /** Raw response from the provider's SDK — opaque, for app-level inspection. */
    raw?: unknown;
}

export declare interface OAuthError {
    /** Provider name. */
    provider: string;
    /** Provider-specific error code, when available. */
    code?: string;
    /** Human-readable message. */
    message: string;
    /** Raw underlying error object. */
    raw?: unknown;
}

export declare interface OfflineDatabase<TSchema extends OfflineSchema> {
    /**
     * The {@link OfflineStore} for one table.
     *
     * The name is checked against the declared schema; the record type is
     * supplied by the caller — `store<Chat>("chats")`. Deriving it from the
     * schema instead (`OfflineStore<TSchema[K], string>`) is what the shape
     * below documents as unavailable: Dexie's `Table<T>` expands `UpdateSpec<T>`
     * over the keys of `T`, and an unresolved indexed access there makes the
     * checker answer TS2589 no matter how the value is cast.
     *
     * Stores are created once and memoised, so repeated calls with the same
     * name return the same object.
     */
    store: <TItem>(name: keyof TSchema & string) => OfflineStore<TItem, string>;
    /** The Dexie instance shared by every store. */
    db: default_2;
    /** Delete the whole database from the browser. */
    destroy: () => Promise<void>;
}

export declare interface OfflineDatabaseConfig<TSchema extends OfflineSchema> {
    /** IndexedDB database name. */
    databaseName: string;
    /** Schema version. Bump when changing any table's indexes. */
    version: number;
    /** One entry per object store, all inside this single database. */
    tables: OfflineTablesConfig<TSchema>;
}

/**
 * Fixed bar that appears while the browser is offline and, by default, flashes
 * a brief confirmation when the connection returns. Backed by {@link useOnline}
 * — no props needed for the common case.
 *
 * Renders nothing while online (after any flash has elapsed), so it is safe to
 * mount unconditionally at the app root.
 *
 * @example
 * <OfflineIndicator position="top" />
 */
export declare function OfflineIndicator({ position, offlineLabel, onlineLabel, onlineFlashMs, className, children, ...props }: OfflineIndicatorProps): JSX.Element | null;

export declare type OfflineIndicatorPosition = "top" | "bottom";

export declare interface OfflineIndicatorProps extends HTMLAttributes<HTMLDivElement> {
    /** Where to pin the fixed bar. Default `"bottom"`. */
    position?: OfflineIndicatorPosition;
    /** Message shown while offline. */
    offlineLabel?: ReactNode;
    /** Message flashed briefly when connectivity returns. */
    onlineLabel?: ReactNode;
    /**
     * How long (ms) to keep the "back online" flash visible. `0` hides it
     * entirely. Default `3000`.
     */
    onlineFlashMs?: number;
    /** Override the offline body entirely (icon + label ignored). */
    children?: ReactNode;
}

/** Handle returned by {@link persistQueryClientOffline}. */
export declare interface OfflineQueryPersistence {
    /**
     * Load the persisted snapshot into the `QueryClient`. Call once on boot,
     * before rendering queries, so cached data is available offline.
     */
    restore: () => Promise<void>;
    /** Write the current cache snapshot immediately (bypassing the throttle). */
    flush: () => Promise<void>;
    /** Stop persisting and drop the pending write. */
    unsubscribe: () => void;
    /** Delete the persisted snapshot (e.g. on logout). */
    clear: () => Promise<void>;
}

/** Options for {@link persistQueryClientOffline}. */
export declare interface OfflineQueryPersistenceOptions {
    /** The `QueryClient` to snapshot and restore. */
    queryClient: QueryClient;
    /** IndexedDB database name for the snapshot. Default `"TempestQueryCache"`. */
    databaseName?: string;
    /** Row key under which the snapshot is stored. Default `"tanstack-query"`. */
    key?: string;
    /**
     * Minimum gap between snapshot writes, in ms — cache churn is coalesced into
     * one trailing write per window. Default `1000`.
     */
    throttleMs?: number;
}

/** Maps each table name to the record type it stores. */
export declare type OfflineSchema = Record<string, unknown>;

export declare interface OfflineStore<TItem, TKey extends string | number> {
    /** Insert or replace a record. */
    put: (item: TItem, owner?: string) => Promise<TKey>;
    /** Insert or replace multiple records in a single transaction. */
    bulkPut: (items: TItem[], owner?: string) => Promise<TKey>;
    /** Fetch one record by its primary key. */
    get: (key: TKey) => Promise<TItem | undefined>;
    /** List records, optionally scoped to `owner` when `ownerField` is configured. */
    list: (owner?: string, options?: ListOptions<TItem>) => Promise<TItem[]>;
    /** Partial update by primary key. Returns the number of records changed. */
    update: (key: TKey, changes: Partial<TItem>) => Promise<number>;
    /** Apply a modification to every record matching `owner`. */
    updateMany: (owner: string | undefined, changes: Partial<TItem>) => Promise<number>;
    /** Delete one record by primary key. */
    delete: (key: TKey) => Promise<void>;
    /** Delete every record matching `owner` (or the entire table when no scope is set). */
    clear: (owner?: string) => Promise<void>;
    /** Count records, optionally scoped to `owner`. */
    count: (owner?: string) => Promise<number>;
    /** Raw Dexie table for advanced queries. */
    raw: Table_2<TItem, TKey>;
    /** Underlying Dexie instance. */
    db: default_2;
}

export declare interface OfflineStoreConfig<TItem> {
    /** IndexedDB database name. */
    databaseName: string;
    /** Schema version. Bump when changing indexes; pair with a migration if needed. */
    version: number;
    /** Object-store name. */
    tableName: string;
    /**
     * Dexie index definition for the table. Use `&` for the primary key
     * (unique), e.g. `"&id, owner_id, created_at"`. See Dexie docs for the
     * full syntax.
     */
    indexes: string;
    /** Property used as the primary key (default: `"id"`). */
    keyPath?: keyof TItem & string;
    /**
     * Optional owner scoping. When set, every read/write method honors the
     * `owner` argument and persists it on each record (e.g. multi-tenant
     * notifications keyed by `user_id`).
     */
    ownerField?: keyof TItem & string;
}

/**
 * Offline-first sync engine: a durable outbox plus a paginated delta pull.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 */
export declare interface OfflineSync<TPayload> {
    /**
     * Queue a mutation. Returns the generated entry id.
     *
     * @param op - The mutation kind.
     * @param recordId - Primary key of the affected record.
     * @param payload - Record snapshot (for `create`/`update`).
     */
    enqueue: (op: OutboxOp, recordId: string, payload?: TPayload) => Promise<string>;
    /**
     * Run a full sync (drain the outbox, then pull the delta). Concurrent
     * calls share one in-flight promise, so triggers never overlap.
     *
     * @param trigger - Label for why the run happened. Default `"manual"`.
     */
    flush: (trigger?: SyncTrigger) => Promise<SyncRunSummary>;
    /** Number of mutations still queued. */
    pendingCount: () => Promise<number>;
    /** The queued mutations in FIFO order. */
    listPending: () => Promise<OutboxEntry<TPayload>[]>;
    /** Drop every queued mutation (e.g. on logout). */
    clearOutbox: () => Promise<void>;
    /** Reset the pull watermark (e.g. on logout / account switch). */
    resetWatermark: () => void;
    /** Read the current reactive {@link SyncState} snapshot synchronously. */
    getState: () => SyncState;
    /**
     * Subscribe to {@link SyncState} changes. The listener fires on every
     * enqueue, flush transition and outbox clear.
     *
     * @param listener - Called with the new snapshot on each change.
     * @returns An unsubscribe function.
     */
    subscribe: (listener: (state: SyncState) => void) => () => void;
    /**
     * Release resources held by the engine — currently the cross-tab
     * `BroadcastChannel` when `crossTab` is enabled. Safe to call when none was
     * opened. Optional in long-lived apps (the channel is reclaimed on tab
     * close); call it in tests and on teardown.
     */
    dispose: () => void;
}

/**
 * Configuration for {@link createOfflineSync}.
 *
 * The engine owns the outbox, the single-flight flush, the offline guard, the
 * paginated pull loop and the watermark; the three transport callbacks
 * (`deliver`, `pullPage`, `applyRemote`) are where the app plugs in its own
 * endpoints, record shape and conflict resolution.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 * @typeParam TRemote - Server item shape returned by `pullPage`.
 */
export declare interface OfflineSyncConfig<TPayload, TRemote> {
    /** IndexedDB database name for the outbox (kept separate per queue). */
    databaseName: string;
    /** Outbox object-store name. Default `"outbox"`. */
    tableName?: string;
    /** Outbox schema version. Default `1`. */
    version?: number;
    /** Prefix for generated entry ids. Default `"outbox"`. */
    idPrefix?: string;
    /**
     * Deliver one queued mutation to the server. Throwing keeps the entry
     * queued (its `attempts`/`lastError` are bumped) for the next run.
     */
    deliver: (entry: OutboxEntry<TPayload>) => Promise<void>;
    /** Fetch one page of the server delta since `since`, from `cursor`. */
    pullPage: (since: string | null, cursor: string | null) => Promise<PullPage<TRemote>>;
    /**
     * Merge one pulled item into the local store. The app owns conflict
     * resolution here (e.g. last-write-wins, keeping newer local pending
     * edits, resolving tombstones and downloading blobs).
     */
    applyRemote: (item: TRemote) => Promise<void>;
    /** Watermark persistence, or `{ storageKey }` for a `localStorage` default. */
    watermark: WatermarkStore | {
        storageKey: string;
    };
    /** Called after an entry is delivered and acked. */
    onEntryDelivered?: (entry: OutboxEntry<TPayload>) => void | Promise<void>;
    /** Called after an entry fails delivery (it stays queued). */
    onEntryFailed?: (entry: OutboxEntry<TPayload>, error: unknown) => void | Promise<void>;
    /**
     * Connectivity check. Default reads `navigator.onLine` (always online in
     * non-browser environments). When it returns `false`, `flush` is skipped.
     */
    isOnline?: () => boolean;
    /**
     * Broadcast {@link SyncState} across browser tabs of the same origin via a
     * `BroadcastChannel`, so every tab shows a coherent pending count / phase
     * (e.g. one tab flushing drops the badge to zero everywhere). The outbox is
     * already a shared IndexedDB; this only shares the in-memory state. Silently
     * ignored where `BroadcastChannel` is unavailable. Default `false`.
     *
     * When the Web Locks API is available, `flush` is additionally coordinated
     * *across* tabs: only one tab runs at a time and others skip while the lock
     * is held (they pick up the result via the broadcast). Delivery should still
     * be idempotent (upsert by client id). Without Web Locks, `flush` falls back
     * to per-tab single-flight.
     */
    crossTab?: boolean;
    /** Channel name when `crossTab` is on. Default `tempest-sync:${databaseName}`. */
    broadcastChannelName?: string;
}

export declare interface OfflineTableConfig<TItem> {
    /**
     * Dexie index definition for this table. Use `&` for a unique primary key,
     * e.g. `"&id, service_id, created_at"`.
     */
    indexes: string;
    /** Property used as the primary key (default: `"id"`). */
    keyPath?: keyof TItem & string;
    /**
     * Optional owner scoping for this table. Set per table, since one database
     * commonly mixes scoped and unscoped data.
     */
    ownerField?: keyof TItem & string;
}

export declare type OfflineTablesConfig<TSchema extends OfflineSchema> = {
    [K in keyof TSchema]: OfflineTableConfig<TSchema[K]>;
};

/** A pan offset in frame pixels, measured from the centered position. */
declare interface Offset {
    x: number;
    y: number;
}

/** Offset-paginated response envelope (fastapi-pagination `Page[T]`). */
export declare interface OffsetPage<T> {
    /** The rows for the current page. */
    items: T[];
    /** Total number of matching rows across all pages. */
    total: number;
    /** Current 1-based page number. */
    page: number;
    /** Total number of pages. */
    pages: number;
    /** Page size — fastapi-pagination emits `size`. */
    size?: number;
    /** Page size — some backends name it `page_size` instead. */
    page_size?: number;
}

/** Offset filter query params (fastapi-pagination / `BasePaginationFilterSchema`). */
export declare interface OffsetParams {
    page?: number;
    /** Page size — fastapi-pagination convention. */
    size?: number;
    /** Page size — `page_size` convention. */
    page_size?: number;
    order_by?: string;
    ascending?: boolean;
}

/**
 * @tempest-limits file-lines — OKLCH ↔ sRGB with the gamut mapping in between: the
 * transfer function, the LMS matrices, the chroma search that finds the nearest in-
 * gamut colour and the contrast ratio used to check it. Matrices split across files
 * are matrices that get edited one half at a time.
 */
/**
 * Color math behind {@link createTheme} — OKLab/OKLCH conversions, tint scale
 * generation and WCAG contrast picking.
 *
 * Everything here is pure and dependency-free: the SDK generates brand ramps at
 * runtime in the browser, so a color library would be a disproportionate cost
 * for ~150 lines of well-specified math. OKLCH is used instead of HSL because
 * HSL lightness is not perceptual — an HSL ramp of a yellow and of a blue at the
 * same `L` read as wildly different brightness, which is exactly what breaks a
 * generated palette.
 */
/** A color in the OKLCH space: perceptual lightness, chroma and hue. */
export declare interface Oklch {
    /** Perceptual lightness, `0` (black) to `1` (white). */
    l: number;
    /** Chroma (colorfulness). `0` is gray; sRGB rarely exceeds `~0.37`. */
    c: number;
    /** Hue angle in degrees, `0`–`360`. */
    h: number;
}

/**
 * Convert OKLCH to a hex color, reducing chroma until the result fits sRGB.
 *
 * Lightness and hue are preserved: desaturating is far less noticeable than
 * shifting either of them, and a naive channel clamp would do both.
 */
export declare function oklchToHex(color: Oklch): string;

/**
 * Create a new object with the given `keys` removed from `obj`.
 *
 * The input is never mutated.
 *
 * @example
 * omit({ id: 1, name: "Ana", age: 30 }, ["age"]);
 * // { id: 1, name: "Ana" }
 */
export declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

/**
 * Wrap `fn` so it runs at most once; subsequent calls return the cached result.
 *
 * @example
 * const init = once(() => expensiveSetup());
 * init(); // runs expensiveSetup()
 * init(); // returns the same cached result, no re-run
 */
export declare function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R;

/**
 * Build the cache key for a single-record query.
 *
 * @param resource - The resource name.
 * @param id - The record id.
 * @returns A stable TanStack Query key.
 */
export declare function oneQueryKey(resource: string, id: string | number | null | undefined): unknown[];

/** Options accepted by {@link ModalsApi.open}. */
export declare interface OpenModalOptions {
    /** Header title. */
    title?: ReactNode;
    /** Modal body content. */
    children: ReactNode;
    /** Dialog size. Default `md`. */
    size?: ModalSize;
    /** Allow closing by clicking the backdrop. Default `true`. */
    closeOnBackdrop?: boolean;
    /** Allow closing with the Esc key. Default `true`. */
    closeOnEsc?: boolean;
    /** Hide the header close button. */
    hideCloseButton?: boolean;
    /** Called after the modal is removed from the stack. */
    onClose?: () => void;
}

/** The operators a field offers. */
export declare function operatorsFor(field: FilterField): FilterOperator[];

/**
 * @tempest-limits file-lines — parsing a session description, merging one
 * `fmtp` line and inserting a missing one are the same pass over the same
 * grammar; split apart, each half is a parser of half an SDP.
 */
/** What an Opus `fmtp` line can be asked to carry. Every field is optional. */
export declare interface OpusProfile {
    /**
     * Ceiling the encoder is asked to respect, in bits per second.
     *
     * This describes what we want **to receive**. To cap what we *send*, use
     * `setSenderBitrate` — in a mesh that is the one that matters, because the
     * uplink carries one copy per participant.
     */
    maxAverageBitrate?: number;
    /** Highest sample rate worth decoding, in Hz. `48000` for full band. */
    maxPlaybackRate?: number;
    /**
     * Two channels instead of one.
     *
     * Sets `stereo` **and** `sprop-stereo`, which point in opposite directions:
     * `stereo=1` asks the *remote* to send two channels, `sprop-stereo=1`
     * announces that *we* will. Setting only one leaves the link asymmetric,
     * which is the recurring reason "I asked for stereo and got mono".
     */
    stereo?: boolean;
    /**
     * In-band forward error correction (`useinbandfec`).
     *
     * Rebuilds a lost packet from the next one, which keeps speech intelligible
     * on a lossy link — and smears music, since it spends bitrate on redundancy
     * instead of detail.
     */
    fec?: boolean;
    /**
     * Discontinuous transmission (`usedtx`): stop sending during silence.
     *
     * Saves uplink in a mesh, at the cost of clipping the first instant after a
     * pause. Wrong for music and for a shared screen, where the quiet passages
     * are content.
     */
    dtx?: boolean;
    /** Constant bitrate (`cbr`). Off by default, as Opus intends. */
    cbr?: boolean;
    /**
     * Any other `fmtp` key, merged verbatim.
     *
     * The escape hatch for a parameter this type does not model. Values are
     * written as given; a key with an empty string is emitted as a bare flag.
     */
    extra?: Record<string, string>;
}

/**
 * Profiles to apply, keyed by audio m-line index (`0`, `1`, …) or by `mid`.
 *
 * Position and `mid` can be mixed in one object. A key that matches nothing is
 * ignored rather than an error — an SDP is negotiated, and a slot that was not
 * offered this time is normal.
 */
export declare type OpusProfileMap = Record<string | number, OpusProfile>;

/**
 * First sequential step that clears 2:1 against the chart surface.
 *
 * A sequential scale may let its near-zero end recede into the surface — on a
 * heatmap that is exactly what "almost nothing" should look like. An **ordinal**
 * scale may not: every step is a discrete mark someone has to see. Starting an
 * ordinal ramp here is the difference.
 */
export declare const ORDINAL_START_STEP = 3;

/** Options for {@link createOSRMBackend}. */
export declare interface OSRMBackendOptions {
    /**
     * Base URL of an **OSRM** HTTP server. There is no default on purpose — this
     * SDK ships no external endpoint. Point it at a routing engine **you host**.
     */
    baseUrl: string;
    /** `fetch` implementation. Default: the global `fetch`. */
    fetch?: typeof globalThis.fetch;
    /** Per-mode duration multipliers applied over the car profile. */
    modeDurationFactors?: Partial<Record<TravelMode, number>>;
}

/** The outbox entry a mutation's variables map to. */
export declare interface OutboxDraft<TPayload> {
    /** The mutation kind. */
    op: OutboxOp;
    /** Primary key of the affected record. */
    recordId: string;
    /** Record snapshot for `create`/`update` (omit for `delete`). */
    payload?: TPayload;
}

/**
 * A single queued mutation.
 *
 * @typeParam TPayload - The record snapshot shape carried by
 *   `create`/`update` entries (omitted for `delete`).
 */
export declare interface OutboxEntry<TPayload = unknown> {
    /** Stable per-entry id (generated with {@link randomId}). */
    id: string;
    /** The mutation kind. */
    op: OutboxOp;
    /** Primary key of the record the mutation targets. */
    recordId: string;
    /**
     * Epoch milliseconds when the mutation was queued, and the FIFO sort key for
     * `listPending()` and the delivery loop. Strictly increasing per engine
     * instance: entries queued inside the same millisecond are spaced by 1ms so
     * the order never depends on how the index breaks a tie.
     */
    enqueuedAt: number;
    /** How many delivery attempts have been made so far. */
    attempts: number;
    /** Last delivery error message, kept for UI/debug. */
    lastError?: string;
    /** Record snapshot for `create`/`update`. Omitted for `delete`. */
    payload?: TPayload;
}

/**
 * Mutation kinds queued in the outbox.
 *
 * `create`/`update` carry a snapshot of the record; `delete` needs only the
 * record id. The distinction between `create` and `update` is advisory — the
 * engine treats both as "deliver this record" and leaves the create-vs-update
 * decision to the app's `deliver` callback (a `PUT` upsert usually ignores it).
 */
export declare type OutboxOp = "create" | "update" | "delete";

export { Outlet }

/**
 * DOM attributes this component redefines.
 *
 * `title` becomes a rendered heading node instead of a tooltip string, and
 * `onSelect` becomes "an entry was activated" instead of the DOM text-selection
 * event. Both would be type errors if merged, and silently confusing if allowed
 * through.
 */
declare type OverriddenDomProps = "children" | "title" | "onSelect";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_10 = "children" | "onChange" | "defaultValue";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_11 = "children";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_12 = "children";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_13 = "children" | "onChange";

/**
 * DOM attributes this component redefines.
 *
 * `onRateChange` is a real collision, not tidiness: React types it on every
 * element as the media `ratechange` handler, `ReactEventHandler`. Ours carries
 * the rate the viewer picked, and a `(rate: number) => void` is not assignable
 * to a handler that receives an event — same shape of clash as `Input`'s `size`
 * against `HTMLInputElement.size`. The DOM one is useless on a `<div>` anyway:
 * the event fires on the media element inside, which this component owns.
 */
declare type OverriddenDomProps_2 = "children" | "onRateChange";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_3 = "children" | "onSubmit";

/** DOM attributes the composer redefines. */
declare type OverriddenDomProps_4 = "onSubmit" | "value" | "defaultValue" | "rows";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_5 = "children";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_6 = "children" | "onError";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_7 = "children" | "onError";

/** DOM attributes this component redefines. */
declare type OverriddenDomProps_8 = "children" | "onSubmit";

/** DOM attributes the composer redefines. */
declare type OverriddenDomProps_9 = "onSubmit" | "value" | "defaultValue" | "rows";

/**
 * Page wrapper with header + (optional) toolbar + content + footer. Pairs
 * with `Container` when you want a max-width content well.
 *
 * @example
 * <Page title="Pedidos" description="Acompanhe seus pedidos" actions={<Button>Novo</Button>}>
 *     <Table {...} />
 * </Page>
 */
export declare function Page({ title, eyebrow, description, actions, toolbar, footer, padded, className, children, ...props }: PageProps): JSX.Element;

export declare interface PageProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
    /** Page title rendered as `<h1>`. */
    title?: ReactNode;
    /** Optional subtitle / breadcrumbs slot rendered above the title. */
    eyebrow?: ReactNode;
    /** Optional description rendered below the title. */
    description?: ReactNode;
    /** Right-side actions slot in the header (buttons, menus). */
    actions?: ReactNode;
    /** Sticky tab bar / filter row rendered just below the header. */
    toolbar?: ReactNode;
    /** Footer slot rendered at the bottom of the content area. */
    footer?: ReactNode;
    /** Page-level padding. Default `true`. */
    padded?: boolean;
    children?: ReactNode;
}

/**
 * Numeric pagination controls. Pair with {@link usePagination} for state.
 *
 * Narrow screens collapse to `‹` / `›` plus the summary by default, which turns
 * random access into sequential access — fine for a desktop-first app, wrong for
 * one whose traffic is phones. `compactOnMobile={false}` keeps the numbers at
 * every width: the row scrolls on its own instead of widening the page, and the
 * effect below keeps the current page inside the visible part of that row.
 *
 * The scroll is why this is one boolean rather than a `variant`. Simply
 * un-hiding the buttons would push a nine-button row past a 360px viewport and
 * give the whole document a horizontal scrollbar — the opt-out has to carry its
 * own layout, so it does.
 */
export declare function Pagination({ page, totalPages, onPageChange, pageSize, onPageSizeChange, pageSizeOptions, totalItems, siblingCount, compactOnMobile, className, }: PaginationProps): JSX.Element | null;

export declare interface PaginationProps {
    page: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    pageSize?: number;
    onPageSizeChange?: (size: number) => void;
    pageSizeOptions?: number[];
    /** Total items count; if provided, renders the summary text. */
    totalItems?: number;
    /** Pages kept around the current one; ~`siblingCount + 4` buttons render. Default 3. */
    siblingCount?: number;
    /**
     * Below 640px, drop to `‹` / `›` plus the summary and hide the numbered
     * buttons and the size select. Default `true`.
     *
     * The default suits a desktop-first app, and costs the thing pagination is
     * for on a phone: reaching page 7 becomes six taps on "next" instead of one
     * tap on `7`. Pass `false` in a mobile-first app and the numbers stay at
     * every width — the row scrolls horizontally by itself rather than pushing
     * the page wider, and the current page is scrolled into view when it
     * changes.
     */
    compactOnMobile?: boolean;
    className?: string;
}

export { Params }

/** Query-param values accepted by the API client for a list request. */
declare type ParamValue = string | number | boolean | undefined | null;

/**
 * Validate an unknown response payload against a zod schema.
 *
 * A development build throws a detailed error naming every divergent field path
 * and embedding the raw payload; every other build throws a generic sentence, so
 * server internals never reach a user's screen or an error tracker.
 *
 * Which one you get comes from `isDevBuild()`, the SDK's single answer to that
 * question, rather than from a check written here. This function used to ask
 * `typeof process !== "undefined" && process.env?.NODE_ENV === "development"`,
 * and a browser has no `process` identifier at all — so the guard short-circuited
 * and the detailed branch was dead in exactly the build it was written for, no
 * matter what the bundler substituted behind it.
 *
 * The rule `isDevBuild()` applies is `NODE_ENV !== "production"`, which is wider
 * than the old `"development" || "test"`: a staging build that never sets
 * `NODE_ENV=production` gets the drift report, raw payload included.
 *
 * @param schema - The zod schema to parse against.
 * @param raw - The raw response payload.
 * @param context - A label used in error messages, e.g. "POST /auth/login".
 * @returns The parsed, typed payload.
 * @throws Error When the payload does not match the schema: `[parseResponse]
 * Contract drift on <context>` with the field paths and the raw payload in a
 * development build, `Resposta inválida do servidor (<context>).` otherwise.
 */
export declare function parseResponse<TSchema extends z.ZodTypeAny>(schema: TSchema, raw: unknown, context: string): z.infer<TSchema>;

/** Per-call knobs for {@link PasskeyClient.authenticate}. */
export declare interface PasskeyAuthenticateInit extends PasskeyRegisterInit {
    /**
     * `"conditional"` is the autofill flow: no modal, the browser offers passkeys
     * inside a field marked `autocomplete="webauthn"`. Requires a `signal`, and
     * only one conditional request may be live per page.
     */
    mediation?: PasskeyMediation;
}

/** What the client sends to the backend to finish authentication. */
export declare interface PasskeyAuthenticationJSON {
    /** Base64url credential id — the server looks up the stored public key by it. */
    id: string;
    /** Same bytes as `id`. */
    rawId: string;
    type: "public-key";
    /** `"platform"` or `"cross-platform"`. */
    authenticatorAttachment: string | null;
    response: {
        /** Base64url client data. */
        clientDataJSON: string;
        /** Base64url authenticator data, carrying the signature counter. */
        authenticatorData: string;
        /** Base64url signature over `authenticatorData || sha256(clientDataJSON)`. */
        signature: string;
        /** Base64url user handle — present on discoverable credentials, else null. */
        userHandle: string | null;
    };
    /** Extension outputs. */
    clientExtensionResults: AuthenticationExtensionsClientOutputs;
}

/** Capability probes shared by both passkey hooks. */
export declare interface PasskeyCapabilities {
    /** WebAuthn exists in this browser. Known synchronously. */
    supported: boolean;
    /**
     * This device has a built-in authenticator. `null` until the async probe
     * settles — render nothing passkey-related while it is `null`.
     */
    platformAvailable: boolean | null;
    /** Autofill-driven sign-in is available. `null` until the probe settles. */
    conditionalAvailable: boolean | null;
}

/** Which ceremony was running, so the message can name it. */
export declare type PasskeyCeremony = "register" | "authenticate";

/** Framework-free WebAuthn client. Build one with {@link createPasskeyClient}. */
export declare interface PasskeyClient {
    /** Run the registration ceremony and return the JSON your backend verifies. */
    register(options: PasskeyCreationOptionsJSON, init?: PasskeyRegisterInit): Promise<PasskeyRegistrationJSON>;
    /** Run the authentication ceremony and return the JSON your backend verifies. */
    authenticate(options: PasskeyRequestOptionsJSON, init?: PasskeyAuthenticateInit): Promise<PasskeyAuthenticationJSON>;
    /**
     * Whether this client can run a ceremony at all — the WebAuthn API exists, or a
     * `credentials` container was injected.
     */
    isSupported(): boolean;
    /** Whether this device has a built-in authenticator (Face ID, Hello, …). */
    isPlatformAuthenticatorAvailable(): Promise<boolean>;
    /** Whether autofill-driven (`"conditional"`) requests are available. */
    isConditionalMediationAvailable(): Promise<boolean>;
}

/**
 * Server-issued registration options, in the base64url JSON shape every WebAuthn
 * backend speaks (`PublicKeyCredentialCreationOptionsJSON` in the spec).
 *
 * `challenge`, `user.id` and every `excludeCredentials[].id` are **base64url**
 * strings here and `ArrayBuffer`s in the DOM API. Converting them is the plumbing
 * this client owns.
 */
export declare interface PasskeyCreationOptionsJSON {
    /** Base64url server challenge. Single-use; the server must remember it. */
    challenge: string;
    /** Relying party. `id` defaults to the client's `rpId`, then to the origin. */
    rp: {
        name: string;
        id?: string;
    };
    /** The account. `id` is base64url of an opaque, stable user handle. */
    user: {
        id: string;
        name: string;
        displayName: string;
    };
    /** Allowed COSE algorithms. Defaults to {@link DEFAULT_PUB_KEY_CRED_PARAMS}. */
    pubKeyCredParams?: {
        type: "public-key";
        alg: number;
    }[];
    /** Ceremony timeout in ms. Defaults to the client's `timeoutMs`. */
    timeout?: number;
    /** Credentials this user already has, so the authenticator refuses a duplicate. */
    excludeCredentials?: {
        id: string;
        type: "public-key";
        transports?: string[];
    }[];
    /** Resident-key / user-verification / attachment requirements. */
    authenticatorSelection?: AuthenticatorSelectionCriteria;
    /** Attestation conveyance. Leave unset (`"none"`) unless you verify it. */
    attestation?: AttestationConveyancePreference;
    /** Client extension inputs (`credProps`, `largeBlob`, …). */
    extensions?: AuthenticationExtensionsClientInputs;
}

/**
 * A passkey failure carrying a stable {@link PasskeyErrorKind} plus an English
 * message safe to show a user.
 *
 * A class rather than the plain `{ kind, message }` object the media classifier
 * returns, because these surface by rejecting a promise: an `Error` subclass keeps
 * stack traces, `instanceof` checks and logging intact, and `kind` is what code
 * branches on.
 */
export declare class PasskeyError extends Error {
    /** Stable, branchable classification. */
    readonly kind: PasskeyErrorKind;
    /**
     * Build a classified passkey error.
     *
     * @param kind - The classification a UI branches on.
     * @param message - English, user-safe explanation.
     * @param cause - The original thrown value, when there was one.
     */
    constructor(kind: PasskeyErrorKind, message: string, cause?: unknown);
}

/**
 * @tempest-limits file-lines, function-lines — the WebAuthn client half: the JSON
 * shapes both ceremonies exchange with a backend, base64url ↔ ArrayBuffer, the
 * capability probes and the error classifier. The two ceremonies are near-mirrors
 * that must not drift — register and authenticate encode the same credential fields
 * in the same order — and the file's docstring is also the specification of the four
 * backend routes it expects.
 */
/**
 * Classified reason a passkey ceremony did not produce a credential.
 *
 * The kinds group the raw `DOMException.name` values the way a UI has to branch
 * on them, which is *not* how the spec groups them:
 *
 * - `"cancelled"` covers `NotAllowedError`, which the browser raises both when
 *   the user dismissed the sheet and when the ceremony timed out. They are
 *   indistinguishable **by design** — telling a site "the user has no credential
 *   for you" would leak account existence — so a UI must treat them as one thing.
 * - `"already-registered"` (`InvalidStateError`) is not really a failure: this
 *   device already holds a credential for this user. The correct reaction is
 *   "you are already set up on this device", never a red error.
 * - `"rp-mismatch"` (`SecurityError`) is the single most common integration bug:
 *   `rp.id` must equal the page's domain or a registrable parent of it.
 */
export declare type PasskeyErrorKind = "unsupported" | "insecure" | "cancelled" | "already-registered" | "not-supported" | "rp-mismatch" | "invalid-options" | "aborted" | "unknown";

/** How the browser should surface the authentication ceremony. */
export declare type PasskeyMediation = "optional" | "conditional" | "required" | "silent";

/** Per-call knobs for {@link PasskeyClient.register}. */
export declare interface PasskeyRegisterInit {
    /** Cancel the ceremony (closes the browser sheet). */
    signal?: AbortSignal;
}

/** What the client sends to the backend to finish registration. */
export declare interface PasskeyRegistrationJSON {
    /** Base64url credential id. */
    id: string;
    /** Same bytes as `id`; both are sent because servers differ on which they read. */
    rawId: string;
    type: "public-key";
    /** `"platform"` (this device) or `"cross-platform"` (a phone or key). */
    authenticatorAttachment: string | null;
    response: {
        /** Base64url client data — the server re-checks challenge, origin and type. */
        clientDataJSON: string;
        /** Base64url attestation object, holding the new public key. */
        attestationObject: string;
        /** Transports the authenticator advertises, when the browser exposes them. */
        transports?: string[];
        /** COSE algorithm of the new key, when the browser exposes it. */
        publicKeyAlgorithm?: number;
        /** Base64url SPKI public key, when the browser exposes it. */
        publicKey?: string;
        /** Base64url authenticator data, when the browser exposes it. */
        authenticatorData?: string;
    };
    /** Extension outputs — `credProps.rk` tells you whether it is discoverable. */
    clientExtensionResults: AuthenticationExtensionsClientOutputs;
}

/** Server-issued authentication options, base64url JSON. */
export declare interface PasskeyRequestOptionsJSON {
    /** Base64url server challenge. */
    challenge: string;
    /** Relying party id. Defaults to the client's `rpId`, then to the origin. */
    rpId?: string;
    /** Ceremony timeout in ms. Defaults to the client's `timeoutMs`. */
    timeout?: number;
    /** Restrict to these credentials. **Omit it** for usernameless / autofill flows. */
    allowCredentials?: {
        id: string;
        type: "public-key";
        transports?: string[];
    }[];
    /** Whether the authenticator must verify the user (biometric / PIN). */
    userVerification?: UserVerificationRequirement;
    /** Client extension inputs. */
    extensions?: AuthenticationExtensionsClientInputs;
}

/**
 * Where a passkey ceremony is.
 *
 * `"prompting"` and `"verifying"` are split because they need different copy:
 * while prompting, the browser sheet is up and the user must touch a sensor;
 * while verifying, your backend is checking the signature and the user should
 * just wait.
 */
export declare type PasskeyStatus = "idle" | "prompting" | "verifying" | "success" | "error";

/**
 * Password field with toggle-visibility button and optional strength meter.
 *
 * @example
 * <PasswordInput label="Senha" showStrength autoComplete="new-password" />
 */
export declare const PasswordInput: ForwardRefExoticComponent<PasswordInputProps & RefAttributes<HTMLInputElement>>;

export declare interface PasswordInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
    /** Label rendered above the input. */
    label?: ReactNode;
    /** Helper text below — replaced by `error` when set. */
    helperText?: ReactNode;
    /** Error message. Adds `aria-invalid` + red border. */
    error?: string;
    /** Visual size of the input. */
    size?: "sm" | "md" | "lg";
    /** Show a strength meter below the field. Default `false`. */
    showStrength?: boolean;
    /** Override the automatic strength calc (0–4). */
    strength?: PasswordStrength;
    /** Custom labels per strength level (5 entries). */
    strengthLabels?: readonly [string, string, string, string, string];
    /** Custom toggle button labels for accessibility. */
    toggleLabels?: {
        show: string;
        hide: string;
    };
}

export declare type PasswordStrength = 0 | 1 | 2 | 3 | 4;

export { Path }

/**
 * Total length of a trajectory: the sum of haversine distances between each
 * consecutive pair of points. Returns `0` for an empty or single-point path.
 *
 * @param points - Ordered coordinates along the path.
 * @returns Cumulative distance in kilometers.
 */
export declare function pathLengthKm(points: readonly Coordinate[]): number;

/** Raw PCM ready to be wrapped in a RIFF container. */
export declare interface PcmAudio {
    /** One `Float32Array` per channel, samples in −1…1. */
    channels: readonly Float32Array[];
    sampleRate: number;
}

/** A running mesh. */
export declare interface PeerMesh {
    /**
     * Open a link to a peer.
     *
     * `offerer` decides which side sends the offer, and exactly one side of each
     * link must say `true`. Drive it from the arrival order your server already
     * imposes — the peer that joined **later** offers, the one already in the
     * room answers. That avoids glare by construction, without the rollback
     * dance of perfect negotiation and without depending on a browser
     * implementing argument-less `setLocalDescription`.
     */
    addPeer: (peerId: string, options: {
        offerer: boolean;
    }) => Promise<void>;
    /** Close one link and give its share of the uplink back to the others. */
    removePeer: (peerId: string) => void;
    /** Feed the mesh an `offer`, `answer` or `ice` message from `from`. */
    accept: (message: MeshMessage & {
        from: string;
    }) => Promise<void>;
    /**
     * Publish or retract one slot across every live link.
     *
     * `null` retracts: the sender keeps its negotiated transceiver and stops
     * producing, which is what mutes a microphone without disturbing the other
     * slots or the connection. Nothing renegotiates — the m-lines were allocated
     * before any track existed, which is what makes a mesh survive toggling: a
     * renegotiation per toggle is N-1 simultaneous offer/answer rounds every time
     * somebody unmutes.
     */
    setLocalTrack: (slot: string, track: MediaStreamTrack | null) => Promise<void>;
    /** Apply encoder limits, divided by the current size of the room. */
    applyQuality: (quality: MeshQuality) => Promise<void>;
    /** Replace the ICE servers used for links opened from now on. */
    setIceServers: (servers: RTCIceServer[]) => void;
    /** Close every link and report `closed`. */
    stop: () => void;
    /** The peers as the mesh currently sees them. */
    readonly peers: MeshPeer[];
    /**
     * The connection carrying one peer's link, or `null`.
     *
     * The escape hatch for everything this mesh does not model. `getStats()`,
     * `getSenders()`, an `RTCDataChannel`, an encoding tweak the `quality`
     * shape has no field for — all of it lives on the connection, and a mesh
     * that keeps it private turns adopting the mesh into losing a feature.
     *
     * {@link MeshPeer.connection} is the *state*, which is what a view needs;
     * this is the object, which is what a measurement needs. For the common
     * case of measuring, {@link PeerMeshOptions.stats} spares you the loop —
     * including the one-sampler-per-connection rule that a hand-rolled version
     * gets wrong.
     *
     * @param peerId - The id the peer was added under.
     * @returns The connection, or `null` when there is no link for that id.
     */
    getConnection: (peerId: string) => RTCPeerConnection | null;
}

export declare interface PeerMeshOptions {
    /** The lanes every link negotiates, in the order they are allocated. */
    slots: readonly MeshSlot[];
    /** Send one message to the peer named by `to`. The transport is yours. */
    send: (message: MeshMessage) => void;
    /** ICE servers for every connection this mesh opens. */
    iceServers?: RTCIceServer[];
    /** Called whenever the peer list or any peer's streams change. */
    onPeers?: (peers: MeshPeer[]) => void;
    /** Called when the aggregate state changes, with an optional detail. */
    onState?: (state: MeshState, detail?: string) => void;
    /** Called for a failure worth surfacing that is not fatal to the mesh. */
    onNotice?: (reason: string) => void;
    /** Initial encoder limits. */
    quality?: MeshQuality;
    /** Measure every link, on one timer the mesh owns. See {@link MeshStatsOptions}. */
    stats?: MeshStatsOptions;
    /**
     * Applies a local description, so the SDP can be rewritten on the way out.
     *
     * Defaults to `connection.setLocalDescription(description)`. The reason it
     * is a seam is `setTunedLocalDescription`: the mesh is what creates every
     * offer and answer, so without a hook here there is nowhere left to put the
     * Opus rewrite, and a call that adopts the mesh silently loses the bitrate
     * and channel layout it had negotiated before.
     *
     * Profiles are keyed by **audio m-line position**, which is legitimate for
     * exactly the reason slot routing is: the slot list fixes the order, so the
     * first audio slot is always the first audio m-line.
     *
     * @example
     * setLocalDescription: (connection, description) =>
     *     setTunedLocalDescription(connection, description, {
     *         0: MIC_PROFILE,
     *         1: SYSTEM_AUDIO_PROFILE,
     *     }),
     */
    setLocalDescription?: (connection: RTCPeerConnection, description: RTCSessionDescriptionInit) => Promise<unknown>;
}

/**
 * What percentage of `total` is `part`, with an empty base yielding `0`.
 *
 * The guard is the whole point: `(part / total) * 100` produces `NaN` when the
 * base is zero and `Infinity` when only the base is missing, and both reach the
 * screen as a broken label — `NaN%` on an empty dashboard is the single most
 * common way a panel announces that it has no data yet.
 *
 * Returns a **0–100** number, which is what a bar width and a label want.
 * `formatPercent` takes a 0–1 fraction instead, so pair them as
 * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the
 * fraction straight in.
 *
 * The result is not clamped: 120% of a target is a real number somebody wants to
 * see, and capping it would hide the interesting case.
 *
 * @example
 * percentOf(3, 4);  // 75
 * percentOf(5, 0);  // 0
 * percentOf(12, 8); // 150
 *
 * @param part - The measured amount.
 * @param total - The base it is measured against.
 * @returns The percentage, or `0` when the base is zero or either input is not finite.
 */
export declare function percentOf(part: number, total: number): number;

/**
 * Extract a permission list from a JWT.
 *
 * Reads the configured claim (default `"permissions"`); if absent, falls back to
 * the OAuth `"scopes"`/`"scope"` claims. Array claims are used as-is; string
 * claims are split on whitespace. Returns `[]` on any decode failure or when no
 * recognizable claim is present.
 *
 * @param token - The JWT to inspect (signature is **not** verified).
 * @param options - Optional claim override.
 * @returns The list of permission strings, or `[]` on failure.
 */
export declare function permissionsFromToken(token: string, options?: PermissionsFromTokenOptions): string[];

export declare interface PermissionsFromTokenOptions {
    /** JWT claim to read permissions from. Default: `"permissions"`. */
    claim?: string;
}

/**
 * Persist a TanStack `QueryClient` cache to IndexedDB (via
 * {@link createOfflineStore}) and restore it on boot — so a reload or a cold
 * offline start shows the last-known data instead of empty screens.
 *
 * Self-contained: uses `dehydrate`/`hydrate` from `@tanstack/react-query`
 * directly, so no `@tanstack/react-query-persist-client` dependency is needed.
 * Writes are throttled and subscribe to the query cache; call `unsubscribe` on
 * teardown. Dexie is a peer dependency of the offline store — install it.
 *
 * @param options - The client plus storage/throttle configuration.
 * @returns A handle with `restore`, `flush`, `clear` and `unsubscribe`.
 *
 * @example
 * const persistence = persistQueryClientOffline({ queryClient });
 * await persistence.restore(); // before first render
 * // ... later, on logout:
 * await persistence.clear();
 */
export declare function persistQueryClientOffline(options: OfflineQueryPersistenceOptions): OfflineQueryPersistence;

export declare const PhoneInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange"> & {
    value?: string;
    onChange?: (value: string) => void;
} & RefAttributes<HTMLInputElement>>;

/**
 * Create a new object containing only the given `keys` from `obj`.
 *
 * Missing keys are skipped. The input is never mutated.
 *
 * @example
 * pick({ id: 1, name: "Ana", age: 30 }, ["id", "name"]);
 * // { id: 1, name: "Ana" }
 */
export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;

/**
 * First container in `preferred` the browser can actually produce, or `null`.
 *
 * **There is no MP3 or WAV here, and that is not an omission.** `MediaRecorder`
 * emits Opus (in WebM or Ogg) on Chromium and Firefox and AAC (in MP4) on Safari —
 * no engine implements an MP3 or WAV encoder for it. If a backend needs WAV,
 * {@link blobToWav} converts one client-side with no dependency; if it needs MP3,
 * transcode on the server. Shipping an MP3 encoder would mean a WASM build of the
 * order of 150 KB in every consumer's bundle to serve one format, which is the
 * trade this SDK does not make.
 *
 * @param preferred - Candidates, best first. Defaults to {@link AUDIO_MIME_CANDIDATES}.
 * @returns A supported MIME type, or `null` when none is.
 */
export declare function pickAudioMimeType(preferred?: readonly string[]): string | null;

/**
 * First video container in `preferred` the browser can actually produce, or `null`.
 *
 * @param preferred - Candidates, best first. Defaults to {@link VIDEO_MIME_CANDIDATES}.
 * @returns A supported MIME type, or `null` when none is.
 */
export declare function pickVideoMimeType(preferred?: readonly string[]): string | null;

/**
 * One-time-password style input — N independent cells, paste support, auto-
 * advance on input, backspace flows back, arrow keys navigate.
 *
 * @example
 * <PinInput length={6} type="numeric" onComplete={(otp) => verify(otp)} />
 */
export declare const PinInput: ForwardRefExoticComponent<PinInputProps & RefAttributes<HTMLDivElement>>;

export declare interface PinInputProps {
    /** Number of cells. Default `6`. */
    length?: number;
    /** Allowed character set. `numeric` (default) rejects letters, `alphanumeric` allows both. */
    type?: PinInputType;
    /** Visual size. Default `"md"`. */
    size?: PinInputSize;
    /** Controlled value. */
    value?: string;
    /** Initial value (uncontrolled mode). */
    defaultValue?: string;
    /** Fires on every change with the current concatenated value. */
    onChange?: (value: string) => void;
    /** Fires when the user fills the last cell. */
    onComplete?: (value: string) => void;
    /** Show characters obscured (`*`). Default `false`. */
    masked?: boolean;
    /** Label rendered above the cells. */
    label?: string;
    /** Helper text below the cells. */
    helperText?: string;
    /** Error message — turns cells red and replaces helperText. */
    error?: string;
    /** Disable all cells. */
    disabled?: boolean;
    /** Auto-focus the first cell on mount. Default `false`. */
    autoFocus?: boolean;
    /** id for the wrapping group label association. */
    id?: string;
    className?: string;
}

export declare type PinInputSize = "sm" | "md" | "lg";

export declare type PinInputType = "numeric" | "alphanumeric";

/** A pixel coordinate inside the plotting viewport. */
export declare interface PixelPoint {
    x: number;
    y: number;
}

/** An event placed in the grid: which day, where vertically, which column. */
export declare interface PlacedEvent {
    event: SchedulerEvent;
    /** Index into the rendered day list. */
    dayIndex: number;
    /** Distance from the top of the day column, as a fraction of its height. */
    top: number;
    /** Height as a fraction of the day column. */
    height: number;
    /** Column this event occupies among its overlapping cluster, zero-based. */
    column: number;
    /** How many columns the cluster was split into. */
    columns: number;
}

/**
 * Convenience wrapper around a shared {@link AudioPlayerHandle}. Use this for
 * one-off notification sounds. For more complex flows (e.g. several
 * simultaneous channels), build a dedicated player with {@link createAudioPlayer}.
 */
export declare function playAudio(src: string, options?: PlayAudioOptions): Promise<HTMLAudioElement | null>;

export declare interface PlayAudioOptions {
    /** Volume between 0 and 1. Default: 1. */
    volume?: number;
    /** Loop the clip. Default: false. */
    loop?: boolean;
    /** Begin playback immediately. Default: true. */
    autoplay?: boolean;
    /** Stop the previous clip managed by this player. Default: false. */
    stopPrevious?: boolean;
    /**
     * Output device to play on, from `useMediaDevices().audioOutputs`.
     *
     * Ignored where the browser has no output routing (everything but Chromium) —
     * the clip still plays, on the system default. Useful for a chime that must land
     * on a headset while the call audio stays on the speakers.
     */
    sinkId?: string;
    /** Fired when playback ends naturally. */
    onEnded?: () => void;
    /** Fired on playback error. */
    onError?: (error: unknown) => void;
}

/** Per-play overrides. */
export declare interface PlaySfxOptions {
    /** Volume for this play, `0`–`1`, multiplied by the pool's master. Default `1`. */
    volume?: number;
}

/**
 * Pick the singular or plural form of a word based on `count`.
 *
 * Returns only the word (never the count). When `plural` is omitted it defaults
 * to `singular + "s"`.
 *
 * @example
 * pluralize(1, "item");            // "item"
 * pluralize(3, "item");            // "items"
 * pluralize(2, "person", "people"); // "people"
 */
export declare function pluralize(count: number, singular: string, plural?: string): string;

/**
 * Lightweight popover. Renders a positioned panel anchored to a trigger,
 * dismissed on outside click / Escape. Does NOT include collision detection
 * or smart positioning — pair with Floating UI if you need that.
 */
export declare function Popover({ trigger, children, placement, open, onOpenChange, defaultOpen, closeOnEsc, closeOnOutsideClick, className, }: PopoverProps): JSX.Element;

export declare type PopoverPlacement = "top" | "bottom" | "left" | "right";

export declare interface PopoverProps {
    /** Trigger element. Receives `onClick`/`aria-expanded`/`aria-controls`. */
    trigger: ReactElement<{
        onClick?: (e: React.MouseEvent) => void;
        "aria-expanded"?: boolean;
        "aria-controls"?: string;
    }>;
    children: ReactNode;
    placement?: PopoverPlacement;
    /** Controlled open state. */
    open?: boolean;
    /** Called when the user toggles or dismisses. */
    onOpenChange?: (open: boolean) => void;
    /** Default open state for uncontrolled usage. */
    defaultOpen?: boolean;
    /** Close on Escape. Default true. */
    closeOnEsc?: boolean;
    /** Close on outside click. Default true. */
    closeOnOutsideClick?: boolean;
    className?: string;
}

/**
 * Renders its children into a different part of the DOM tree via a React portal.
 *
 * Useful for overlays (modals, tooltips, dropdowns) that must escape parent
 * overflow/stacking contexts.
 *
 * Without `container` the target is the element currently presented fullscreen,
 * and `document.body` the rest of the time. `body` alone would be wrong during
 * fullscreen: the browser paints only the fullscreen element's subtree, so an
 * overlay mounted outside it is invisible and unclickable while looking perfectly
 * healthy in the DOM. Passing `container` opts out of that and pins the target.
 *
 * SSR-safe: renders `null` on the server and on the first client render, then
 * mounts the portal after hydration (when `document` is available).
 *
 * @param props - The portal props.
 * @returns The portal node once mounted, otherwise `null`.
 */
export declare function Portal({ children, container }: PortalProps): ReactNode;

export declare interface PortalProps {
    /** Content rendered through the portal. */
    children: ReactNode;
    /**
     * Target DOM node to render into.
     *
     * Defaults to the fullscreen element while one is presented, and to
     * `document.body` otherwise.
     */
    container?: Element | null;
}

/** Imperative controller returned by {@link createPositionTracker}. */
export declare interface PositionTracker {
    /** Begin watching position. No-op if already tracking. */
    start: () => void;
    /** Stop watching. Retains the recorded trajectory. */
    stop: () => void;
    /** Stop and discard the recorded trajectory. */
    clear: () => void;
    /** Snapshot of the recorded trajectory (newest last). */
    readonly points: readonly TrackPoint[];
    /** Total distance of the recorded trajectory in kilometers. */
    readonly distanceKm: number;
    /** Current tracker status. */
    readonly status: TrackerStatus;
}

/**
 * Minimal subset of `posthog-js` used by the adapter. Pass either the real
 * default export (`import posthog from "posthog-js"`) or a stubbed object
 * in tests.
 */
export declare interface PostHogLike {
    init?: (apiKey: string, options?: Record<string, unknown>) => void;
    identify: (distinctId: string, properties?: Record<string, unknown>) => void;
    capture: (eventName: string, properties?: Record<string, unknown>) => void;
    captureException?: (error: unknown, properties?: Record<string, unknown>) => void;
    reset?: () => void;
}

/** A lazy component that can also be fetched ahead of being rendered. */
export declare type PreloadableLazy<T extends AnyComponent> = ReturnType<typeof lazy<T>> & {
    /**
     * Start fetching the chunk now, before anything renders it.
     *
     * Call it on the interaction that makes the route likely — hovering the
     * link, opening the menu that holds it, finishing the step before it — so
     * the chunk is warm by the time the user commits and the suspense fallback
     * never appears.
     *
     * Shares its work with the render path: whichever fires first performs the
     * single fetch and the other awaits the same promise. Safe to call
     * repeatedly.
     *
     * @returns The module, once loaded. Rejects when every retry failed; that
     *   rejection is already handled internally, so a fire-and-forget call
     *   never surfaces as an unhandled rejection.
     */
    preload: () => Promise<{
        default: T;
    }>;
};

/** A model whose cached size should appear in the report. */
export declare interface ProfiledModel {
    /** Label for the report row, e.g. `"detector"`. */
    name: string;
    /** Cache Storage bucket holding the response, e.g. `"app-models"`. */
    cacheName: string;
    /** Request URL the model was cached under. */
    url: string;
}

/** A model's size as found in the cache. */
export declare interface ProfiledModelSize {
    name: string;
    /** Size in bytes, or `null` when uncached or the size is unreported. */
    bytes: number | null;
}

/**
 * Linear progress bar with determinate / indeterminate modes.
 *
 * The `progressbar` role requires an accessible name: it comes from
 * `aria-labelledby`, then explicit `aria-label`, then the visible `label`.
 */
export declare function Progress({ value, max, variant, indeterminate, showLabel, label, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, className, }: ProgressProps): JSX.Element;

export declare interface ProgressProps {
    /** Value between 0 and `max` (or 0-100 by default). Ignored when `indeterminate`. */
    value?: number;
    max?: number;
    variant?: ProgressVariant;
    /** Show an animated indeterminate bar. Default: false. */
    indeterminate?: boolean;
    /** Render a numeric label "x% / max" above the bar. Default: false. */
    showLabel?: boolean;
    /** Optional left-aligned descriptor (e.g. "Enviando arquivo…"). */
    label?: string;
    /**
     * Accessible name for the bar. Defaults to `label` when that is set —
     * provide it explicitly whenever the bar renders without a visible label,
     * otherwise screen readers announce an unnamed progressbar.
     */
    "aria-label"?: string;
    /** Id of an existing element that names the bar (alternative to `aria-label`). */
    "aria-labelledby"?: string;
    className?: string;
}

export declare type ProgressVariant = "primary" | "success" | "warning" | "danger";

/**
 * Project a geographic coordinate onto the unit Web Mercator plane. This is the
 * same projection tile servers use, so a self-hosted tile layer and the
 * tile-free SVG plot line up pixel-for-pixel.
 *
 * @param coord - Coordinate to project.
 * @returns `{ x, y }` in `[0, 1]`.
 */
export declare function projectMercator(coord: Coordinate): MercatorPoint;

/**
 * One page of the server delta pull.
 *
 * @typeParam TRemote - The server-side item shape.
 */
export declare interface PullPage<TRemote> {
    /** Items changed since the watermark, in this page. */
    items: TRemote[];
    /** Cursor for the next page, or `null` when this is the last page. */
    nextCursor: string | null;
    /**
     * Server clock to persist as the next watermark once the whole delta is
     * applied. `null` leaves the watermark unchanged.
     */
    serverTime: string | null;
}

/**
 * The keys worth offering for push-to-talk.
 *
 * Identified by `code` rather than `key` so a binding survives a layout change:
 * on an ABNT2 keyboard the `key` reported for the backquote position is not what
 * a US layout reports, while `Backquote` is the same physical key everywhere.
 *
 * Left-hand modifiers only. The right-hand ones sit under the hand that is
 * usually on the mouse, and a modifier that is also a shortcut prefix
 * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes
 * by choosing it.
 */
export declare const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[];

/**
 * Service-worker context helpers for handling `push` and `notificationclick`
 * events. Import these inside your own `sw.ts` — they expect to run in the
 * service-worker global scope, not in the main thread.
 *
 * @example
 *   /// <reference lib="webworker" />
 *   import { installPushHandler, installNotificationClickHandler } from "tempest-react-sdk";
 *
 *   installPushHandler({ defaultIcon: "/icons/Logo.png" });
 *   installNotificationClickHandler();
 */
export declare interface PushPayload {
    title?: string;
    body?: string;
    icon?: string;
    badge?: string;
    image?: string;
    tag?: string;
    url?: string;
    /** Arbitrary extra data forwarded to `event.notification.data`. */
    data?: Record<string, unknown>;
}

/** A key offered for push-to-talk, with the label a settings screen shows. */
export declare interface PushToTalkKey {
    /** `KeyboardEvent.code`, which is layout-independent. */
    code: string;
    /** What to show a person. `code` itself is not a label. */
    label: string;
}

/**
 * The label to show for a `KeyboardEvent.code`.
 *
 * @param code - The bound key's code.
 * @returns Its label, or the code itself for a key this list does not name —
 *     showing `"F13"` beats showing nothing.
 */
export declare function pushToTalkKeyLabel(code: string): string;

/** Raised when a payload cannot be encoded at the requested level. */
export declare class QRCapacityError extends Error {
    readonly length: number;
    readonly level: QRErrorCorrection;
    constructor(length: number, level: QRErrorCorrection);
}

/**
 * A QR symbol, encoded in the browser and drawn as SVG.
 *
 * No dependency and no network round trip: an image service would leak the
 * payload — a payment link, a session token, an invite — to a third party, and
 * the encoder is a few kilobytes.
 *
 * SVG rather than canvas so the symbol stays sharp at any size and prints at
 * the printer's resolution instead of the screen's. Everything is one path
 * (horizontal runs merged), because a version-10 symbol is 3 481 modules and
 * that many elements costs real paint time.
 *
 * The colours are **black on white in both themes, on purpose** — they are the
 * one part of the SDK that ignores the theme tokens. Scanners expect
 * dark-on-light, and the ones that cope with an inverted symbol do it slowly and
 * unreliably; a QR that looks integrated with a dark page and scans on the third
 * try is worse than one that looks pasted on. Wiring the modules to
 * `--tempest-text` would flip them light in dark mode and leave a light symbol
 * on the white background, which scans as nothing at all. Override
 * `color`/`background` only with a scanner in hand.
 *
 * @throws {QRCapacityError} When the payload is too long for a version-40
 * symbol at the chosen level. That is a programming error rather than a state
 * to render, so it surfaces instead of silently drawing nothing — wrap it in
 * `ErrorBoundary` if the payload comes from user input.
 *
 * @example
 * <QRCode value="https://tempest.dev" />
 * <QRCode value={pixPayload} level="H" size={220} label="QR do Pix" />
 */
export declare function QRCode({ value, size, level, margin, color, background, label, className, style, ...rest }: QRCodeProps): JSX.Element;

export declare interface QRCodeProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** The payload. Encoded as UTF-8 when it is not plain digits or upper-case text. */
    value: string;
    /** Rendered side in px, quiet zone included. Default `160`. */
    size?: number;
    /** Error correction level. Default `"M"`. */
    level?: QRErrorCorrection;
    /** Quiet zone in modules. The standard asks for 4; below that, scanners start to miss. */
    margin?: number;
    /** Module colour. Defaults to black — see the note on dark mode below. */
    color?: string;
    /** Background colour. Defaults to white. */
    background?: string;
    /**
     * Accessible name. Defaults to naming the payload, because a screen reader
     * user cannot scan the symbol: the content has to reach them as text.
     */
    label?: string;
}

export declare interface QREncodeOptions {
    /** Error correction level. Default `"M"`. */
    level?: QRErrorCorrection;
    /**
     * Force a minimum version. The encoder still grows past it when the payload
     * does not fit — a version is a floor, never a cap that silently truncates.
     */
    minVersion?: number;
}

/**
 * The fixed tables of ISO/IEC 18004, transcribed.
 *
 * They are data, not logic: the standard specifies them and there is nothing to
 * derive. They live apart from {@link ./qr-encode} so the algorithm reads as
 * algorithm and a typo in a table stays findable.
 */
/** Error correction level, by how much of the symbol it can lose and survive. */
export declare type QRErrorCorrection = "L" | "M" | "Q" | "H";

export declare interface QRMatrix {
    /** Side length in modules, including no quiet zone. */
    size: number;
    /** Row-major modules; `true` is dark. */
    modules: boolean[][];
    /** Symbol version, 1 to 40. */
    version: number;
    /** Level the symbol was encoded at. */
    level: QRErrorCorrection;
    /** The mode chosen for the payload. */
    mode: QRMode;
    /** Which of the eight masks scored best. */
    mask: number;
}

/** How the payload is packed into bits. */
export declare type QRMode = "numeric" | "alphanumeric" | "byte";

/**
 * Wrapper around `QueryClientProvider` that bootstraps a `QueryClient` with
 * sane SDK defaults (5-minute stale time, 30-minute gc time, one retry for
 * failures worth replaying).
 *
 * Retries follow {@link shouldRetryQuery} rather than a flat count: a 4xx other
 * than 408/429 is the server refusing on purpose, and replaying it only doubles
 * the network log while the spinner keeps turning.
 */
export declare function QueryProvider({ children, client, defaultOptions }: QueryProviderProps): JSX.Element;

export declare interface QueryProviderProps {
    children: ReactNode;
    /** Pass an existing client to share it across roots. */
    client?: QueryClient;
    /** Overrides for the default options applied when no `client` is provided. */
    defaultOptions?: DefaultOptions;
}

/**
 * Single radio button. Inside a {@link RadioGroup}, name/checked/onChange are
 * managed by the group; outside, behaves as a regular radio input.
 */
export declare const Radio: ForwardRefExoticComponent<RadioProps & RefAttributes<HTMLInputElement>>;

/**
 * Wraps multiple {@link Radio} children and coordinates selection via context.
 * Pass `value` for controlled mode or `defaultValue` for uncontrolled.
 */
export declare function RadioGroup({ value, defaultValue, onChange, name, disabled, horizontal, className, children, }: RadioGroupProps): JSX.Element;

export declare interface RadioGroupProps {
    /** Selected value (controlled). */
    value?: string;
    /** Default selected value (uncontrolled). */
    defaultValue?: string;
    /** Called when the selection changes. */
    onChange?: (value: string) => void;
    /** `name` attribute applied to every Radio inside. Auto-generated if omitted. */
    name?: string;
    /** Disable every Radio inside. */
    disabled?: boolean;
    /** Lay out radios horizontally. Default: false (column). */
    horizontal?: boolean;
    className?: string;
    children: ReactNode;
}

export declare interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
    label?: ReactNode;
    description?: ReactNode;
    value: string;
    wrapperClassName?: string;
}

/**
 * Generate a collision-resistant id suitable for client-side UI keys.
 *
 * Uses `crypto.randomUUID()` when available, falling back to a
 * timestamp + `Math.random()` combination otherwise. When `prefix` is given,
 * the result is formatted as `${prefix}-${id}`.
 *
 * @example
 * randomId();          // "9f1c2b3a-..." (uuid) or "lq3f8k-4a9z1" (fallback)
 * randomId("user");    // "user-9f1c2b3a-..."
 */
export declare function randomId(prefix?: string): string;

/**
 * Build a numeric range from `start` (inclusive) to `end` (exclusive).
 *
 * - `step` defaults to `1` and may be negative for descending ranges.
 * - Returns an empty array when no progress can be made toward `end`
 *   (wrong-direction step, zero step, or `start === end`).
 *
 * @param start - First value of the range.
 * @param end - Exclusive upper (or lower, for negative step) bound.
 * @param step - Increment between values; defaults to `1`.
 *
 * @example
 * range(0, 5);        // [0, 1, 2, 3, 4]
 * range(0, 10, 2);    // [0, 2, 4, 6, 8]
 * range(5, 0, -1);    // [5, 4, 3, 2, 1]
 * range(0, 5, -1);    // [] (wrong direction)
 * range(3, 3);        // []
 */
export declare function range(start: number, end: number, step?: number): number[];

/**
 * Dual-thumb range slider. Built on two native `<input type="range">` so it
 * stays accessible and works with keyboards/screen readers without
 * heavyweight positioning libs. The active fill is positioned via percentages.
 */
export declare function RangeSlider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, "aria-label": ariaLabel, className, }: RangeSliderProps): JSX.Element;

export declare interface RangeSliderProps {
    value: RangeValue;
    onChange: (value: RangeValue) => void;
    min?: number;
    max?: number;
    step?: number;
    label?: string;
    helperText?: string;
    disabled?: boolean;
    /** Formatter for the value badge next to the label. Defaults to `min – max`. */
    formatValue?: (value: RangeValue) => string;
    /**
     * Accessible name for the pair, for when the visible `label` block does not fit.
     *
     * Each thumb still gets its own suffixed name — `"Preço (mínimo)"` and
     * `"Preço (máximo)"` — because a screen reader user moving between the two
     * needs to know which end they are on. Takes precedence over `label`.
     */
    "aria-label"?: string;
    className?: string;
}

export declare type RangeValue = [number, number];

export declare type RatingSize = "sm" | "md" | "lg";

/**
 * Star rating control. Renders `max` stars, fills the first `value`. Click a
 * star to set rating (when not readonly). Hovering previews the value.
 */
export declare function RatingStars({ value, max, onChange, size, readonly, disabled, label, className, }: RatingStarsProps): JSX.Element;

export declare interface RatingStarsProps {
    /** Current selected value (1..max). 0 means none. */
    value: number;
    /** Total number of stars. Default 5. */
    max?: number;
    onChange?: (value: number) => void;
    size?: RatingSize;
    readonly?: boolean;
    disabled?: boolean;
    /** Accessible label for the rating group. */
    label?: string;
    className?: string;
}

/** One issue as either supported shape reports it. */
declare interface RawIssue {
    readonly message: string;
    readonly path?: readonly IssuePathSegment[] | undefined;
}

/**
 * Pick the readable foreground for a background, by contrast ratio.
 *
 * Used for `--tempest-primary-foreground`: a generated brand color can land
 * anywhere on the lightness axis, and hardcoding white would silently produce
 * unreadable buttons for light brands (yellow, lime, cyan).
 */
export declare function readableForeground(background: string, light?: string, dark?: string): string;

/**
 * Read the uplink the transport estimates for this path, in kbps.
 *
 * This is the field that tells a cap being honoured apart from a cap that is
 * drowning: `bytesSent` reports the same 2500 kbps whether the path has room
 * for it or the queue behind it is growing. No fixed budget can stand in for it
 * — a domestic uplink of 1 Mbps and a fibre link differ by an order of
 * magnitude, and in Brazil the upload routinely is a tenth of the download
 * beside it.
 *
 * @param report - A report from `RTCPeerConnection.getStats()`.
 * @returns The estimate in kbps, or `null` while there is none. Every reader
 *   needs a fallback for that, not a default of zero.
 *
 * @example
 * const headroom = readAvailableOutgoingKbps(await pc.getStats());
 * if (headroom !== null && headroom < asked) lowerTheCap(headroom);
 */
export declare function readAvailableOutgoingKbps(report: RTCStatsReport): number | null;

/**
 * Sample the device capabilities the browser reports.
 *
 * Safe to call during SSR: without a `navigator` every field is `null`.
 *
 * @returns The profile, with `null` for anything this platform withholds.
 *
 * @example
 * ```typescript
 * const device = readDeviceProfile();
 * console.log(device.hardwareConcurrency); // 8
 * console.log(device.deviceMemoryGb);      // 8 on Chromium, null on Safari
 * ```
 */
export declare function readDeviceProfile(): DeviceProfile;

/**
 * Read what the encoder says is holding the picture back.
 *
 * `"bandwidth"` wins when senders disagree, because it is the only reason a
 * lower cap answers. The spec's `"none"` comes back as `null`.
 *
 * @param report - A report from `RTCPeerConnection.getStats()`.
 * @returns The reason, or `null` when nothing is limiting the picture.
 *
 * @example
 * if (readQualityLimitation(await pc.getStats()) === "cpu") stopBlurringTheBackground();
 */
export declare function readQualityLimitation(report: RTCStatsReport): RTCQualityLimitationReason | null;

/**
 * Read whether the link is travelling through a TURN relay.
 *
 * Resolved only from the pair the browser names, never from a merely
 * `succeeded` one: a relayed route is somebody's hosting bill, and reporting
 * one from a pair that carries nothing bills a cost nobody is paying.
 *
 * @param report - A report from `RTCPeerConnection.getStats()`.
 * @returns `true` when the carrying pair's local candidate is a relay.
 *
 * @example
 * if (readRelayed(await pc.getStats())) capTheStreamThatCostsMoney();
 */
export declare function readRelayed(report: RTCStatsReport): boolean;

/**
 * Read the round trip of the candidate pair actually carrying the link.
 *
 * A `succeeded` pair is kept as a last resort because not every browser names
 * the selected one — losing the reading entirely is worse than an occasionally
 * optimistic one. See {@link carryingPair} for the chain and why the middle
 * step exists.
 *
 * @param report - A report from `RTCPeerConnection.getStats()`.
 * @returns Round trip in milliseconds, rounded, or `null` when nothing reported
 *   one — which is the normal state before the connection settles.
 *
 * @example
 * const rttMs = readRoundTripMs(await pc.getStats());
 */
export declare function readRoundTripMs(report: RTCStatsReport): number | null;

/**
 * Read a token's computed value from an element (default: `<html>`).
 *
 * Useful to bridge CSS tokens into JS that cannot take a `var()` — canvas
 * drawing, chart libraries that set SVG attributes, `<meta name="theme-color">`.
 *
 * @param name - Token name, with or without the leading `--`.
 * @param element - Element to resolve against. Omit for `document.documentElement`;
 *   an explicit `null` (a ref that has not attached yet) reads nothing rather than
 *   silently falling back to the root, whose value may be a different theme.
 * @returns The trimmed value, or `""` when unset or outside a browser.
 */
export declare function readThemeToken(name: string, element?: Element | null): string;

/**
 * The sentence a reader gets for a receipt, for the tooltip and the screen reader.
 *
 * Partial counts are spelled out rather than rounded to a state: "delivered to 3
 * of 9" is the information the sender actually wants when the ticks are not blue
 * yet, and it is the part a glyph cannot carry.
 *
 * @param receipt - Per-recipient counts.
 * @param strings - Locale strings for the thread.
 * @returns One sentence describing delivery and reading.
 */
export declare function receiptLabel(receipt: ChatReceipt, strings: {
    deliveredAll: string;
    deliveredSome: (delivered: number, total: number) => string;
    readAll: string;
    readSome: (read: number, total: number) => string;
}): string;

export { redirect }

/** Recommended refetch intervals (milliseconds). */
export declare const REFETCH_TIME: {
    readonly REALTIME: number;
    readonly FAST: number;
    readonly DEFAULT: number;
    readonly SLOW: number;
};

/**
 * RefreshIndicator — pull-to-refresh wrapper for touch devices.
 *
 * Wraps scrollable `children` and listens for a downward drag that starts while the
 * container is scrolled to the top. Pulling past `threshold` and releasing triggers
 * `onRefresh`; the SDK {@link Spinner} is shown while pulling and during the refresh.
 */
export declare function RefreshIndicator({ onRefresh, children, threshold, disabled, className, }: RefreshIndicatorProps): JSX.Element;

export declare interface RefreshIndicatorProps {
    /** Invoked when the user pulls past `threshold` and releases. May be async. */
    onRefresh: () => void | Promise<void>;
    /** Scrollable content to wrap. */
    children: ReactNode;
    /** Pixels the user must pull past to trigger a refresh. Defaults to `80`. */
    threshold?: number;
    /** When true, pull-to-refresh is inert. */
    disabled?: boolean;
    className?: string;
}

/**
 * Request a Periodic Background Sync registration.
 *
 * Checks the `periodic-background-sync` permission first and only registers
 * when it is granted, so calling this unconditionally is safe. The browser
 * ultimately decides whether and how often the `periodicsync` event fires.
 *
 * @param options - The registration, tag and interval.
 * @returns `true` when the periodic sync was registered, else `false`
 *   (unsupported, permission denied, or registration threw).
 *
 * @example
 * const reg = await navigator.serviceWorker.ready;
 * await registerPeriodicSync({ registration: reg, minIntervalMinutes: 360 });
 */
export declare function registerPeriodicSync(options: RegisterPeriodicSyncOptions): Promise<boolean>;

/**
 * Main-thread helper to register a Periodic Background Sync, the counterpart to
 * the `periodicsync` listener installed by `installBackgroundSync`. Chrome-only
 * and gated behind the `periodic-background-sync` permission plus a site
 * engagement heuristic; degrades to a no-op (returns `false`) everywhere else.
 */
/** Options for {@link registerPeriodicSync}. */
export declare interface RegisterPeriodicSyncOptions {
    /** The active service-worker registration. */
    registration: ServiceWorkerRegistration;
    /** Sync tag; must match `installBackgroundSync`'s `periodicSyncTag`. Default `tempest-bg-sync-periodic`. */
    tag?: string;
    /**
     * Minimum interval between runs, in minutes. The browser treats this as a
     * floor and may space runs out much further. Default `720` (12h).
     */
    minIntervalMinutes?: number;
}

/**
 * Register a service worker with consistent update-detection wiring.
 *
 * Skips silently when the runtime has no `serviceWorker` support. The host
 * app keeps full control over the SW file — this helper only handles the
 * boilerplate around `register()` and update detection.
 *
 * Two things can mean "an update is ready", and only one of them is an event.
 * `updatefound` covers the worker that installs while this tab is open. The
 * commoner case has no event at all: the user visited after a deploy, the new
 * worker installed and went to `waiting`, they closed the tab, and they are back
 * now. `install` already happened, so nothing fires — which is why `waiting` is
 * read directly once the registration resolves. Both routes go through the same
 * dedupe, so a worker is announced once even when both apply.
 *
 * Neither route fires without `navigator.serviceWorker.controller`: no
 * controller means this is the first install, which is `onReady` territory, not
 * an update the user should be prompted about.
 *
 * With `autoUpdate` enabled it additionally polls `registration.update()` on
 * an interval and (by default) reloads the page when a freshly activated worker
 * takes control — a framework-agnostic equivalent of `vite-plugin-pwa`'s
 * auto-update client, implemented directly on `navigator.serviceWorker`.
 *
 * @returns The registration when it succeeds, or `null` when unsupported.
 */
export declare function registerServiceWorker(options: RegisterServiceWorkerOptions): Promise<ServiceWorkerRegistration | null>;

export declare interface RegisterServiceWorkerOptions {
    /** Public URL of the compiled service worker file (e.g. `/sw.js`). */
    url: string;
    /** SW scope (default: SW directory). */
    scope?: string;
    /** Called once the registration is active. */
    onReady?: (registration: ServiceWorkerRegistration) => void;
    /**
     * Called when a new worker has finished installing while another worker
     * still controls the page. The host app typically prompts the user to
     * reload and then calls {@link skipWaiting} on the returned worker.
     *
     * Fires for a worker that was already `waiting` when `register()` resolved
     * — the state a user returning after a deploy actually finds — as well as
     * for one that installs during this session, and at most once per worker.
     */
    onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;
    /** Called on registration failure. */
    onError?: (error: unknown) => void;
    /**
     * When `true`, poll the server for a fresh service worker on an interval
     * (see {@link RegisterServiceWorkerOptions.updateIntervalMs}) and, unless
     * {@link RegisterServiceWorkerOptions.reloadOnActivate} is disabled, reload
     * the page as soon as a new worker takes control. Mirrors the auto-update
     * behaviour of `vite-plugin-pwa` without depending on it. Default `false`.
     */
    autoUpdate?: boolean;
    /**
     * How often, in ms, to call `registration.update()` while `autoUpdate` is
     * on. Browsers already re-check roughly every 24h; an hourly poll keeps
     * long-lived sessions current without flooding the network. Default
     * `3600000` (1 hour).
     */
    updateIntervalMs?: number;
    /**
     * When `autoUpdate` is on, reload the page once a new worker takes control
     * (`controllerchange`), guarded against reload loops. Set to `false` to
     * keep polling but leave the reload to the host app. Default `true`.
     */
    reloadOnActivate?: boolean;
}

/** WCAG 2.x relative luminance of a hex color. */
export declare function relativeLuminance(hex: string): number;

/**
 * Render a date as a human-friendly relative-time string (e.g. "5 min atrás")
 * inside a semantic `<time>` element with a machine-readable `dateTime`.
 *
 * Delegates the wording to the `relativeTime` util; "pt" maps to its "pt-BR"
 * locale.
 *
 * @example
 * <RelativeTime date={post.createdAt} locale="en" />
 */
export declare function RelativeTime({ date, locale, ...props }: RelativeTimeProps): JSX.Element;

/**
 * Render a `Date` / ISO string as a relative-time string. Supports past and
 * future, PT-BR (default) and English.
 *
 * @example
 * relativeTime(new Date(Date.now() - 90_000));         // "1 min atrás"
 * relativeTime("2026-05-17T10:00:00Z", { locale: "en" }); // "5h ago"
 */
export declare function relativeTime(input: Date | string | number, options?: {
    locale?: RelativeTimeLocale;
    now?: Date | number;
}): string;

export declare type RelativeTimeLocale = "pt-BR" | "en";

export declare interface RelativeTimeProps extends HTMLAttributes<HTMLTimeElement> {
    /** The instant to render relative to now. */
    date: Date | string | number;
    /** Output language. Defaults to "pt". */
    locale?: "pt" | "en";
}

/**
 * Build an `applyOptimistic` that removes the entry matching the item's id
 * (by `idField`) from the list. For `delete` mutations, pass variables carrying
 * at least the id field.
 *
 * @typeParam T - The list item shape.
 * @param idField - The identity field. Default `"id"`.
 * @returns An `(current, item) => T[]` patcher for a list cache.
 *
 * @example
 * useOfflineMutation<{ id: string }, Note[], Note>({
 *     sync, queryKey: ["notes"],
 *     toEntry: ({ id }) => ({ op: "delete", recordId: id }),
 *     applyOptimistic: removeById(),
 * });
 */
export declare function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(idField?: keyof T): (current: T[] | undefined, item: V) => T[];

/** Renders the instruction shown when the browser has no install prompt. */
export declare type RenderInstallHint = (input: InstallHintInput) => ReactNode;

export declare interface ReorderPayload {
    from: number;
    to: number;
}

export declare interface RequestOptions extends Omit<RequestInit, "body"> {
    body?: unknown;
    params?: Record<string, string | number | boolean | undefined | null>;
    /**
     * Abort this request.
     *
     * Inherited from `RequestInit` and forwarded to `fetch`, so it has always
     * worked — but nothing said so, which made it a capability nobody could find.
     * Declared here for that reason alone. Pass the `signal` react-query hands to
     * a `queryFn` and the request is cancelled on unmount and on refetch.
     */
    signal?: AbortSignal | null;
    /**
     * Send this request with no `Authorization` header, and never enter the
     * refresh-and-replay cycle on a `401`.
     *
     * This is what login and refresh need: a route that must not carry the
     * token it is about to obtain, and whose own `401` must surface rather than
     * call `refresh()` again — which would recurse. Before 0.66.0 the only way
     * to get it was a second client, which is why `createTempestAuth` used to
     * build three.
     */
    skipAuth?: boolean;
    /**
     * Send the `Authorization` header, but let a `401` surface instead of
     * refreshing and replaying.
     *
     * The narrower half of {@link skipAuth}, for a call that is authenticated
     * but whose failure the caller wants to see — a token probe, a background
     * poll that should not fight for the refresh lock.
     */
    skipAuthRetry?: boolean;
    /**
     * Retry policy for this request, overriding the client's.
     *
     * Replaces `config.retry` entirely rather than merging into it, the same
     * way `config.retry` is read today: a merged `shouldRetry` would silently
     * combine two policies that were each written to be complete.
     *
     * `false` turns retrying off for one call on a client that has it on;
     * `true` or {@link RetryOptions} turns it on for one call on a client that
     * does not.
     */
    retry?: boolean | RetryOptions;
    /**
     * Override the client's timeout for this request, in milliseconds. `null`
     * disables it, which is the escape hatch for a stream or a long poll.
     *
     * Composed with `signal`, not replacing it: whichever fires first wins, and
     * the two are told apart — a timeout surfaces as an {@link ApiError} with
     * `status: 0`, while an abort you asked for propagates as an abort.
     */
    timeout?: number | null;
}

/**
 * Ask the browser to make this origin's storage persistent, so IndexedDB and
 * the Cache Storage are not silently evicted under disk pressure — essential
 * for durable offline-first data.
 *
 * The browser may grant silently, prompt, or deny based on engagement heuristics.
 *
 * @returns `true` when storage is (now or already) persisted, else `false`.
 */
export declare function requestPersistentStorage(): Promise<boolean>;

/**
 * A two-pane split layout with a draggable divider. The first pane is sized via
 * `flex-basis` as a percentage; the second pane fills the rest. Drag the divider
 * with a pointer, or focus it and use the arrow keys to adjust by 2% steps.
 *
 * The size is clamped to `[min, max]` at all times.
 */
export declare function Resizable({ direction, defaultSize, min, max, children, className, ...props }: ResizableProps): JSX.Element;

export declare type ResizableDirection = "horizontal" | "vertical";

export declare interface ResizableProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Split orientation. `horizontal` (default) places panes side by side. */
    direction?: ResizableDirection;
    /** Initial size of the first pane, as a percentage. Defaults to `50`. */
    defaultSize?: number;
    /** Lower clamp for the first pane size, in percent. Defaults to `10`. */
    min?: number;
    /** Upper clamp for the first pane size, in percent. Defaults to `90`. */
    max?: number;
    /** Exactly two panes — `[paneA, paneB]`. */
    children: [ReactNode, ReactNode];
}

/**
 * Decide what the encoder gives up, letting physics override the preference.
 *
 * `maintain-framerate` is honoured while there are bits enough for the frames to
 * be worth keeping. Once the room's division has taken the budget below the
 * fluid floor, holding the rate halves what each frame receives and the picture
 * is worse than the lower rate it replaced — so below that line the preference
 * is overridden rather than obeyed.
 *
 * Two things decide *which* budget answers that question:
 *
 * - **`null` is the most generous case, not the absent one.** A slot with no cap
 *   is unbounded, which is exactly where fluidity should hold. Reading it as
 *   missing — and then deciding from a modest camera beside it — is the answer
 *   backwards.
 * - **{@link MeshQuality.degradationAnchor} names the slot the choice was
 *   about.** Without it the largest cap across the video slots answers, which
 *   is right when the slots are interchangeable and wrong when they are not.
 *
 * @param quality - What was asked for, including the anchor and the floor.
 * @param effective - What the room's share actually allows.
 * @returns The degradation preference to write onto the senders, or `undefined`
 *     when the caller expressed no preference.
 */
export declare function resolveDegradation(quality: MeshQuality, effective: MeshQuality): RTCDegradationPreference | undefined;

export declare type ResolvedTheme = "light" | "dark";

/**
 * Resolve the tick state of an outgoing message.
 *
 * A group needs three states where a single message has two: sent to the server,
 * delivered to the recipients, read by the recipients. A boolean `status` collapses
 * the middle one, so an app that has per-recipient counts either invents its own
 * glyph or shows a message as read when one person out of nine opened it.
 *
 * The counts win when they are there, and the thresholds are deliberately "all":
 * blue ticks in every messenger mean the whole room, and reporting "read" for a
 * partial count is the failure that makes people distrust the indicator entirely.
 * A `totalRecipients` of zero — a note to self, a thread whose membership the app
 * does not track — falls back to `status`, because "read by all of nobody" is not
 * a claim worth making.
 *
 * `"failed"` and `"sending"` come from `status` regardless: they are about this
 * side of the wire, and no recipient count exists yet.
 *
 * @param message - The message being rendered.
 * @returns The tick state, or `null` when there is nothing to show.
 */
export declare function resolveReceiptState(message: ChatMessage): ChatReceiptState | null;

/**
 * Responsive value — either a single value applied at all breakpoints, or
 * an object with `mobile` / `tablet` / `desktop` overrides. Apps can mix
 * any combination; `mobile` is the base, `tablet` / `desktop` cascade up.
 */
export declare type ResponsiveValue<T> = T | {
    mobile?: T;
    tablet?: T;
    desktop?: T;
};

/** A resumable upload in progress. Build one with {@link createResumableUpload}. */
export declare interface ResumableUpload {
    /**
     * Create (or re-attach to) the upload and push chunks until it is complete.
     *
     * Resolves `null` when the run stopped because of `pause()` or `abort()` —
     * neither is a failure. Rejects with a `TempestApiError` when the server
     * refused and the retries ran out.
     */
    start(): Promise<ResumableUploadResult | null>;
    /** Stop after the in-flight chunk is dropped, keeping the resume point. */
    pause(): void;
    /** Continue from the server's offset. Same resolution contract as `start`. */
    resume(): Promise<ResumableUploadResult | null>;
    /**
     * Stop for good.
     *
     * @param options - `discard: true` also sends `DELETE` (tus termination) and
     *   forgets the persisted record, so the next `start()` uploads from zero.
     */
    abort(options?: {
        discard?: boolean;
    }): Promise<void>;
    /** Current state. */
    readonly state: ResumableUploadState;
    /** Bytes the server has confirmed. */
    readonly offset: number;
    /** The upload URL, once creation succeeded. */
    readonly url: string | null;
    /** The resume key in use. */
    readonly key: string;
}

/** Options for {@link createResumableUpload}. */
export declare interface ResumableUploadOptions {
    /** tus creation endpoint, e.g. `"/api/uploads"`. */
    endpoint: string;
    /** The bytes to upload. A `File` also supplies the default resume key. */
    file: Blob | File;
    /** Bytes per `PATCH`. Default {@link DEFAULT_CHUNK_SIZE}. */
    chunkSize?: number;
    /** Sent as `Upload-Metadata` (base64-encoded values), e.g. `{ filename }`. */
    metadata?: Record<string, string>;
    /** Extra headers on every request. */
    headers?: Record<string, string>;
    /** Returns the current bearer token, read before each request. */
    getToken?: () => string | null | undefined;
    /**
     * Origins besides `endpoint`'s that may receive the `getToken` credential.
     *
     * Since 0.66.0 the bearer token is scoped to the origin of `endpoint`, and
     * the creation response's `Location` no longer decides where it goes. A
     * server that hands the upload to object storage on another host still
     * works — the `PATCH` requests simply carry no `Authorization`, which is
     * what a presigned storage URL expects anyway.
     *
     * List the storage origin here when it does need the API's token.
     */
    trustedOrigins?: readonly string[];
    /** Send cookies. Default `false`. */
    withCredentials?: boolean;
    /**
     * Resume key. Defaults to a fingerprint of endpoint + file name/size/mtime, so
     * picking the same file after a reload resumes instead of restarting.
     */
    key?: string;
    /**
     * Where to persist resume state. Defaults to `localStorage`. Pass `null` to
     * disable persistence — resume then only survives a network blip, not a reload.
     */
    storage?: ResumableUploadStorage | null;
    /** Backoff for a failed chunk. Forwarded to `retry`. Default 5 attempts. */
    retry?: RetryOptions;
    /** Called on every upload-progress tick and after every confirmed chunk. */
    onProgress?: (progress: ResumableUploadProgress) => void;
    /** Called whenever {@link ResumableUpload.state} changes. */
    onStateChange?: (state: ResumableUploadState) => void;
}

/** Byte-level progress for a resumable upload. */
export declare interface ResumableUploadProgress {
    /** Bytes the server holds, including anything a resume skipped. */
    loaded: number;
    /** Total size of the file. */
    total: number;
    /** `loaded / total`, between 0 and 1. */
    fraction: number;
    /** Bytes already on the server when this run started. `0` on a fresh upload. */
    resumedFrom: number;
}

/** What has to survive a page reload for a resume to be possible. */
export declare interface ResumableUploadRecord {
    /** Upload URL the creation POST returned, absolute. */
    url: string;
    /** Last offset the server confirmed. */
    offset: number;
    /** File size, so a different file under the same key is not resumed into. */
    size: number;
    /** Idempotency key of the creation request, reused if creation is retried. */
    idempotencyKey: string;
    /** Epoch ms of the last write, so an app can sweep stale records. */
    updatedAt: number;
}

/** What a finished upload resolves with. */
export declare interface ResumableUploadResult {
    /** The tus upload URL — hand this to your API to link the stored file. */
    url: string;
    /** Total bytes uploaded. */
    size: number;
}

/**
 * Where a resumable upload is.
 *
 * `"paused"` and `"aborted"` are both "not running", but only `"paused"` keeps the
 * persisted offset — `abort({ discard: true })` throws it away.
 */
export declare type ResumableUploadState = "idle" | "creating" | "uploading" | "paused" | "done" | "error" | "aborted";

/**
 * Persistence for resume state. Sync or async — both are awaited.
 *
 * Implement it over anything: the default is `localStorage`, and
 * `createOfflineStore` from `@/offline` slots in when you already have a Dexie
 * database open.
 */
export declare interface ResumableUploadStorage {
    /** Read the record for `key`, or `null`. */
    get(key: string): Promise<ResumableUploadRecord | null> | ResumableUploadRecord | null;
    /** Write the record for `key`. */
    set(key: string, record: ResumableUploadRecord): Promise<void> | void;
    /** Forget the record for `key`. */
    delete(key: string): Promise<void> | void;
}

/**
 * Run `factory()` with exponential backoff. Each attempt awaits an
 * increasing delay capped at `maxDelay`. Throws the last error if every
 * attempt fails.
 *
 * @example
 * const data = await retry(() => api.get("/flaky"), { retries: 5 });
 */
export declare function retry<T>(factory: () => Promise<T>, options?: RetryOptions): Promise<T>;

export declare interface RetryOptions {
    /** Max attempts (including the first). Default: 3. */
    retries?: number;
    /** Initial backoff in ms. Doubles each attempt, capped at `maxDelay`. Default: 300. */
    initialDelay?: number;
    /** Maximum delay between attempts. Default: 10_000. */
    maxDelay?: number;
    /**
     * Honor a `Retry-After` hint on the thrown error (`error.retryAfter`, in
     * seconds — populated by {@link createApiClient} on `429`/`503`). When
     * present it overrides the exponential backoff for that attempt. The value
     * is capped at `maxDelay`. Default: true.
     */
    respectRetryAfter?: boolean;
    /**
     * Return false to stop retrying for a specific error.
     *
     * Default: replay anything that is not a recognisable API error — a
     * transport failure has no status to judge — and, for one that is, only the
     * statuses {@link isRetriableStatus} accepts. A `403` on an admin-only
     * endpoint and a `404` for a deleted record are the server's final answer;
     * repeating them spends the caller's time to show the same error twice.
     */
    shouldRetry?: (error: unknown, attempt: number) => boolean;
    /** Called before each retry with the upcoming delay. */
    onRetry?: (info: {
        attempt: number;
        delay: number;
        error: unknown;
    }) => void;
    /** Cancel pending retries. */
    signal?: AbortSignal;
}

/** Serialize sRGB channels (`0`–`1`, clamped) back to a `#rrggbb` string. */
export declare function rgbToHex(r: number, g: number, b: number): string;

export declare interface RoleAccessControlConfig {
    /** Permission strings granted directly, regardless of role. */
    permissions?: string[];
    /** Map of role name → permission strings granted by that role. */
    roles?: Record<string, string[]>;
    /** The active role(s). Their permissions (from `roles`) are merged in. */
    role?: string | string[];
}

/** Role label used in the turn header and by screen readers. */
export declare function roleLabel(role: AIChatRole, strings: AIChatStrings): string;

export { Route }

/**
 * Declarative route guard built on React Router's `<Navigate>`. Renders its
 * children when `when` is `true`, redirects when it is `false`, and holds on
 * `"pending"`. Pairs naturally with `createAuthStore` for protected areas, and
 * with `useCan` for permissions that resolve over the network.
 *
 * @example
 * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo="/login">
 *     <Outlet />
 * </RouteGuard>
 *
 * @example
 * const { allowed, isLoading } = useCan({ action: "read", resource: "finance" });
 *
 * <RouteGuard when={isLoading ? "pending" : allowed} fallback={<Spinner />}>
 *     <Outlet />
 * </RouteGuard>
 */
export declare function RouteGuard({ when, fallback, redirectTo, replace, children, }: RouteGuardProps): JSX.Element;

export declare interface RouteGuardProps {
    /**
     * Whether access is allowed — typically
     * `useAuthStore((s) => s.isAuthenticated)`.
     *
     * `"pending"` is the third answer, for a permission that has not resolved
     * yet: it holds the decision and renders {@link fallback} instead of
     * choosing between two wrong moves — redirecting someone who does have
     * access, or showing the screen to someone who does not.
     */
    when: RouteGuardResult;
    /**
     * Rendered while `when` is `"pending"`. Defaults to nothing, which is a
     * blank screen — pass the same spinner the rest of the app uses.
     */
    fallback?: ReactNode;
    /** Where to redirect when `when` is falsy (default: `"/"`). */
    redirectTo?: string;
    /** Replace history entry on redirect instead of pushing (default: true). */
    replace?: boolean;
    /** Protected content, usually `<Outlet />` for a guarded layout route. */
    children: ReactNode;
}

/**
 * What a route guard can answer.
 *
 * `true` renders the route, `false` redirects — and `"pending"` is the third
 * answer a two-state guard cannot give. Without it, a permission that resolves
 * asynchronously has to lie while it is in flight, and both lies are wrong:
 * answering `false` redirects the person who **does** have the permission,
 * every time the route is opened cold (F5 on the URL, an external link);
 * answering `true` renders the screen for someone who does not, until the
 * answer lands.
 */
export declare type RouteGuardResult = boolean | "pending";

/** Router history strategy used by {@link AppRouter}. */
export declare type RouterKind = "browser" | "hash" | "memory";

export { Routes }

/**
 * Pluggable routing backend. A backend turns two coordinates into a
 * {@link TravelEstimate}. Mirrors the `RoutingBackend` protocol from
 * `tempest-fastapi-sdk` so client and server share the same contract.
 *
 * Implement this to route against your own self-hosted engine (OSRM, Valhalla,
 * GraphHopper). The offline {@link estimateTravel} heuristic satisfies the same
 * shape without any network.
 */
export declare interface RoutingBackend {
    route: (origin: Coordinate, destination: Coordinate, options?: {
        mode?: TravelMode;
    }) => Promise<TravelEstimate>;
}

/** A single runtime-caching rule, matched against each `GET` request. */
export declare interface RuntimeRoute {
    /** A `RegExp` tested against the full URL, or a predicate over the parsed URL. */
    match: RegExp | ((url: URL, request: Request) => boolean);
    /** How to resolve a match. */
    strategy: RuntimeStrategy;
    /** Cache bucket name for this route. */
    cacheName: string;
    /** Trim the cache to at most this many entries (FIFO) after each write. */
    maxEntries?: number;
    /** Treat a cached response older than this (seconds) as a miss. */
    maxAgeSeconds?: number;
    /** For `network-first`: fall back to cache after this timeout (seconds). */
    networkTimeoutSeconds?: number;
    /**
     * Serve HTTP `Range` requests (206 Partial Content) by slicing the cached
     * full response. Enable for audio/video so seeking works offline. The full
     * resource is cached once (the `Range` header is stripped before caching).
     */
    rangeRequests?: boolean;
}

/**
 * @tempest-limits file-lines — precache, runtime strategies (cache-first, network-
 * first, stale-while-revalidate), expiry and the inspect/clear helpers all address
 * the same Cache Storage namespace, and the naming scheme that keeps them from
 * evicting each other is the file's whole contract.
 */
/**
 * Service-worker caching helpers — a small, dependency-free subset of what
 * Workbox provides: precaching of the build's app shell (so the app launches
 * offline) plus runtime caching strategies for fonts, APIs and images.
 *
 * Import these inside your own `sw.ts`. They run in the service-worker global
 * scope, not the main thread. Pair `installPrecache` with the
 * `tempestPwaManifest()` Vite plugin (from `tempest-react-sdk/vite`), which
 * emits the `precache-manifest.json` this reads at install time.
 *
 * @example
 *   /// <reference lib="webworker" />
 *   import { installRuntimeCache, installPrecache } from "tempest-react-sdk/sw";
 *
 *   // Register specific routes FIRST so they win over the precache catch-all.
 *   installRuntimeCache([
 *     { match: /\/api\//, strategy: "network-first", cacheName: "api", maxAgeSeconds: 300 },
 *   ]);
 *   installPrecache();
 */
/** Caching strategy for a runtime route. Mirrors the common Workbox trio. */
export declare type RuntimeStrategy = "cache-first" | "network-first" | "stale-while-revalidate";

/**
 * Apply `env(safe-area-inset-*)` padding so content avoids iOS notch /
 * Android navbar / device chrome. Wrap the outermost container of pages
 * with sticky headers/footers.
 *
 * @example
 * <SafeArea edges={["top"]}>
 *     <Navbar />
 * </SafeArea>
 */
export declare function SafeArea({ edges, inline, className, children, ...props }: SafeAreaProps): JSX.Element;

export declare type SafeAreaEdge = "top" | "right" | "bottom" | "left";

export declare interface SafeAreaProps extends HTMLAttributes<HTMLDivElement> {
    /** Edges to pad. Default `["top","right","bottom","left"]` (all). */
    edges?: SafeAreaEdge[];
    /** Render as inline (use `display: contents`). */
    inline?: boolean;
    children?: ReactNode;
}

/** A schema exposing zod's `.safeParse`, including versions older than `~standard`. */
export declare interface SafeParseSchemaLike<T> {
    readonly safeParse: (value: unknown) => {
        readonly success: true;
        readonly data: T;
    } | {
        readonly success: false;
        readonly error: {
            readonly issues: readonly RawIssue[];
        };
    };
}

/**
 * Divide the video caps by the size of the room.
 *
 * A mesh sends one copy of everything per participant, so the uplink is the
 * shared resource and the caps are what compete for it. Nothing is divided while
 * the caller is alone with one peer — that is the case the largest sizes exist
 * for, and dividing a budget that is not being shared would make them
 * unreachable in the only call where they fit.
 *
 * The floor is what keeps the division honest: without it a busy room allocates
 * tens of kbps per stream, and everybody loses the picture instead of the excess
 * giving way.
 *
 * @param quality - The caps as asked for.
 * @param peers - How many links are live.
 * @returns The caps to actually apply. The input is never mutated, so a room
 *     that empties out climbs back to what was asked for.
 */
export declare function scaleForRoom(quality: MeshQuality, peers: number): MeshQuality;

/** The ten steps of a Tempest tint scale, lightest to darkest. */
export declare type ScaleStep = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;

/**
 * Every step of a token scale, in order — for rendering a legend.
 *
 * A continuous scale needs a legend showing the ramp with its end labels; without
 * one the reader has no way to turn a colour back into a number.
 *
 * @param kind - Which scale.
 * @returns The token references, lightest/coolest first.
 */
export declare function scaleSteps(kind: "sequential" | "diverging"): ChartColorToken[];

/**
 * An agenda: events placed on a time grid across consecutive days.
 *
 * `Calendar` is a date *picker* — it answers "which day?". This answers "what is on
 * those days, and when", which needs a different structure entirely: a vertical time
 * axis, events sized by duration, and overlapping events sitting side by side.
 *
 * That last part is the one worth naming. Overlapping events are grouped into
 * clusters of mutual overlap and every event in a cluster shares one column count,
 * so widths line up; a column is reused the moment it frees, so `9–10`, `9–10`,
 * `10–11` takes two columns and not three. The layout is pure and lives in
 * `scheduler-layout.ts`.
 *
 * Times are local. An event crossing midnight is split into both day columns, and
 * the day range is built by incrementing the calendar day, so a DST boundary does
 * not duplicate or skip a date.
 *
 * @example
 * <Scheduler
 *     events={bookings}
 *     days={7}
 *     startHour={7}
 *     endHour={21}
 *     onEventClick={(e) => open(e.id)}
 *     onSlotClick={(start) => createAt(start)}
 * />
 */
declare function Scheduler_2({ events, anchor, days: dayCount, startHour, endHour, snapMinutes, onEventClick, onSlotClick, renderEvent, locale, showCurrentTime, now, className, ...rest }: SchedulerProps): JSX.Element;
export { Scheduler_2 as Scheduler }

/** An event on the schedule. `start`/`end` are absolute instants in local time. */
export declare interface SchedulerEvent {
    id: string;
    title: string;
    start: Date;
    end: Date;
    /** Render across the all-day lane instead of the time grid. */
    allDay?: boolean;
    /** Free-form payload the app passes through. */
    data?: Record<string, unknown>;
}

export declare interface SchedulerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Events to place. Instants are read in the browser's local time. */
    events: readonly SchedulerEvent[];
    /** Any day within the range to show. Default: today. */
    anchor?: Date;
    /** How many consecutive days to render. `1` is a day view, `7` a week. Default `7`. */
    days?: number;
    /** First visible hour, `0`–`23`. Default `8`. */
    startHour?: number;
    /** Last visible hour, `1`–`24`. Default `20`. */
    endHour?: number;
    /** Minutes a click on empty space snaps to. Default `30`. */
    snapMinutes?: number;
    /** Called when an event is activated by click, `Enter` or `Space`. */
    onEventClick?: (event: SchedulerEvent) => void;
    /** Called with the snapped instant when empty space is clicked. */
    onSlotClick?: (start: Date) => void;
    /** Render an event's contents. Defaults to its title and start time. */
    renderEvent?: (event: SchedulerEvent) => ReactNode;
    /** Locale for the day and hour labels. Default `"pt-BR"`. */
    locale?: string;
    /** Draw the current-time line. Default `true`. */
    showCurrentTime?: boolean;
    /** Fixed "now" for the indicator. Default: the real clock, ticking each minute. */
    now?: Date;
}

/**
 * The SDK's answer to "the caller handed me a schema" — one normalizer behind
 * every option that takes one.
 *
 * Internal, and imported by path rather than through the `utils` barrel: the
 * function exists so `decodeFrame` and anything else that validates a payload
 * share one reading of the two shapes below, not so consumers can call it. The
 * types are public, because an option typed `SchemaLike<T>` is a name the
 * consumer has to be able to write down.
 *
 * Two shapes are accepted on purpose:
 *
 * - [Standard Schema](https://standardschema.dev) (`~standard`), which zod
 *   (>=3.24), valibot and arktype all implement, so the SDK validates against
 *   any of them without depending on one;
 * - `.safeParse`, because the SDK's own zod range starts at `^3.23.0`, which
 *   predates `~standard`, and because it is the method every zod user already
 *   knows.
 */
/** One field-level complaint from a schema validation. */
export declare interface SchemaIssue {
    /** Dotted path to the offending field, or `"<root>"` for the value itself. */
    path: string;
    /** What the validator said was wrong. */
    message: string;
}

/** Anything the SDK can validate a payload against. */
export declare type SchemaLike<T> = StandardSchemaLike<T> | SafeParseSchemaLike<T>;

/** Lifecycle of a screen share. */
export declare type ScreenCaptureStatus = "idle" | "requesting" | "sharing" | "error";

/**
 * A styled scroll container that overflows on the chosen axis and renders a
 * thin custom scrollbar (WebKit) while staying fully functional in browsers
 * without scrollbar styling. Forwards `className`, `style` and the ref to the
 * underlying `<div>`.
 *
 * While the content overflows, the container becomes a named, focusable group.
 * A scroll area whose children are plain text holds nothing focusable, so
 * without that a keyboard user can see the scrollbar and has no way to move it.
 * The tab stop disappears again once the content fits, so an area that does not
 * scroll never adds one. Callers may still override `tabIndex` or `role`.
 */
export declare const ScrollArea: ForwardRefExoticComponent<ScrollAreaProps & RefAttributes<HTMLDivElement>>;

export declare type ScrollAreaOrientation = "vertical" | "horizontal" | "both";

export declare interface ScrollAreaProps extends HTMLAttributes<HTMLDivElement> {
    /** Caps the container height; numbers are treated as pixels. */
    maxHeight?: number | string;
    /** Which axis scrolls. Default `"vertical"`. */
    orientation?: ScrollAreaOrientation;
    /**
     * Accessible name used while the content actually overflows, when the area
     * takes a tab stop of its own. Defaults to a generic one; name it when the
     * page holds several scroll areas.
     */
    scrollLabel?: string;
}

/** Which axis to watch for overflow. */
export declare type ScrollOverflowAxis = "horizontal" | "vertical" | "both";

/**
 * Search input with magnifier icon and a clear button. Controlled component:
 * pass `value` and `onChange`.
 */
export declare const SearchBar: ForwardRefExoticComponent<SearchBarProps & RefAttributes<HTMLInputElement>>;

export declare interface SearchBarProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "onChange"> {
    value: string;
    onChange: (value: string) => void;
    onClear?: () => void;
    wrapperClassName?: string;
}

/**
 * iOS-style segmented control. Two-to-five mutually-exclusive options
 * rendered as a single connected pill bar.
 *
 * @example
 * <SegmentedControl
 *     value={view}
 *     onChange={setView}
 *     options={[
 *         { value: "list", label: "Lista" },
 *         { value: "grid", label: "Grade" },
 *     ]}
 * />
 */
export declare function SegmentedControl<TValue extends string = string>({ options, value, onChange, size, fullWidth, className, "aria-label": ariaLabel, ...props }: SegmentedControlProps<TValue>): JSX.Element;

export declare interface SegmentedControlOption<TValue extends string = string> {
    value: TValue;
    label: ReactNode;
    icon?: ReactNode;
    disabled?: boolean;
}

export declare interface SegmentedControlProps<TValue extends string = string> extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
    /** Available segments. */
    options: SegmentedControlOption<TValue>[];
    /** Selected value. */
    value: TValue;
    /** Fires with the new value when a segment is selected. */
    onChange: (value: TValue) => void;
    /** Visual size. Default `"md"`. */
    size?: "sm" | "md" | "lg";
    /** Stretch to full width of container. Default `false`. */
    fullWidth?: boolean;
    /** Group label for screen readers. */
    "aria-label"?: string;
}

/**
 * Native `<select>` wrapper. Either provide `options` for a quick render, or
 * pass `<option>` children directly.
 *
 * Two variants:
 *
 * - `"field"` (default) — label, control, helper text and error slot, for a form.
 * - `"chip"` — the control alone, sized to its content, for a settings row where
 *   the icon and the label are already on the left and the control belongs on the
 *   right. Rendering the full field there stacks two labelled fields inside one
 *   list item, which is why every app ended up hand-rolling a native `<select>`
 *   with `appearance: none` — and hand-rolling it loses the focus ring, the
 *   disabled styling and the caret this component already solves.
 *
 * @example
 * <Select label="Estado" options={states} placeholder="Selecione" />
 *
 * @example
 * <ListTile title="Idioma" trailing={<Select variant="chip" aria-label="Idioma" options={langs} />} />
 */
export declare const Select: ForwardRefExoticComponent<SelectProps & RefAttributes<HTMLSelectElement>>;

/** What both variants of {@link Select} accept. */
declare interface SelectBaseProps extends SelectHTMLAttributes<HTMLSelectElement> {
    options?: SelectOption[];
    placeholder?: string;
    wrapperClassName?: string;
}

/**
 * The bare control, sized to its content.
 *
 * `aria-label` is required rather than optional, because the variant removes the
 * only visible label the component had. A settings row names the control in the
 * row's own text, which the `<select>` has no relationship to — so without this
 * the screen reader announces a combobox with no name at all.
 */
declare interface SelectChipProps extends SelectBaseProps {
    variant: "chip";
    "aria-label": string;
}

/** The full form field: label, control, helper text and error slot. */
declare interface SelectFieldProps extends SelectBaseProps {
    variant?: "field";
    label?: string;
    helperText?: string;
    error?: string;
}

export declare interface SelectOption {
    value: string | number;
    label: string;
    disabled?: boolean;
}

export declare type SelectProps = SelectFieldProps | SelectChipProps;

/**
 * Minimal subset of `@sentry/browser` used by the adapter. Lets you pass
 * either the real SDK module (`import * as Sentry from "@sentry/browser"`)
 * or a stubbed object in tests.
 */
export declare interface SentryLike {
    init?: (options: Record<string, unknown>) => void;
    setUser: (user: Record<string, unknown> | null) => void;
    addBreadcrumb: (breadcrumb: {
        category?: string;
        message?: string;
        level?: string;
        data?: Record<string, unknown>;
    }) => void;
    captureException: (error: unknown, hint?: {
        extra?: Record<string, unknown>;
        contexts?: Record<string, unknown>;
    }) => void;
    flush?: (timeout?: number) => Promise<boolean>;
}

/** How many steps the sequential token scale has. */
export declare const SEQUENTIAL_STEP_COUNT = 7;

/**
 * Build a magnitude scale over the sequential tokens.
 *
 * Returns `var(--tempest-chart-sequential-N)` rather than a hex string, so a
 * heatmap painted once follows the theme — including dark mode, whose steps are
 * chosen for the dark surface rather than flipped.
 *
 * @example
 * const color = sequentialScale({ min: 0, max: 250 });
 * <rect fill={color(value)} />
 *
 * @param options - The data domain, and whether every step must stay visible.
 * @returns A function from value to a CSS colour reference.
 */
export declare function sequentialScale(options: SequentialScaleOptions): (value: number) => ChartColorToken;

export declare interface SequentialScaleOptions {
    /** Lowest value in the data. */
    min: number;
    /** Highest value in the data. */
    max: number;
    /**
     * Keep every step visible against the surface, for discrete ordered marks.
     *
     * Off by default: a heatmap *wants* its near-zero cells to recede. Turn it on
     * for tiers, funnel stages or anything where each step is its own mark.
     */
    ordinal?: boolean;
}

/**
 * Send an element's audio to a specific output device.
 *
 * The `sinkId` comes from `useMediaDevices().audioOutputs` — and, like every device
 * label, that list is anonymous until a capture permission has been granted, so an
 * output picker realistically only works after the microphone has been allowed once.
 *
 * Returns `false` instead of throwing when the browser has no `setSinkId`, because
 * "this engine cannot route audio" is the common case and not an error the caller can
 * act on: the sound still plays, on the system default device. A rejected
 * `setSinkId` — a device that was unplugged between enumeration and playback is the
 * usual cause — also resolves `false`, and playback continues on the default.
 *
 * @param element - The `<audio>` or `<video>` element to route.
 * @param sinkId - Device id, or `""` for the system default.
 * @returns `true` when the route was applied.
 *
 * @example
 * const ok = await setAudioOutput(audioRef.current, selectedSpeakerId);
 * if (!ok) toast("Este navegador não permite escolher a saída de som.");
 */
export declare function setAudioOutput(element: HTMLMediaElement | null, sinkId: string): Promise<boolean>;

/**
 * {@link isDevBuild} stays internal, imported by path (`../utils/dev-mode`)
 * rather than through the `utils` barrel: re-exporting it would make a one-line
 * env read part of the package's public API, with the semver weight that
 * carries, for something no consumer asked for. Every dev-only diagnostic in
 * the SDK routes through it — `grep -rn "dev-mode" src/` for the current list,
 * which an enumeration written here would only drift away from.
 *
 * {@link setDevBuild} is public, because a context nothing compiles cannot be
 * detected from the inside. See its doc for when that is.
 */
/**
 * Tell the SDK whether the app around it was built for development.
 *
 * Call it once, at bootstrap, from a context {@link isDevBuild} cannot read:
 *
 * ```ts
 * import { setDevBuild } from "tempest-react-sdk";
 *
 * setDevBuild(import.meta.env.DEV);
 * ```
 *
 * **When you need it.** Not for an ordinary Vite, webpack, Rspack or Parcel
 * app: all of them substitute `process.env.NODE_ENV` while building the app, so
 * the automatic read already answers correctly there — measured for Vite 5
 * through 8 in {@link isDevBuild}, whose doc carries the table. What is left is
 * the context nothing compiles or nothing configures:
 *
 * - code no bundler transformed — a raw service-worker script registered as a
 *   file of its own, a plain `<script type="module">`;
 * - a staging or QA build that never sets `NODE_ENV=production`, where the
 *   automatic answer is `true` and `parseResponse` would put the raw response
 *   payload in an error string seen by real users. `setDevBuild(false)` closes
 *   that;
 * - a test that wants the other branch, and puts it back on the way out.
 *
 * `import.meta.env.DEV` cannot be read by the SDK on your behalf, which is why
 * the signal is a parameter: Vite would replace it while building *this
 * package*, and the published artifact would ship the constant.
 *
 * The default stays `false` when the read throws. `parseResponse` puts the raw
 * response payload in its message when this is on, so guessing `true` in a
 * context that cannot prove it leaks a payload into a production error string.
 * Silence is the safe default; the report is one line away for anyone who wants
 * it.
 *
 * Passing `undefined` clears the override and returns to automatic detection,
 * which is what a test that set it should do on the way out.
 *
 * @param value - `true` for a development build, `false` for production,
 *     `undefined` to go back to detecting it.
 *
 * @example
 * // A service worker, or any context no bundler transformed
 * setDevBuild(false);
 *
 * @example
 * // A test that flips it, and puts it back
 * afterEach(() => setDevBuild(undefined));
 */
export declare function setDevBuild(value: boolean | undefined): void;

/**
 * Cap what one sender transmits, in bits per second.
 *
 * This is the other half of the pair that confuses people: an Opus `fmtp` line
 * describes what we want **to receive**, while this is what limits what we
 * **send**. Both are needed, and in a mesh topology this one matters more,
 * because the uplink carries one copy of the stream per participant.
 *
 * The read-modify-write is not ceremony. `setParameters` only accepts the very
 * object `getParameters` handed back — a freshly built one is rejected — and a
 * sender that has not negotiated yet reports **no** encodings at all, so writing
 * to `encodings[0]` without checking throws on exactly the call that sets the
 * cap before the first offer.
 *
 * @param sender - The `RTCRtpSender` to cap, from `pc.getSenders()` or
 *   `transceiver.sender`.
 * @param maxBitrate - Ceiling in bits per second, or `null` to lift the cap.
 * @returns `false` when the browser refused the change, which happens when the
 *   sender has no track or the transceiver is gone. Playback continues
 *   uncapped — a call that keeps running beats one that throws over a bitrate.
 *
 * @example
 * const sender = pc.getSenders().find((s) => s.track?.kind === "audio");
 * if (sender) await setSenderBitrate(sender, 48_000);
 */
export declare function setSenderBitrate(sender: RTCRtpSender, maxBitrate: number | null): Promise<boolean>;

/**
 * Set a local description, falling back to the untouched one if it is refused.
 *
 * Chrome has been tightening what `setLocalDescription` accepts from edited SDP,
 * and there is no way to know in advance. Without a fallback the call dies
 * instead of merely losing the profile — which is the wrong trade by a wide
 * margin: worse audio beats no audio.
 *
 * @param connection - The peer connection.
 * @param description - The description from `createOffer` / `createAnswer`.
 * @param profiles - Passed straight to {@link tuneOpus}.
 * @returns `"tuned"` when the rewritten SDP was accepted, `"original"` when the
 *   fallback was used — worth reporting, because it means the profile silently
 *   did not apply.
 * @throws Whatever `setLocalDescription` throws for the original description: at
 *   that point the failure is not about the rewrite and the caller has to know.
 *
 * @example
 * const applied = await setTunedLocalDescription(pc, await pc.createOffer(), profiles);
 * if (applied === "original") logger.warn("opus profile refused by the browser");
 */
export declare function setTunedLocalDescription(connection: RTCPeerConnection, description: RTCSessionDescriptionInit, profiles: OpusProfile | OpusProfileMap): Promise<TunedDescriptionResult>;

/** Imperative handle over a pool of short sound effects. */
export declare interface SfxPool {
    /** Play a clip, allocating and caching its element on first use. */
    play: (src: string, options?: PlaySfxOptions) => void;
    /** Fetch clips ahead of the first play, so it is not silent while the file downloads. */
    preload: (src: string | string[]) => void;
    /** Set the master volume, applying it to anything already sounding. */
    setVolume: (volume: number) => void;
    /** Stop one source, or every source when called with no argument. */
    stop: (src?: string) => void;
    /** Release every element. Call on unmount. */
    dispose: () => void;
}

/** Options for {@link createSfxPool}. */
export declare interface SfxPoolOptions {
    /**
     * Master volume, `0`–`1`, multiplied into every per-play volume. Default
     * `1`. Wire it to the app's sound setting so one value governs the lot.
     */
    volume?: number;
    /**
     * Prefix applied to sources that are not absolute URLs — typically Vite's
     * `import.meta.env.BASE_URL`, so a build served from a subpath resolves.
     * Default `""`.
     */
    baseUrl?: string;
    /**
     * Elements kept per source. `1` (the default) restarts the clip on every
     * play, which is what a menu blip wants. Raise it to let a sound overlap
     * itself — a hit landing while the previous one is still ringing.
     */
    voices?: number;
    /**
     * Maximum number of distinct sources held. When exceeded, the least
     * recently played source is released. Default `48`.
     */
    maxSources?: number;
}

/**
 * Wrap the Web Share API with a uniform result object. Falls through to
 * `unsupported: true` when the browser lacks `navigator.share`, leaving the
 * caller free to render a custom fallback (copy-link, social buttons).
 */
export declare function share(payload: SharePayload): Promise<ShareResult>;

/**
 * Try the Web Share API with the given `Blob` as a file; fall back to a
 * download anchor when the browser cannot share files (desktop Firefox, older
 * iOS Safari, etc.).
 *
 * A companion to {@link share} for the common "export a generated artifact"
 * flow: on mobile it opens the native share sheet, and everywhere else it
 * triggers a plain download. Returns early when the user shares or cancels the
 * dialog; otherwise it downloads.
 *
 * @param blob - The binary payload to share or download.
 * @param fileName - The file name presented to the user.
 * @param options - Optional `title` for the share dialog.
 * @returns A promise that resolves once the share or download completes.
 *
 * @example
 * const zip = new Blob([bytes], { type: "application/zip" });
 * await shareOrDownloadBlob(zip, "export.zip");
 */
export declare function shareOrDownloadBlob(blob: Blob, fileName: string, options?: ShareOrDownloadOptions): Promise<void>;

/** Options for {@link shareOrDownloadBlob}. */
export declare interface ShareOrDownloadOptions {
    /** Title passed to the Web Share dialog. Defaults to the file name. */
    title?: string;
}

export declare interface SharePayload {
    title?: string;
    text?: string;
    url?: string;
    /** Files to share (supported only on a subset of browsers). */
    files?: File[];
}

export declare interface ShareResult {
    /** True when `navigator.share` resolved successfully. */
    shared: boolean;
    /** True when the platform did not support the requested payload. */
    unsupported: boolean;
    /** True when the user cancelled the share dialog. */
    cancelled: boolean;
    error?: unknown;
}

/**
 * Default `retry` for SDK queries: replay transport and server failures, never a
 * deliberate client-side refusal.
 *
 * A flat `retry: 1` replays a 403 on an admin-only listing and a 404 for a record
 * somebody deleted. The server meant both — the second attempt returns the same
 * answer, doubles the network log and holds the spinner on screen for the length
 * of another round trip. A network failure or a 5xx is a different thing: it may
 * well succeed on the next try, so those keep the previous behaviour.
 *
 * The status list is {@link isRetriableStatus}, shared with the client's own
 * policy. It used to be a second copy here, and the copy was missing `425` — so
 * a `425 Too Early` was replayed by `createApiClient({ retry: true })` and not
 * by a query, for the same error in the same app.
 *
 * @example
 * new QueryClient({ defaultOptions: { queries: { retry: shouldRetryQuery } } });
 *
 * @param failureCount - Attempts already made, as react-query counts them.
 * @param error - The rejection value from the query function.
 * @returns Whether react-query should try again.
 */
export declare function shouldRetryQuery(failureCount: number, error: unknown): boolean;

/**
 * Conditionally render children based on the viewport breakpoint.
 *
 * - `above` — render when viewport width is `>=` the given breakpoint.
 * - `below` — render when viewport width is `<` the given breakpoint.
 * - `only` — render only on the listed breakpoint(s).
 *
 * SSR-safe: first render uses `xs` (renders mobile content first); the
 * component re-renders once `useBreakpoint` has the real viewport width.
 */
export declare function Show({ above, below, only, children }: ShowProps): ReactNode;

export declare interface ShowProps {
    /** Render children only when viewport width is `>=` this breakpoint. */
    above?: Breakpoint;
    /** Render children only when viewport width is `<` this breakpoint. */
    below?: Breakpoint;
    /** Render only on specific breakpoints. Wins over `above`/`below` when set. */
    only?: Breakpoint | Breakpoint[];
    children: ReactNode;
}

/**
 * Desktop sidebar navigation. Pair with `<Show above="md">` and a `Drawer`
 * for mobile.
 *
 * Sixteen screens in one flat list is a wall, so `items` also takes section
 * headings and separators. A section renders as a labelled `role="group"`, which
 * is what tells a screen reader "Monitoring, group, 3 items" — the reason it is
 * not a styled `disabled` item, which would announce an unavailable button and
 * stay in the navigation order.
 *
 * @example
 * const [tab, setTab] = useState("home");
 * <Show above="md">
 *     <Sidebar
 *         header={<Brand />}
 *         items={[{ key: "home", label: "Home", icon: <Home /> }]}
 *         value={tab}
 *         onChange={setTab}
 *     />
 * </Show>
 *
 * @example
 * <Sidebar
 *     items={[
 *         { type: "section", key: "monitoring", label: "Monitoring" },
 *         { key: "overview", label: "Overview", href: "/overview" },
 *         { key: "activity", label: "Activity", href: "/activity" },
 *         { type: "section", key: "admin", label: "Administration" },
 *         { key: "settings", label: "Settings", href: "/settings" },
 *     ]}
 *     value={tab}
 *     onChange={setTab}
 * />
 */
export declare function Sidebar({ header, items, value, onChange, footer, collapsed, width, collapsedWidth, className, style, ...props }: SidebarProps): JSX.Element;

/**
 * One entry of the navigation list.
 *
 * An entry with no `type` is an item, which is what keeps a plain
 * `SidebarItem[]` a valid `SidebarEntry[]`: adding sections to this component
 * needed no change at any existing call site.
 */
export declare type SidebarEntry = ({
    type?: "item";
} & SidebarItem) | SidebarSection | SidebarSeparator;

export declare interface SidebarItem {
    key: string;
    label: ReactNode;
    icon?: ReactNode;
    badge?: ReactNode;
    disabled?: boolean;
    /**
     * Renders the entry as a link to this URL instead of a button.
     *
     * `onChange` still fires on click, so an app that tracks the active key keeps
     * working — the difference is that the entry now behaves like navigation:
     * middle-click, ctrl-click and "copy link address" do what the user expects,
     * and a screen reader announces a link rather than a button.
     *
     * A `disabled` entry ignores this and stays a `<button disabled>`: there is no
     * disabled state for an anchor, and dropping the `href` to fake one leaves a
     * link that announces itself as actionable and is not.
     */
    href?: string;
}

export declare interface SidebarProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
    /** Top slot — typically the logo + brand. */
    header?: ReactNode;
    /** Navigation entries. An entry with no `type` is an item. */
    items: SidebarEntry[];
    /** Active item key. */
    value?: string;
    /** Fires when an item is clicked. Receives the item's `key`. */
    onChange?: (key: string) => void;
    /** Bottom slot — typically settings/profile/logout. */
    footer?: ReactNode;
    /** Collapsed mode — only icons visible. Default `false`. */
    collapsed?: boolean;
    /** Width when expanded, in pixels or any CSS length. Default `240px`. */
    width?: number | string;
    /** Width when collapsed, in pixels or any CSS length. Default `64px`. */
    collapsedWidth?: number | string;
}

/**
 * A section heading. Every item after it belongs to the section, until the next
 * section or separator.
 */
export declare interface SidebarSection {
    type: "section";
    key: string;
    label: ReactNode;
}

/** A plain divider, for splitting the list without naming the parts. */
export declare interface SidebarSeparator {
    type: "separator";
    key: string;
}

/**
 * Signature capture on a canvas — the "sign here" field of a delivery receipt,
 * a service order, a term of acceptance.
 *
 * Strokes are kept as point lists and the canvas is **redrawn** from them, which
 * is what makes `undo` possible at all: a canvas holds pixels, not history, so
 * removing the last stroke means replaying the rest.
 *
 * The backing store is scaled by `devicePixelRatio`, so the line is crisp on a
 * phone instead of the blurry 1x bitmap a naive canvas produces.
 *
 * @example
 * ```tsx
 * const pad = useRef<SignaturePadHandle>(null);
 * const [empty, setEmpty] = useState(true);
 *
 * async function submit() {
 *   const blob = await pad.current?.toBlob("image/png");
 *   if (blob) await api.upload("/receipts/42/signature", blob);
 * }
 *
 * <SignaturePad ref={pad} label="Assinatura do cliente" onEmptyChange={setEmpty} />
 * <Button disabled={empty} onClick={submit}>Enviar</Button>
 * ```
 */
export declare const SignaturePad: ForwardRefExoticComponent<SignaturePadProps & RefAttributes<SignaturePadHandle>>;

/** Imperative handle exposed through `ref`. */
export declare interface SignaturePadHandle {
    /** Drop every stroke. */
    clear: () => void;
    /** Drop the last stroke. */
    undo: () => void;
    /** `true` while nothing has been drawn. */
    isEmpty: () => boolean;
    /** Export as a data URL. Returns `""` when the canvas is unavailable. */
    toDataURL: (type?: string, quality?: number) => string;
    /** Export as a `Blob` — what you actually upload. `null` when unavailable. */
    toBlob: (type?: string, quality?: number) => Promise<Blob | null>;
}

export declare interface SignaturePadProps {
    /** Drawing surface width in CSS pixels. Default `400`. */
    width?: number;
    /** Drawing surface height in CSS pixels. Default `160`. */
    height?: number;
    /**
     * Stroke color. Defaults to the canvas' computed `color`, which the
     * stylesheet binds to `--tempest-text` — so the signature follows the theme
     * (including dark mode) instead of being hardcoded black.
     */
    penColor?: string;
    /** Stroke width in CSS pixels. Default `2`. */
    penWidth?: number;
    /** Blocks drawing and dims the surface. */
    disabled?: boolean;
    /** Accessible name of the surface. Default `"Signature"`. */
    label?: string;
    /** Called on the first move of each stroke. */
    onBegin?: () => void;
    /** Called when a stroke ends, with the current image as a data URL. */
    onEnd?: (dataUrl: string) => void;
    /** Called whenever the emptiness changes — wire it to a submit button. */
    onEmptyChange?: (isEmpty: boolean) => void;
    /** Renders the Clear/Undo buttons. Default `true`. */
    showActions?: boolean;
    clearLabel?: string;
    undoLabel?: string;
    className?: string;
}

/** Loading placeholder block. Use `variant="text"` for inline lines, `circle` for avatars. */
export declare function Skeleton({ variant, width, height, className, style }: SkeletonProps): JSX.Element;

export declare interface SkeletonProps {
    variant?: "rect" | "text" | "circle";
    width?: number | string;
    height?: number | string;
    className?: string;
    style?: CSSProperties;
}

/**
 * Tell a waiting worker to activate immediately. Pair with `onUpdate` to roll
 * out updates after the user confirms a reload prompt.
 */
export declare function skipWaiting(worker: ServiceWorker): void;

/**
 * Resolve after `ms` milliseconds.
 *
 * @example
 * await sleep(500); // pauses for half a second
 */
export declare function sleep(ms: number): Promise<void>;

/**
 * Single-thumb slider built on a native `<input type="range">`, so it stays
 * accessible (keyboard + screen reader) with no positioning libs. The active
 * fill is a percentage-width bar. For a two-thumb range, use `RangeSlider`.
 */
export declare function Slider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, "aria-label": ariaLabel, className, }: SliderProps): JSX.Element;

export declare interface SliderProps {
    /** Current value. */
    value: number;
    /** Called with the new value on every change. */
    onChange: (value: number) => void;
    min?: number;
    max?: number;
    step?: number;
    label?: string;
    helperText?: string;
    disabled?: boolean;
    /** Formatter for the value badge next to the label. Defaults to the raw number. */
    formatValue?: (value: number) => string;
    /**
     * Accessible name, for when the visible `label` block does not fit.
     *
     * A slider in a one-line footer, a table cell or a toolbar has no room for the
     * label row above the track, and without this every such control announces
     * itself as "Slider" — several on the same screen become indistinguishable to a
     * screen reader. Takes precedence over `label`; wrapping the field in an outer
     * `<label>` does not work, because an explicit `aria-label` on the input wins
     * the accessible-name precedence order.
     */
    "aria-label"?: string;
    className?: string;
}

/**
 * Convert a string into a URL-safe slug.
 *
 * - Strips accents/diacritics.
 * - Lowercases.
 * - Replaces non-alphanumeric runs with `-`.
 * - Trims leading/trailing separators.
 *
 * @example
 * slugify("São Paulo / Centro"); // "sao-paulo-centro"
 */
export declare function slugify(input: string): string;

/** Where a dragged item would land if dropped now. */
export declare interface SortableDropTarget {
    /** Index the item started at, within its own group. */
    from: number;
    /** Index it would move to, within the destination group. */
    to: number;
    /**
     * Group the item started in — a Kanban column, for instance. `undefined` for a
     * plain single-list sortable.
     */
    fromGroup?: string;
    /** Destination group. Equal to `fromGroup` when the move stays in one group. */
    toGroup?: string;
}

/** Props to spread on each sortable item. */
export declare interface SortableItemProps {
    /** Marks the item for hit-testing. */
    "data-sortable-index": number;
    /** Group the item belongs to, when the sortable spans several lists. */
    "data-sortable-group"?: string;
    /** `true` while this item is the one being moved. */
    "data-sortable-active"?: boolean;
    /** Grab handle wiring: starts a pointer drag. */
    onPointerDown: (event: PointerEvent_2<HTMLElement>) => void;
    /** Keyboard reordering — see {@link UseSortableResult}. */
    onKeyDown: (event: KeyboardEvent_2<HTMLElement>) => void;
    /** Puts the item in the tab order so the keyboard path is reachable. */
    tabIndex: number;
    role: "option";
    "aria-roledescription": string;
    "aria-selected": boolean;
}

export declare type SortDirection = "asc" | "desc";

/**
 * Flex spacer — pushes siblings apart inside a flex container. Equivalent
 * to `<div style={{ flex: 1 }}>` but typed and intent-revealing.
 *
 * @example
 * <Stack direction="horizontal">
 *     <Button>Cancelar</Button>
 *     <Spacer />
 *     <Button variant="primary">Salvar</Button>
 * </Stack>
 */
export declare function Spacer({ axis, className, ...props }: SpacerProps): JSX.Element;

export declare type SpacerAxis = "both" | "x" | "y";

export declare interface SpacerProps extends HTMLAttributes<HTMLDivElement> {
    /** Axis to flex along. Default `"both"` (`flex: 1`). */
    axis?: SpacerAxis;
}

/**
 * A tiny inline chart: shape only, no axes, no legend.
 *
 * Sized to sit in a table cell or beside a number, which is why it is plain SVG on
 * the root entry rather than a recharts wrapper — a sparkline in a data table should
 * not oblige an app to install a charting library.
 *
 * It carries `role="img"` and a spoken description of the series (direction, ends,
 * extremes). Without that it is an unlabelled image: a sparkline has no axis or
 * legend to fall back on, so a screen reader would reach it and read nothing. Pair it
 * with the number it annotates — the shape is context, never the only way to read the
 * value.
 *
 * @example
 * <Sparkline data={last30Days} />
 * <Sparkline data={revenue} variant="area" width={120} height={32} />
 *
 * // Same axis across a column, so the rows are comparable
 * <Sparkline data={row.series} min={0} max={columnMax} />
 */
export declare function Sparkline({ data, width, height, variant, color, showEnd, min, max, valueFormatter, label, className, ...rest }: SparklineProps): JSX.Element;

export declare interface SparklineProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
    /** The series, in order. Non-finite entries are skipped. */
    data: readonly number[];
    /** Drawing width in px. Default `88`. */
    width?: number;
    /** Drawing height in px. Default `24`. */
    height?: number;
    /** Which mark to draw. Default `"line"`. */
    variant?: SparklineVariant;
    /** Any CSS colour. Defaults to the first chart series token. */
    color?: string;
    /** Draw a dot on the last point. Default `true` for line and area. */
    showEnd?: boolean;
    /** Force the low end of the value axis — use it to compare several sparklines. */
    min?: number;
    /** Force the high end. */
    max?: number;
    /** Render a value; used in the accessible description. */
    valueFormatter?: (value: number) => string;
    /**
     * Accessible name. Defaults to a sentence describing the series.
     *
     * Pass one when the surrounding text already says what is plotted — the default
     * still appends the shape, so a caller never ends up with an unlabelled image.
     */
    label?: string;
}

export declare type SparklineVariant = "line" | "area" | "bar";

/** One reading of what was heard. */
export declare interface SpeechAlternativeLike {
    transcript: string;
    confidence?: number;
}

/** A classified speech error with a human-readable, English message. */
export declare interface SpeechError {
    kind: SpeechErrorKind;
    message: string;
}

/** Classified reason recognition stopped or never started. */
export declare type SpeechErrorKind = "unsupported" | "not-allowed" | "no-speech" | "audio-capture" | "network" | "aborted" | "language-not-supported" | "unknown";

/** The `error` event, reduced to what this hook reads. */
export declare interface SpeechRecognitionErrorEventLike {
    error: string;
    message?: string;
}

/** The `result` event, reduced to what this hook reads. */
export declare interface SpeechRecognitionEventLike {
    /** Index of the first result that changed — everything before it is settled. */
    resultIndex: number;
    results: SpeechResultListLike;
}

/**
 * The slice of the Web Speech `SpeechRecognition` object this SDK uses.
 *
 * Declared here rather than imported: TypeScript's DOM lib ships the *event* types but
 * not the constructor, because the API is still prefixed in Chromium and absent in
 * Firefox. Exported so a test — or a consumer wrapping a different engine — can hand in
 * something else.
 */
export declare interface SpeechRecognitionLike {
    lang: string;
    continuous: boolean;
    interimResults: boolean;
    maxAlternatives: number;
    start: () => void;
    stop: () => void;
    abort: () => void;
    onresult: ((event: SpeechRecognitionEventLike) => void) | null;
    onerror: ((event: SpeechRecognitionErrorEventLike) => void) | null;
    onend: (() => void) | null;
    onstart: (() => void) | null;
}

/** One recognised phrase, settled (`isFinal`) or still being revised. */
export declare interface SpeechResultLike {
    isFinal: boolean;
    length: number;
    [index: number]: SpeechAlternativeLike | undefined;
}

/** The growing list of phrases in a session. */
export declare interface SpeechResultListLike {
    length: number;
    [index: number]: SpeechResultLike | undefined;
}

/**
 * Loading spinner with preset sizes (xs..xl). Provide `label` for screen
 * readers, `caption` for a visible message, and `overlay` to center it inside a
 * full-area container (e.g. a Suspense / route fallback).
 *
 * @example
 * <Spinner />
 * <Spinner size="lg" caption="Carregando…" overlay />
 */
export declare function Spinner({ size, className, label, caption, overlay, }: SpinnerProps): JSX.Element;

export declare interface SpinnerProps {
    size?: SpinnerSize;
    className?: string;
    /** Accessible label announced by screen readers. */
    label?: string;
    /**
     * Visible caption rendered under the spinner. When set, the spinner and
     * caption are wrapped in a centered column.
     */
    caption?: ReactNode;
    /**
     * Center the spinner inside a full-area overlay (fills the nearest
     * positioned ancestor; pair with a relative container or a route fallback).
     * Implies the wrapped layout.
     */
    overlay?: boolean;
}

export declare type SpinnerSize = "xs" | "sm" | "md" | "lg" | "xl";

/** Flex-based vertical or horizontal stack with a numeric `gap`. */
export declare function Stack({ direction, gap, align, justify, wrap, className, style, children, ...props }: StackProps): JSX.Element;

export declare type StackAlign = "start" | "center" | "end" | "stretch";

export declare type StackDirection = "vertical" | "horizontal";

export declare type StackJustify = "start" | "center" | "end" | "between";

export declare interface StackProps extends HTMLAttributes<HTMLDivElement> {
    /** Direction. Accepts responsive object — e.g. `{ mobile: "vertical", desktop: "horizontal" }`. */
    direction?: ResponsiveValue<StackDirection>;
    /** Gap as a CSS length. Numbers map to a multiple of the 4px scale. Accepts responsive object. */
    gap?: ResponsiveValue<number | string>;
    align?: StackAlign;
    justify?: StackJustify;
    wrap?: boolean;
    children?: ReactNode;
}

/** Recommended `staleTime` presets (milliseconds). */
export declare const STALE_TIME: {
    readonly SHORT: number;
    readonly DEFAULT: number;
    readonly LONG: number;
    readonly INFINITE: number;
};

/** A schema exposing the [Standard Schema](https://standardschema.dev) interface. */
export declare interface StandardSchemaLike<T> {
    readonly "~standard": {
        readonly validate: (value: unknown) => {
            readonly value: T;
            readonly issues?: undefined;
        } | {
            readonly issues: readonly RawIssue[];
        } | Promise<{
            readonly value: T;
            readonly issues?: undefined;
        } | {
            readonly issues: readonly RawIssue[];
        }>;
    };
}

/**
 * KPI card. Dashboard widget showing a label + big value + optional
 * delta/trend and hint.
 *
 * @example
 * <Stat label="Receita" value="R$ 12.345" delta="+12,4%" trend="up" hint="vs. mês anterior" />
 */
export declare function Stat({ label, value, delta, trend, hint, icon, className, ...props }: StatProps): JSX.Element;

export declare interface StatProps extends HTMLAttributes<HTMLDivElement> {
    /** Metric label (e.g. "Revenue", "Active users"). */
    label: ReactNode;
    /** Metric value (e.g. "R$ 12.345", "1.2k"). */
    value: ReactNode;
    /** Optional comparison delta — when set, renders alongside the value. */
    delta?: ReactNode;
    /** Trend direction for the delta. Default inferred from delta string. */
    trend?: StatTrend;
    /** Optional supporting context line below the value. */
    hint?: ReactNode;
    /** Optional leading icon. */
    icon?: ReactNode;
}

export declare type StatTrend = "up" | "down" | "flat";

export declare interface StepItem {
    label: ReactNode;
    /** Secondary line under the label — a hint, or "optional". */
    description?: ReactNode;
}

/**
 * Linear progress indicator for multi-step flows. Steps before `current`
 * render as completed; the step at `current` is active; later steps are
 * upcoming.
 */
export declare function Stepper({ steps, current, orientation, onStepClick, className, }: StepperProps): JSX.Element;

/**
 * Numeric +/− stepper. Common in checkout quantity selectors and admin
 * forms. Clamps to `[min, max]` and emits already-bounded values.
 *
 * @example
 * <StepperInput value={qty} onChange={setQty} min={1} max={10} />
 */
export declare const StepperInput: ForwardRefExoticComponent<StepperInputProps & RefAttributes<HTMLDivElement>>;

export declare interface StepperInputProps {
    /** Current value. */
    value: number;
    /** Fires with the new value (already clamped to min/max). */
    onChange: (value: number) => void;
    /** Lower bound. Default `0`. */
    min?: number;
    /** Upper bound. Default `Number.POSITIVE_INFINITY`. */
    max?: number;
    /** Increment per click. Default `1`. */
    step?: number;
    /** Visual size. Default `"md"`. */
    size?: "sm" | "md" | "lg";
    /** Disable the whole control. */
    disabled?: boolean;
    /** Optional label rendered above. */
    label?: ReactNode;
    /** Optional formatter for the displayed value. */
    format?: (value: number) => string;
    /** Custom button labels for accessibility. */
    labels?: {
        decrement: string;
        increment: string;
    };
    className?: string;
}

export declare interface StepperProps {
    steps: StepItem[];
    /** Index of the currently active step (0-based). */
    current: number;
    orientation?: "horizontal" | "vertical";
    /**
     * Makes each step activatable. Without it the steps are a read-only
     * indicator, which is the right default — in a gated flow, jumping ahead
     * would skip the gates.
     */
    onStepClick?: (index: number) => void;
    className?: string;
}

/** Stop the clip currently playing on the shared default player. */
export declare function stopAudio(): void;

/**
 * Typed wrapper around `localStorage` that JSON-encodes values and silently
 * handles environments where storage is unavailable (SSR, private mode).
 *
 * `get`/`set` encode; `getRaw`/`setRaw` do not. Reach for the raw pair when the
 * key is shared with something that does not speak JSON — an existing key in an
 * app adopting this wrapper, a key another library owns, or the theme
 * preference the SDK's own `ThemeProvider` stores as a bare string.
 */
export declare const storage: JsonStorage;

/** How a {@link createJsonStorage} store turns values into text and back. */
export declare interface StorageCodec {
    /** Encode a value for storage. */
    serialize: <T>(value: T) => string;
    /** Decode a stored string. */
    deserialize: <T>(raw: string) => T;
}

/** Raw usage/quota reading from the Storage API, in bytes. */
declare interface StorageEstimate_2 {
    /** Bytes currently used by this origin, or `null` when unknown. */
    usage: number | null;
    /** Total bytes available to this origin, or `null` when unknown. */
    quota: number | null;
}
export { StorageEstimate_2 as StorageEstimate }

export { SubmitHandler }

/**
 * Turn a measured noise floor into a threshold worth using.
 *
 * Sits above the floor by a margin rather than on it, and is clamped at both
 * ends: a room measured as perfectly silent (or not measured at all) would
 * otherwise get a threshold of zero, which is a gate that never closes, and a
 * room measured while somebody talked would get one nothing opens.
 *
 * @param noiseFloor - Peak RMS measured while nobody spoke.
 * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.
 */
export declare function suggestGateThreshold(noiseFloor: number): number;

/** Toggle switch backed by a checkbox input. Accessible via keyboard. */
export declare const Switch: ForwardRefExoticComponent<SwitchProps & RefAttributes<HTMLInputElement>>;

export declare interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
    label?: ReactNode;
    wrapperClassName?: string;
}

/**
 * Coarse lifecycle phase of the sync engine, surfaced through
 * {@link OfflineSync.getState} / {@link OfflineSync.subscribe} for reactive UI.
 *
 * - `"idle"` — nothing in flight and the last run (if any) fully succeeded.
 * - `"syncing"` — a `flush` run is currently in progress.
 * - `"offline"` — the last run was skipped because the device was offline.
 * - `"error"` — the last run left at least one entry queued after a failure.
 */
export declare type SyncPhase = "idle" | "syncing" | "offline" | "error";

/** Outcome of a single {@link OfflineSync.flush} run. */
export declare interface SyncRunSummary {
    /** The trigger passed to `flush`. */
    trigger: SyncTrigger;
    /** Entries delivered to the server this run. */
    succeeded: number;
    /** Entries that failed and stay queued for the next run. */
    failed: number;
    /**
     * Entries left untried because an earlier entry for the **same record**
     * failed this run.
     *
     * They stay queued and are attempted next run, in order. Counted apart from
     * `failed` because they were never sent: reporting them as failures would
     * blame the server for a decision this engine made, and folding them in would
     * make `succeeded + failed` stop accounting for the queue.
     */
    deferred: number;
    /** Total wall-clock milliseconds the run took. */
    durationMs: number;
    /** `true` when the run was skipped because the device was offline. */
    skipped: boolean;
    /** Last delivery error message seen this run, or `null` when none failed. */
    lastError: string | null;
}

/**
 * Immutable snapshot of the engine's reactive state. A fresh object is emitted
 * to subscribers on every change, so it is safe to use as a
 * `useSyncExternalStore` snapshot (reference equality signals "no change").
 */
export declare interface SyncState {
    /** Current lifecycle phase. */
    phase: SyncPhase;
    /** Number of mutations still queued in the outbox. */
    pending: number;
    /** Summary of the most recent `flush` run, or `null` before the first. */
    lastSummary: SyncRunSummary | null;
    /** Message of the most recent delivery failure, or `null`. */
    lastError: string | null;
    /** Epoch ms of the last non-skipped run, or `null` before the first. */
    lastSyncedAt: number | null;
}

/**
 * Compact status snapshot for a status badge/pill. Prefer this over
 * {@link useOfflineSync} when a component only needs to *display* status and
 * does not trigger flushes itself.
 */
export declare interface SyncStatus {
    /** The dominant tone to render. */
    tone: SyncTone;
    /** Number of mutations still queued. */
    pending: number;
    /** `true` while a flush run is in progress. */
    syncing: boolean;
    /** `true` when the last run was skipped for being offline. */
    offline: boolean;
    /** Message of the most recent delivery failure, or `null`. */
    lastError: string | null;
}

/**
 * Compact pill showing offline-sync status: a tone-colored icon plus a label
 * and optional pending count.
 *
 * Two modes: pass `sync` to have the badge observe an engine via
 * `useSyncStatus` (zero wiring), or pass an explicit `tone` (+ `pending`) to
 * keep it presentational and testable without IndexedDB.
 *
 * @example
 * // Connected — auto-wires the engine:
 * <SyncStatusBadge sync={notesSync} />
 *
 * // Presentational — you own the state:
 * const { tone, pending } = useSyncStatus(notesSync);
 * <SyncStatusBadge tone={tone} pending={pending} />
 */
export declare function SyncStatusBadge({ sync, ...rest }: SyncStatusBadgeProps): JSX.Element;

export declare interface SyncStatusBadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
    /**
     * The dominant tone. Required when `sync` is not passed. Ignored when `sync`
     * is passed (the tone is derived from the engine).
     */
    tone?: SyncTone;
    /**
     * An `OfflineSync` engine to observe directly. When set, the badge wires
     * `useSyncStatus` internally, so `tone` and `pending` come from the engine.
     */
    sync?: OfflineSync<unknown>;
    /** Number of queued mutations, appended to the label when `> 0`. */
    pending?: number;
    /** Override the per-tone label text. */
    labels?: Partial<Record<SyncTone, string>>;
    /** Show the pending count next to the label. Default `true`. */
    showPending?: boolean;
    /** Render only the icon (no text). Default `false`. */
    iconOnly?: boolean;
}

/**
 * Presentation-ready tone for a sync status indicator. Collapses the engine's
 * {@link SyncState} into the single most relevant signal for a badge/pill.
 */
export declare type SyncTone = "idle" | "syncing" | "pending" | "offline" | "error";

/**
 * Why a sync run was triggered. The listed values are the common ones; any
 * string is accepted so apps can add their own telemetry labels.
 */
export declare type SyncTrigger = "boot" | "online-event" | "after-mutation" | "manual" | "interval" | (string & {});

export declare interface TabItem {
    id: string;
    label: ReactNode;
    content: ReactNode;
    disabled?: boolean;
}

/**
 * Lightweight table with declarative columns + mobile niceties.
 *
 * - `priority` per column lets less-important data hide on narrow viewports.
 * - `stackOnMobile` re-renders each row as a label/value card on mobile,
 *   avoiding horizontal scroll for dense data.
 */
export declare function Table<T>({ columns, data, rowKey, onRowClick, emptyMessage, className, stackOnMobile, scrollLabel, }: TableProps<T>): JSX.Element;

export declare type TableAlign = "left" | "right" | "center";

export declare interface TableColumn<T> {
    key: string;
    header: ReactNode;
    /** Render the cell content. Defaults to `row[key]` if not provided. */
    render?: (row: T, index: number) => ReactNode;
    align?: TableAlign;
    width?: string | number;
    className?: string;
    /**
     * Visibility priority: `always` (default) shows on every viewport,
     * `tablet` hides below md (< 768px), `desktop` hides below lg (< 1024px).
     */
    priority?: TablePriority;
}

export declare type TablePriority = "always" | "tablet" | "desktop";

export declare interface TableProps<T> {
    columns: TableColumn<T>[];
    data: T[];
    rowKey: (row: T, index: number) => string | number;
    onRowClick?: (row: T) => void;
    emptyMessage?: ReactNode;
    className?: string;
    /**
     * Stack mode — render rows as label/value cards on mobile (< md).
     * Better than horizontal scroll when each row has 3+ columns of dense data.
     */
    stackOnMobile?: boolean;
    /**
     * Accessible name for the scrollable region, used only while the table is
     * actually wider than its box. A focus stop that announces nothing is worse
     * than no focus stop, so name the table when the page holds several.
     */
    scrollLabel?: string;
}

/**
 * Accessible tabs with an underline (default) or pill variant. Controlled via
 * `activeId` + `onChange` or uncontrolled via `defaultId`.
 */
export declare function Tabs({ items, defaultId, activeId, onChange, variant, className, }: TabsProps): JSX.Element;

export declare interface TabsProps {
    items: TabItem[];
    /** Initial active tab id. Defaults to the first non-disabled item. */
    defaultId?: string;
    /** Controlled active id. When provided, ignore internal state. */
    activeId?: string;
    onChange?: (id: string) => void;
    variant?: "underline" | "pill";
    className?: string;
}

/**
 * Removable chip — used for filter tokens, applied search filters,
 * selected entities. Different from `Badge` (status-only, not removable).
 *
 * @example
 * <Tag variant="primary" onRemove={() => removeFilter("sao-paulo")}>
 *     São Paulo
 * </Tag>
 */
export declare function Tag({ variant, size, onRemove, removeLabel, className, children, ...props }: TagProps): JSX.Element;

export declare interface TagProps extends Omit<HTMLAttributes<HTMLSpanElement>, "onRemove"> {
    /** Visual variant. Default `"neutral"`. */
    variant?: TagVariant;
    /** Visual size. Default `"md"`. */
    size?: TagSize;
    /** When set, renders a close button that fires this callback. */
    onRemove?: () => void;
    /** Custom remove label for screen readers. Default `"Remover"`. */
    removeLabel?: string;
    children?: ReactNode;
}

export declare type TagSize = "sm" | "md" | "lg";

export declare type TagVariant = "neutral" | "primary" | "success" | "warning" | "danger" | "info";

/**
 * A value that changes whenever the tail of the thread grows.
 *
 * The scroll effect cannot depend on the `messages` array alone. Streaming appends
 * to the **last** turn, and an app that mutates that object in place — or that
 * re-renders from a store holding the same array identity — would keep the same
 * dependency while the text grows, so the view would stop following the answer.
 * Length of the array, identity of the tail and length of its text together cover
 * both shapes.
 *
 * @param messages - The thread, oldest first.
 * @returns An opaque signature; compare with `===`.
 */
export declare function tailSignature(messages: readonly AIChatMessage[]): string;

export declare interface TelemetryAdapter {
    /** Optional. Called when the provider mounts. */
    init?: () => void | Promise<void>;
    /** Associate the current session with a user. */
    identify: (user: TelemetryUser | null) => void;
    /** Track a discrete event. */
    track: (event: TelemetryEvent) => void;
    /** Report an error / exception with optional context. */
    captureException: (error: unknown, context?: Record<string, unknown>) => void;
    /** Flush queued events (e.g. before page unload). */
    flush?: () => Promise<void> | void;
}

export declare interface TelemetryEvent {
    name: string;
    properties?: Record<string, unknown>;
}

/**
 * Inject a telemetry adapter into the tree. Apps can swap implementations
 * (Sentry, Datadog, PostHog, console) without touching call sites.
 */
export declare function TelemetryProvider({ adapter, children }: TelemetryProviderProps): JSX.Element;

export declare interface TelemetryProviderProps {
    adapter: TelemetryAdapter;
    children: ReactNode;
}

export declare interface TelemetryUser {
    id?: string;
    email?: string;
    name?: string;
    /** Free-form trait bag (plan, role, region, etc.). */
    traits?: Record<string, unknown>;
}

/**
 * Error thrown by {@link createApiClient} / {@link uploadWithProgress} on a
 * non-2xx response. Mirrors the Tempest FastAPI SDK error envelope
 * (`{ detail, code, details.request_id }`) so callers get a typed `code` and a
 * `requestId` for log correlation, while still being a real `Error` (stack
 * trace, `instanceof Error`).
 *
 * @example
 * try {
 *     await api.post("/users", { body });
 * } catch (err) {
 *     if (isApiError(err) && err.code === "EMAIL_TAKEN") {
 *         showFieldError("email", err.detail);
 *     }
 * }
 */
export declare class TempestApiError extends Error implements ApiError {
    readonly status: number;
    readonly detail: string;
    readonly code?: string;
    readonly requestId?: string;
    readonly fields?: Record<string, string>;
    readonly body?: unknown;
    constructor(init: ApiError);
}

export declare interface TempestAuth<TUser, TCredentials> {
    /** The persisted Zustand auth store hook (compatible with `<AuthGuard>`). */
    useAuthStore: ReturnType<typeof createAuthStore<TUser>>;
    /** A `createApiClient` wired with bearer auth + 401 → refresh → retry. */
    api: ApiClient;
    /** Authenticate, store the session, and resolve the user (or null). */
    login: (credentials: TCredentials) => Promise<TUser | null>;
    /** Clear the session (and the stored refresh token). */
    logout: () => void;
    /** Refresh the access token (deduplicated across concurrent callers). */
    refresh: () => Promise<void>;
    /** The current access token, or null. */
    getToken: () => string | null;
}

/**
 * Inject a {@link DataProvider} into the React tree so the resource hooks
 * (`useList`, `useOne`, `useCreate`, …) can resolve it via {@link useDataProvider}.
 *
 * @example
 * const dataProvider = createDataProvider(apiClient);
 * <TempestDataProvider provider={dataProvider}>
 *     <App />
 * </TempestDataProvider>
 */
export declare function TempestDataProvider({ provider, children }: TempestDataProviderProps): JSX.Element;

/** Props for {@link TempestDataProvider}. */
export declare interface TempestDataProviderProps {
    /** The data provider to expose to descendant resource hooks. */
    provider: DataProvider;
    /** The subtree that consumes the provider. */
    children: ReactNode;
}

/**
 * A single declarative route node. Mirrors React Router's nested `<Route>`
 * model but adds first-class `lazy` (code-split with retry) and `guard`
 * (redirect when a predicate fails) so apps describe their route tree as data.
 */
export declare interface TempestRouteObject {
    /** URL segment, e.g. `"dashboard"` or `":id"`. Omit for an index route. */
    path?: string;
    /** Marks this as the index route of its parent. Mutually exclusive with `path`. */
    index?: boolean;
    /** Element rendered for this route. Ignored when `lazy` is provided. */
    element?: ReactNode;
    /**
     * Code-split component loader. Wrapped with `lazyWithRetry` and rendered
     * under the {@link AppRouter} `<Suspense>` boundary.
     */
    lazy?: () => Promise<{
        default: AnyRouteComponent;
    }>;
    /** Nested child routes (rendered through this route's `<Outlet />`). */
    children?: TempestRouteObject[];
    /**
     * Access guard. When `false` (or a function returning `false`), the route
     * renders a redirect to {@link redirectTo} instead of its element. When the
     * function returns `"pending"`, the decision is held and {@link guardFallback}
     * renders instead — see {@link RouteGuardResult}.
     *
     * The function runs inside the guard component's render, so it **may call
     * hooks** — which is what lets an async permission check like `useCan` plug
     * straight in. The usual rule applies: call the same hooks on every render
     * of that route. Guarded routes are keyed per route object, so navigating
     * between two routes whose guards call different hooks remounts rather than
     * breaking hook order.
     */
    guard?: boolean | (() => RouteGuardResult);
    /**
     * Rendered while {@link guard} answers `"pending"`. Defaults to the
     * {@link AppRouter} `fallback`, so a route tree that already passes a
     * spinner for `lazy` chunks reuses it here with no extra wiring.
     */
    guardFallback?: ReactNode;
    /** Destination used when `guard` fails (default: `"/"`). */
    redirectTo?: string;
    /** Match the path case-sensitively. */
    caseSensitive?: boolean;
}

/** The token envelope returned by a Tempest FastAPI SDK login/refresh route. */
export declare interface TempestTokenResponse {
    /** The bearer access token. */
    access_token: string;
    /** Token type — always `"bearer"` for the SDK. */
    token_type?: string;
    /** Optional refresh token (when the API returns it in the body, not a cookie). */
    refresh_token?: string;
}

/**
 * Multi-line text input. Mirrors the {@link Input} API for label/helper/error.
 */
export declare const Textarea: ForwardRefExoticComponent<TextareaProps & RefAttributes<HTMLTextAreaElement>>;

export declare interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
    label?: string;
    helperText?: string;
    error?: string;
    wrapperClassName?: string;
}

export declare interface ThemeContextValue {
    /** Raw user preference (light / dark / system). */
    theme: ThemeMode;
    /** Effective theme actually applied to the DOM (light or dark). */
    resolvedTheme: ResolvedTheme;
    /** Update the preference. Persisted to localStorage when `storageKey` is set. */
    setTheme: (next: ThemeMode) => void;
    /** Convenience: flip light ↔ dark. When in `system` mode, switches to the opposite of the current resolved theme. */
    toggle: () => void;
}

/**
 * Contrast ratio of `--tempest-primary-foreground` over the brand color.
 *
 * Exposed so an app (or a test) can assert its own brand clears WCAG AA (4.5) for
 * body text or AA-large (3.0) for button labels, instead of trusting the pick.
 *
 * @param options - The same input given to {@link createTheme}.
 * @returns The ratio, or `null` when no `primary` was provided.
 */
export declare function themeContrast(options: CreateThemeOptions): number | null;

/**
 * Plain HTML snippet that sets `data-tempest-theme` on `<html>` before React
 * hydrates. Inline this in `<head>` to avoid a flash of the wrong theme on
 * first paint.
 *
 * @example
 * <script dangerouslySetInnerHTML={{ __html: themeInitScript() }} />
 */
export declare function themeInitScript(options?: GetInitialThemeOptions): string;

export declare type ThemeMode = "light" | "dark" | "system";

/** Name of a bundled preset. */
export declare type ThemePresetName = "tempest" | "violet" | "emerald" | "rose" | "slate" | "amber";

/**
 * The bundled presets.
 *
 * `tempest` restates the SDK's own defaults — useful as a starting point to
 * tweak, and as the "reset to default" entry in a theme picker.
 */
export declare const themePresets: Record<ThemePresetName, CreateThemeOptions>;

/**
 * Wire dark/light theming. Writes a data attribute on a target element (the
 * `<html>` element by default) and exposes the current preference via
 * {@link useTheme}.
 *
 * Pair with `themeInitScript()` in the HTML head to prevent the flash of
 * incorrect theme on first paint.
 *
 * @tempest-limits empty-catch — the theme is applied to the DOM before it is
 * persisted, so a `localStorage` write refused by quota or private mode leaves the
 * user with the theme they just picked and only forfeits it on the next load.
 * Throwing from the setter would break the switch that already worked.
 */
export declare function ThemeProvider({ children, defaultTheme, storageKey, target, attribute, themeColor, }: ThemeProviderProps): JSX.Element;

export declare interface ThemeProviderProps {
    children: ReactNode;
    /** Initial preference when nothing is stored. Default: `"system"`. */
    defaultTheme?: ThemeMode;
    /** localStorage key used to persist the preference. Pass `null` to disable persistence. Default: `"tempest-theme"`. */
    storageKey?: string | null;
    /**
     * Element that receives the theme attribute(s). Defaults to
     * `document.documentElement`. Override when scoping the theme to a subtree.
     */
    target?: () => HTMLElement | null;
    /**
     * Attribute name(s) written on the target with the resolved theme
     * (`"light"` / `"dark"`). Default: `"data-tempest-theme"`.
     *
     * Pass an array to mirror the theme onto more than one attribute — handy
     * when the SDK components read `data-tempest-theme` but the host app's own
     * CSS keys off a different attribute (e.g. `["data-tempest-theme",
     * "data-theme"]`). Avoids a separate sync effect in the consumer.
     */
    attribute?: string | string[];
    /**
     * When set, keeps `<meta name="theme-color">` in sync with the resolved
     * theme — `content` becomes `themeColor.dark` in dark mode and
     * `themeColor.light` in light mode. The meta tag must already exist in the
     * document `<head>`. No-op when omitted.
     */
    themeColor?: {
        light: string;
        dark: string;
    };
}

/** Radius presets, applied to the whole `--tempest-radius-*` family at once. */
export declare type ThemeRadius = "none" | "sm" | "md" | "lg" | "xl" | "full";

/** Status token families that {@link createTheme} can regenerate. */
export declare type ThemeStatus = "success" | "warning" | "danger" | "info";

/**
 * Create a throttled version of `fn` with leading and trailing edges.
 *
 * `fn` runs immediately on the first call (leading edge), then at most once
 * per `wait` milliseconds. If calls happen during the wait window, the last
 * one fires on the trailing edge. Call `.cancel()` to drop any pending
 * trailing call and reset the window.
 *
 * @example
 * const onScroll = throttle(() => render(), 200);
 * window.addEventListener("scroll", onScroll);
 * onScroll.cancel();
 */
export declare function throttle<A extends unknown[]>(fn: (...args: A) => void, wait: number): ((...args: A) => void) & {
    cancel: () => void;
};

/**
 * Vertical event timeline — activity feeds, order trackers, audit logs.
 * Each entry has a marker (color or custom icon), title, optional
 * description and right-aligned meta column.
 *
 * @example
 * <Timeline items={[
 *     { id: "1", title: "Pedido criado", meta: "10:24", marker: "primary" },
 *     { id: "2", title: "Aprovação", meta: "10:25", marker: "success" },
 *     { id: "3", title: "Saiu pra entrega", meta: "11:00", marker: "warning" },
 * ]} />
 */
export declare function Timeline({ items, connector, className, ...props }: TimelineProps): JSX.Element;

export declare interface TimelineItem {
    /** Stable identifier (used as React key). */
    id: string;
    /** Title rendered as the entry headline. */
    title: ReactNode;
    /** Optional subtitle / description below the title. */
    description?: ReactNode;
    /** Right-aligned meta column (timestamps, durations). */
    meta?: ReactNode;
    /** Optional custom icon rendered inside the marker. */
    icon?: ReactNode;
    /** Marker color. Default `"primary"`. */
    marker?: TimelineMarker;
}

export declare type TimelineMarker = "primary" | "success" | "warning" | "danger" | "neutral";

export declare interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
    items: TimelineItem[];
    /** Show the connecting line between markers. Default `true`. */
    connector?: boolean;
}

/**
 * TimePicker — inline, dependency-free time picker with Material "spinner column" styling.
 *
 * Renders scrollable columns of selectable cells (hours, minutes, and AM/PM when
 * `use12Hours`). Always emits a 24h `"HH:MM"` string via `onChange`, regardless of
 * whether the 12h display is enabled.
 */
export declare function TimePicker({ value, onChange, minuteStep, use12Hours, label, helperText, disabled, className, }: TimePickerProps): JSX.Element;

export declare interface TimePickerProps {
    /** Selected time as a 24h `"HH:MM"` string (e.g. `"14:30"`). May be `""` for none. */
    value: string;
    /** Fired with the new 24h `"HH:MM"` string whenever a cell is picked. */
    onChange: (value: string) => void;
    /** Granularity of the minute column. Defaults to `5`. */
    minuteStep?: number;
    /** When true, show a 1–12 hour column plus an AM/PM column (still emits 24h). */
    use12Hours?: boolean;
    label?: string;
    helperText?: string;
    disabled?: boolean;
    className?: string;
}

export { To }

export declare interface ToastApi {
    show: (options: ToastOptions) => string;
    dismiss: (id: string) => void;
    success: (description: string, options?: Omit<ToastOptions, "variant" | "description">) => string;
    error: (description: string, options?: Omit<ToastOptions, "variant" | "description">) => string;
    warning: (description: string, options?: Omit<ToastOptions, "variant" | "description">) => string;
    info: (description: string, options?: Omit<ToastOptions, "variant" | "description">) => string;
}

export declare interface ToastOptions {
    id?: string;
    title?: string;
    description?: string;
    variant?: ToastVariant;
    /** Auto-dismiss timeout in ms. Pass `0` to keep the toast until dismissed manually. */
    duration?: number;
}

export declare type ToastPosition = "top-right" | "top-left" | "top-center" | "bottom-right" | "bottom-left" | "bottom-center";

/**
 * Renders a portalled toast container and exposes the imperative {@link useToast} API.
 */
export declare function ToastProvider({ children, defaultDuration, position, }: ToastProviderProps): JSX.Element;

export declare interface ToastProviderProps {
    children: ReactNode;
    /** Default auto-dismiss duration (ms). Default 4000. */
    defaultDuration?: number;
    /** Stack position on screen. Default `"top-right"`. */
    position?: ToastPosition;
}

export declare type ToastVariant = "success" | "warning" | "error" | "info";

/**
 * Serialize rows to CSV text, RFC 4180 style.
 *
 * Rows are separated by `\r\n` — the RFC's terminator and the one Excel is least
 * surprised by. A row is emitted for the header even when `rows` is empty, so the
 * person who opens the file sees which columns they asked for instead of a blank
 * document.
 *
 * @example
 * const csv = toCsv(users, [
 *     { key: "name", header: "Nome" },
 *     { key: "email", header: "E-mail" },
 *     { key: "plan", header: "Plano", csv: (user) => user.plan.label },
 * ]);
 *
 * @param rows - The rows to export.
 * @param columns - Columns, in the order they should appear.
 * @param options - Delimiter and BOM.
 * @returns The complete file contents.
 */
export declare function toCsv<T>(rows: readonly T[], columns: readonly CsvColumn<T>[], options?: CsvOptions): string;

/**
 * A pressable two-state button — like a checkbox styled as a button.
 *
 * Works controlled (pass `pressed` + `onPressedChange`) or uncontrolled
 * (pass `defaultPressed`). Renders a native `<button type="button">` exposing
 * its state through `aria-pressed`.
 *
 * @param props - {@link ToggleProps}.
 * @returns The toggle button element.
 */
export declare const Toggle: ForwardRefExoticComponent<ToggleProps & RefAttributes<HTMLButtonElement>>;

/**
 * A set of {@link ToggleGroupItem}s that share selection state via context.
 *
 * In `single` mode the value is a `string` (empty string when nothing is
 * selected); in `multiple` mode it is a `string[]`. Works controlled (pass
 * `value` + `onValueChange`) or uncontrolled (pass `defaultValue`).
 *
 * @param props - {@link ToggleGroupProps}.
 * @returns A `role="group"` container wrapping the items.
 */
export declare function ToggleGroup({ type, value, defaultValue, onValueChange, className, children, ...props }: ToggleGroupProps): JSX.Element;

/**
 * A single selectable item inside a {@link ToggleGroup}. Reads and updates the
 * group's shared state through context.
 *
 * Icon-only items need an explicit `aria-label` (forwarded to the button):
 * an SVG child gives screen readers nothing to announce.
 *
 * @param props - {@link ToggleGroupItemProps}.
 * @returns A `role="button"` element exposing its state via `aria-pressed`.
 */
export declare function ToggleGroupItem({ value, disabled, className, children, ...props }: ToggleGroupItemProps): JSX.Element;

export declare interface ToggleGroupItemProps extends Omit<HTMLAttributes<HTMLButtonElement>, "onClick"> {
    /** Stable value identifying this item within the group. */
    value: string;
    /** Disables the item. */
    disabled?: boolean;
    children: ReactNode;
}

export declare interface ToggleGroupProps extends HTMLAttributes<HTMLDivElement> {
    /** Selection mode. `"single"` keeps one value; `"multiple"` keeps a set. Default `"single"`. */
    type?: ToggleGroupType;
    /** Controlled value — `string` for `single`, `string[]` for `multiple`. */
    value?: string | string[];
    /** Uncontrolled initial value. */
    defaultValue?: string | string[];
    /** Fired with the next value whenever the selection changes. */
    onValueChange?: (value: string | string[]) => void;
    children: ReactNode;
}

export declare type ToggleGroupType = "single" | "multiple";

export declare interface ToggleHelpers {
    toggle: () => void;
    setTrue: () => void;
    setFalse: () => void;
    set: (next: boolean) => void;
}

export declare interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onChange"> {
    /** Controlled pressed state. When provided the component is controlled. */
    pressed?: boolean;
    /** Initial pressed state for the uncontrolled variant. Default `false`. */
    defaultPressed?: boolean;
    /** Fired with the next pressed state whenever the toggle is activated. */
    onPressedChange?: (pressed: boolean) => void;
    /** Visual size. Default `"md"`. */
    size?: ToggleSize;
    /** Visual style. Default `"default"`. */
    variant?: ToggleVariant;
}

export declare type ToggleSize = "sm" | "md" | "lg";

export declare type ToggleVariant = "default" | "outline";

export declare interface Token {
    kind: TokenKind;
    value: string;
}

/** What a token is painted as. */
export declare type TokenKind = "plain" | "comment" | "string" | "number" | "keyword" | "literal" | "function" | "punctuation" | "tag" | "attribute" | "property";

/**
 * Lightweight tooltip. Shows on hover and on focus (keyboard-friendly). Wraps
 * a single child element via `cloneElement`, so the trigger keeps its own ref
 * and props.
 */
export declare function Tooltip({ content, placement, children, disabled, openDelay, }: TooltipProps): JSX.Element;

export declare type TooltipPlacement = "top" | "bottom" | "left" | "right";

export declare interface TooltipProps {
    /** Tooltip content. Plain text recommended; rich content also works. */
    content: ReactNode;
    /** Placement relative to the trigger. Default: `"top"`. */
    placement?: TooltipPlacement;
    /** Single React element to attach hover/focus listeners to. */
    children: ReactElement;
    /** Disable the tooltip without changing the trigger. */
    disabled?: boolean;
    /** Delay (ms) before showing the tooltip. Default: 150. */
    openDelay?: number;
}

/** Convert degrees to radians. */
export declare function toRadians(degrees: number): number;

/**
 * A guided tour: dim the page, highlight one element at a time, explain it.
 *
 * The highlighted element stays **clickable** while everything else is blocked,
 * because the useful kind of coachmark says "press this" and lets you press it. That
 * is why the backdrop is four rectangles around the target rather than one overlay
 * with a `box-shadow` hole — a shadow is not hit-testable, so a hole made that way
 * would not block anything.
 *
 * Whether a user has seen the tour is the app's business: this component takes
 * `open` and emits `onClose`/`onFinish`. Persisting a flag in `localStorage` is one
 * line in the app and a wrong default here.
 *
 * @example
 * const [open, setOpen] = useState(!storage.get("tour-v1"));
 *
 * <Tour
 *     open={open}
 *     steps={[
 *         { target: "#novo-pedido", title: "Comece aqui", body: "Todo pedido nasce deste botão." },
 *         { target: "[data-tour='filtros']", body: "E filtre por período aqui." },
 *     ]}
 *     onClose={() => setOpen(false)}
 *     onFinish={() => storage.set("tour-v1", true)}
 * />
 */
export declare function Tour({ steps, open, onClose, onFinish, index, onIndexChange, locale, spotlightPadding, className, }: TourProps): JSX.Element | null;

/** Where the card sits relative to the highlighted element. */
export declare type TourPlacement = "top" | "bottom" | "left" | "right" | "center";

export declare interface TourProps {
    /** The stops, in order. */
    steps: readonly TourStep[];
    /** Whether the tour is showing. Controlled. */
    open: boolean;
    /** Closed by `Esc`, by the close button or by "skip". */
    onClose: () => void;
    /** Called after the last step is confirmed. `onClose` follows it. */
    onFinish?: () => void;
    /** Current step index, when the app wants to drive it. */
    index?: number;
    /** Step changed — required only when `index` is given. */
    onIndexChange?: (index: number) => void;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Space kept clear around the highlighted element, in px. Default 4. */
    spotlightPadding?: number;
    /** Extra class on the card. */
    className?: string;
}

/** One stop of the tour. */
export declare interface TourStep {
    /**
     * CSS selector of the element to point at.
     *
     * A selector rather than a ref, so a tour can be declared as data — in a config
     * file, from the backend, next to the copy — without every screen having to
     * thread refs up to whoever renders the tour.
     */
    target?: string;
    /** Heading of the card. */
    title?: ReactNode;
    /** The explanation. */
    body: ReactNode;
    /** Preferred side. Default `"bottom"`, flipped when it does not fit. */
    placement?: TourPlacement;
}

/** Lifecycle status of a {@link PositionTracker}. */
export declare type TrackerStatus = "idle" | "tracking" | "error";

/**
 * A single sample in a recorded trajectory: a {@link Coordinate} stamped with
 * the epoch millisecond it was captured, plus the optional accuracy radius
 * reported by the Geolocation API.
 */
export declare interface TrackPoint extends Coordinate {
    /** Capture time in epoch milliseconds (`GeolocationPosition.timestamp`). */
    timestamp: number;
    /** Horizontal accuracy radius in meters, if the device reported one. */
    accuracy?: number;
}

/**
 * Plot a GPS trajectory. By default it renders a **tile-free SVG** map (Web
 * Mercator projection, auto-fit to the points, optional grid + scale bar) —
 * 100% self-contained, no external tiles or paid API. Pass `tileUrl` pointing
 * at a map server **you host** to upgrade to a real Leaflet tile layer.
 *
 * @example
 * // Zero-dependency SVG plot
 * <TrajectoryMap points={points} current={lastPoint} height={360} />
 *
 * @example
 * // Real tiles from your own server (requires `leaflet` installed)
 * <TrajectoryMap points={points} tileUrl="https://tiles.internal/{z}/{x}/{y}.png" />
 */
export declare function TrajectoryMap({ points, current, height, padding, showGrid, showScale, strokeColor, tileUrl, tileAttribution, label, markers, onMarkerClick, className, style, ...rest }: TrajectoryMapProps): JSX.Element;

export declare interface TrajectoryMapProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Ordered coordinates forming the trajectory. */
    points: readonly Coordinate[];
    /** Optional "current position" marker, drawn on top of the path. */
    current?: Coordinate | null;
    /** Viewport height in pixels. Default: `320`. */
    height?: number;
    /** Inner padding in pixels kept clear on every edge. Default: `24`. */
    padding?: number;
    /** Draw a light reference grid behind the path (SVG mode). Default: `true`. */
    showGrid?: boolean;
    /** Draw a distance scale bar (SVG mode). Default: `true`. */
    showScale?: boolean;
    /** Path stroke color. Default: the primary token. */
    strokeColor?: string;
    /**
     * Tile URL template (`{z}/{x}/{y}`) of a map server **you host**. When set,
     * the map upgrades to a real Leaflet tile layer (requires `leaflet` to be
     * installed). Omit for the zero-dependency, zero-network SVG plot.
     */
    tileUrl?: string;
    /** Attribution text shown over the tile layer. */
    tileAttribution?: string;
    /** Accessible label for the map region. Default: `"Trajetória"`. */
    label?: string;
    /** Point markers to overlay (e.g. stops, POIs). Included in the auto-fit. */
    markers?: readonly GeoMarker[];
    /** Fired when a marker is clicked. */
    onMarkerClick?: (marker: GeoMarker, index: number) => void;
}

/**
 * Two panes and a set of move controls: pick a subset out of a catalogue.
 *
 * Controlled on **ids of the target side only**. The panes are derived on every
 * render, never stored, because two stored lists drift the moment the catalogue
 * changes under them — a permission removed upstream lingers in whichever pane
 * held it, and an id in both panes is a bug nobody can see.
 *
 * @example
 * const [roles, setRoles] = useState<string[]>([]);
 *
 * <Transfer
 *     items={allRoles}
 *     value={roles}
 *     onChange={setRoles}
 *     sourceTitle="Papéis disponíveis"
 *     targetTitle="Papéis do usuário"
 * />
 */
export declare function Transfer({ items, value, onChange, sourceTitle, targetTitle, searchable, renderItem, locale, height, disabled, className, ...rest }: TransferProps): JSX.Element;

/** One movable entry. */
export declare interface TransferItem {
    /** Stable identity. What `value`/`onChange` carry. */
    id: string;
    /** What the row shows. */
    label: ReactNode;
    /** Text the search box matches against. Falls back to `label` when it is a string. */
    searchText?: string;
    /** Row that cannot move — a mandatory permission, a locked seat. */
    disabled?: boolean;
    /** Anything the app wants back in `renderItem`. */
    data?: Record<string, unknown>;
}

export declare interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_10> {
    /** The whole catalogue. Both panes are derived from it. */
    items: readonly TransferItem[];
    /** Ids on the target side. Controlled. */
    value: readonly string[];
    /** Next value, always in catalogue order. */
    onChange: (value: string[]) => void;
    /** Heading of the left pane. Default `"Disponíveis"`. */
    sourceTitle?: ReactNode;
    /** Heading of the right pane. Default `"Selecionados"`. */
    targetTitle?: ReactNode;
    /** Show a search box above each pane. Default `true` past 8 items. */
    searchable?: boolean;
    /** Custom row body. Gets the item and which side it is on. */
    renderItem?: (item: TransferItem, side: TransferSide) => ReactNode;
    /** Locale for labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Height of each pane's scroll area, any CSS length. Default `"16rem"`. */
    height?: string;
    /** Block every move. */
    disabled?: boolean;
}

/** Which pane an operation is about. */
export declare type TransferSide = "source" | "target";

/** Per-call options for {@link I18n.t} and {@link I18n.plural}. */
export declare interface TranslateOptions {
    /**
     * Text to use when the catalog defines neither the key nor its fallback.
     *
     * Without this, a miss returns the key, and a caller that wants its own text
     * instead has to *detect* the miss — which from the outside means comparing
     * the result against the key it just passed in. That heuristic is wrong for a
     * catalog that legitimately maps a key to itself, and it is what every
     * translatable string the SDK ships would otherwise have to copy.
     *
     * Interpolated like any other message, so a default carries `{placeholders}`
     * too and is not second-class.
     */
    default?: string;
}

/**
 * Estimated travel between two coordinates. Mirrors the `TravelEstimate`
 * schema from `tempest-fastapi-sdk` (`geo/schemas.py`), snake_case preserved so
 * a response deserializes straight into this type.
 */
export declare interface TravelEstimate {
    /** Travel mode the estimate was computed for. */
    mode: TravelMode;
    /** Great-circle distance scaled by circuity, in kilometers (`>= 0`). */
    distance_km: number;
    /** Estimated duration in minutes (`>= 0`). */
    duration_minutes: number;
    /** How the estimate was produced. `"heuristic"` (offline) or `"osrm"`. */
    source: "heuristic" | "osrm";
}

/**
 * Travel mode. Mirrors the `TravelMode` string enum from `tempest-fastapi-sdk`
 * (`geo/enums.py`) — the on-the-wire value is the raw string.
 */
export declare type TravelMode = "car" | "motorcycle" | "bus";

/** One node of the tree. Children make it a branch; no children makes it a leaf. */
export declare interface TreeNode {
    /** Stable identifier, unique across the whole tree. */
    id: string;
    /** Rendered label. */
    label: ReactNode;
    /** Child nodes. An empty array still renders as a branch (an empty folder). */
    children?: TreeNode[];
    /** Icon rendered before the label. */
    icon?: ReactNode;
    /** Blocks selection and expansion, and skips the node in keyboard navigation. */
    disabled?: boolean;
}

/**
 * Accessible tree for hierarchical data — categories, permissions, folders, an
 * org chart.
 *
 * Implements the `tree` role with **roving tabindex**: exactly one row is
 * tabbable, and the arrow keys move focus within the widget. That is what keeps a
 * 500-node tree from adding 500 stops to the page's tab order.
 *
 * Keyboard map: `↓`/`↑` move, `→` expands (or descends), `←` collapses (or goes to
 * the parent), `Home`/`End` jump to the first/last visible row, `Enter`/`Space`
 * select.
 *
 * The chevron is decoration (`aria-hidden`), not a button: the row itself carries
 * `aria-expanded`, so a second focusable control there would only add noise for a
 * screen reader while duplicating an action the keyboard map already has. It still
 * accepts a click, with the event stopped so it toggles without also selecting.
 *
 * @example
 * ```tsx
 * const nodes: TreeNode[] = [
 *   {
 *     id: "vendas",
 *     label: "Vendas",
 *     children: [
 *       { id: "vendas.ler", label: "Ler" },
 *       { id: "vendas.editar", label: "Editar" },
 *     ],
 *   },
 *   { id: "config", label: "Configurações", children: [] },
 * ];
 *
 * <TreeView nodes={nodes} defaultExpandedIds={["vendas"]} onSelect={(node) => console.log(node.id)} />
 * ```
 */
export declare function TreeView({ nodes, expandedIds, defaultExpandedIds, onExpandedChange, selectedId, defaultSelectedId, onSelect, toggleOnSelect, label, className, }: TreeViewProps): JSX.Element;

export declare interface TreeViewProps {
    /** Root nodes. */
    nodes: TreeNode[];
    /** Controlled expanded ids. */
    expandedIds?: string[];
    /** Uncontrolled initial expanded ids. */
    defaultExpandedIds?: string[];
    onExpandedChange?: (expandedIds: string[]) => void;
    /** Controlled selected id. `null` means nothing selected. */
    selectedId?: string | null;
    /** Uncontrolled initial selection. */
    defaultSelectedId?: string | null;
    onSelect?: (node: TreeNode) => void;
    /**
     * Selecting a branch also toggles it. Default `true` — matches how a file
     * explorer behaves; set `false` when a branch is itself a meaningful choice
     * (a category that owns items, for instance).
     */
    toggleOnSelect?: boolean;
    /** Accessible name for the tree. */
    label?: string;
    className?: string;
}

/**
 * Truncate a string to `max` characters, appending `suffix` when cut.
 * Returns the original when shorter than (or equal to) `max`.
 *
 * @example
 * truncate("The quick brown fox", 12);              // "The quick…"
 * truncate("The quick brown fox", 12, " (more)");   // "The qu (more)"
 */
export declare function truncate(input: string, max: number, suffix?: string): string;

/**
 * Clamp text to a fixed number of lines using a CSS line-clamp, adding an
 * ellipsis on overflow. The line count is driven by the
 * `--tempest-clamp-lines` custom property.
 *
 * @example
 * <TruncateText lines={2}>{longDescription}</TruncateText>
 */
export declare function TruncateText({ lines, className, style, children, ...props }: TruncateTextProps): JSX.Element;

export declare interface TruncateTextProps extends HTMLAttributes<HTMLDivElement> {
    /** Maximum number of lines to show before clamping. Defaults to 1. */
    lines?: number;
    /** Content to clamp. */
    children: ReactNode;
}

/** Which description a peer connection actually accepted. */
export declare type TunedDescriptionResult = "tuned" | "original";

/**
 * Apply Opus profiles to the audio m-lines of a session description.
 *
 * Audio over WebRTC is mono and narrow by default, and the only place that is
 * corrected is the SDP — which is why shared-screen audio famously sounds like a
 * telephone: music and video inherit the speech profile (mono, ~32 kbps, FEC on,
 * DTX gating the quiet passages) and no high-level API lets you change it.
 *
 * Deliberately **without** built-in presets: which values to use is the
 * consumer's call — voice in a mesh does not want what system audio wants — and
 * a preset table is the kind of thing that has no business inside a dependency.
 * What lives here is the parsing, merging and insertion, which is where the long
 * tail is. Getting any of it wrong degrades silently: nobody sees an exception,
 * the audio is just worse.
 *
 * @param sdp - The description from `createOffer` or `createAnswer`.
 * @param profiles - One {@link OpusProfile} for every audio m-line, or an
 *   {@link OpusProfileMap} keyed by audio m-line index or by `mid`.
 * @returns The rewritten SDP, with CRLF line endings as RFC 4566 requires.
 *   Untouched when there is no Opus, when no profile matches, or when a profile
 *   asks for nothing.
 *
 * @example
 * const tuned = tuneOpus(offer.sdp, {
 *   0: { maxAverageBitrate: 48_000, stereo: false, fec: true, dtx: true },
 *   1: { maxAverageBitrate: 192_000, stereo: true, fec: false, dtx: false },
 * });
 *
 * @example
 * const tuned = tuneOpus(offer.sdp, { stereo: true, dtx: false });
 */
export declare function tuneOpus(sdp: string, profiles: OpusProfile | OpusProfileMap): string;

/**
 * Clock label for a turn — the time, not a relative phrase.
 *
 * A transcript is read top to bottom in one sitting, so "há 2 minutos" on every turn
 * is noise that also has to be re-rendered on a timer. The wall clock is stable and
 * enough to answer the only question anyone asks of it ("was this today?").
 */
export declare function turnTime(timestamp: number, locale?: "pt-BR" | "en"): string;

/**
 * Remove duplicate items, keeping the first occurrence of each distinct key.
 *
 * Equality is determined by the value returned from `key` (compared with `===`).
 *
 * @example
 * uniqueBy([1, 2, 2, 3, 1], (n) => n); // [1, 2, 3]
 *
 * @example
 * uniqueBy(
 *   [{ id: 1, v: "a" }, { id: 1, v: "b" }, { id: 2, v: "c" }],
 *   (u) => u.id,
 * );
 * // [{ id: 1, v: "a" }, { id: 2, v: "c" }]
 */
export declare function uniqueBy<T>(items: T[], key: (item: T) => unknown): T[];

/** Strip any masking and return only digits. */
export declare function unmask(value: string): string;

/**
 * Inverse of {@link projectMercator}: recover a coordinate from a unit-plane
 * point.
 *
 * @param point - `{ x, y }` in `[0, 1]`.
 * @returns The geographic coordinate.
 */
export declare function unprojectMercator(point: MercatorPoint): Coordinate;

/**
 * Unregister all registered service workers for this origin.
 *
 * @returns Number of workers that were unregistered.
 */
export declare function unregisterAllServiceWorkers(): Promise<number>;

/**
 * Fixed toast prompting the user to activate a freshly installed service
 * worker. Presentational — pair with {@link useServiceWorkerUpdate}, feeding
 * `updateAvailable` to `open` and `applyUpdate` to `onUpdate`.
 *
 * Renders nothing while `open` is `false`.
 *
 * @example
 * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: "/sw.js" });
 * <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />
 */
export declare function UpdatePrompt({ open, onUpdate, onDismiss, message, actionLabel, position, className, ...props }: UpdatePromptProps): JSX.Element | null;

export declare type UpdatePromptPosition = "top" | "bottom";

export declare interface UpdatePromptProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Whether the prompt is visible. Feed from `useServiceWorkerUpdate().updateAvailable`. */
    open: boolean;
    /** Called when the user confirms the update. Wire to `applyUpdate`. */
    onUpdate: () => void;
    /** Called when the user dismisses the prompt. Omit to hide the dismiss button. */
    onDismiss?: () => void;
    /** Body message. */
    message?: ReactNode;
    /** Confirm button label. Default `"Atualizar"`. */
    actionLabel?: string;
    /** Where to pin the fixed toast. Default `"bottom"`. */
    position?: UpdatePromptPosition;
}

/** Variables accepted by the update mutation. */
export declare interface UpdateVariables {
    /** The record id to update. */
    id: string | number;
    /** The update payload. */
    data: unknown;
}

/**
 * A stable-enough identity for a file, used as the default resume key.
 *
 * Name + size + last-modified is what the tus reference clients fingerprint on:
 * it is cheap (hashing the bytes of a 400 MB recording is not) and it changes
 * whenever the file does, which is the property that matters — resuming into the
 * wrong file would corrupt it silently.
 *
 * @param endpoint - Creation endpoint, so the same file to two servers is two uploads.
 * @param file - The blob or file being uploaded.
 * @returns A key safe to use in `localStorage`.
 */
export declare function uploadFingerprint(endpoint: string, file: Blob | File): string;

export declare interface UploadProgressEvent {
    /** Bytes already uploaded. */
    loaded: number;
    /** Total payload size in bytes — only meaningful when `lengthComputable` is true. */
    total: number;
    /** Fraction between 0 and 1, or null when total is unknown. */
    fraction: number | null;
    lengthComputable: boolean;
}

/**
 * Upload a file (or any payload) with byte-level progress reporting.
 *
 * `fetch` cannot report upload progress in browsers, so this helper falls
 * back to `XMLHttpRequest`. It mirrors the error contract used by
 * {@link createApiClient}: non-2xx responses reject with a `TempestApiError`.
 *
 * @returns The parsed JSON response, or the raw text when the response is not JSON.
 */
export declare function uploadWithProgress<T = unknown>(options: UploadWithProgressOptions): Promise<T>;

export declare interface UploadWithProgressOptions {
    url: string;
    body: FormData | Blob | File;
    method?: "POST" | "PUT" | "PATCH";
    headers?: Record<string, string>;
    /** Returns the current bearer token. */
    getToken?: () => string | null | undefined;
    /**
     * Origin the `getToken` credential belongs to, normally the API's.
     *
     * Unlike `createApiClient`, this helper has no base URL to infer a scope
     * from — the caller names the destination on every call. Set this when the
     * `url` can come from somewhere other than your own code (a signed URL the
     * API handed back, a value from a response body) and the token must not
     * follow it off-origin. Left unset, the header goes wherever `url` points,
     * which is the behaviour every version before 0.66.0 had.
     */
    credentialOrigin?: string;
    /**
     * Extra origins allowed to receive the credential, on top of
     * {@link credentialOrigin}. Ignored when that one is unset.
     */
    trustedOrigins?: readonly string[];
    /** Send cookies. Defaults to false. */
    withCredentials?: boolean;
    /** Called on every `progress` event from the XHR upload channel. */
    onProgress?: (event: UploadProgressEvent) => void;
    /** Abort the request. */
    signal?: AbortSignal;
    /** Override the JSON parser. Defaults to `JSON.parse`. */
    parser?: (raw: string) => unknown;
    /**
     * Per-request correlation id sent as `X-Request-ID` (Tempest convention).
     * Defaults to a generated id. Return an empty string to disable.
     */
    requestId?: () => string;
}

/**
 * Ready-made `applyOptimistic` builders for {@link useOfflineMutation} over a
 * list-shaped query cache (`TData = T[]`). They cover the two most common
 * optimistic edits — insert-or-update and remove — so callers stop hand-writing
 * the array spread. Both compare records by an id field (`"id"` by default) and
 * treat the mutation variables as the record itself.
 */
/**
 * Build an `applyOptimistic` that inserts the item when absent or shallow-merges
 * it into the existing entry (matched by `idField`). New items append to the end.
 *
 * @typeParam T - The list item shape.
 * @param idField - The identity field. Default `"id"`.
 * @returns An `(current, item) => T[]` patcher for a list cache.
 *
 * @example
 * useOfflineMutation<Note, Note[], Note>({
 *     sync, queryKey: ["notes"],
 *     toEntry: (n) => ({ op: "update", recordId: n.id, payload: n }),
 *     applyOptimistic: upsertById(),
 * });
 */
export declare function upsertById<T>(idField?: keyof T): (current: T[] | undefined, item: T) => T[];

/**
 * Convert a base64url-encoded VAPID public key into the `Uint8Array` format
 * required by `PushManager.subscribe({ applicationServerKey })`.
 *
 * Calls `atob` as a bare global rather than `window.atob` because this runs in a
 * **service worker** too: re-subscribing from a `pushsubscriptionchange` handler
 * needs the same conversion, and there is no `window` in a worker scope — the
 * qualified call threw `ReferenceError` there while working fine on the page.
 *
 * @param base64String - VAPID public key (URL-safe base64).
 * @returns The decoded key as bytes.
 */
export declare function urlBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;

/**
 * Read the current {@link AccessControl} from context.
 *
 * Returns `null` when no {@link AccessControlProvider} is present. Callers MUST
 * treat the absence of a provider as **"allow all"** — i.e. when this returns
 * `null`, access checks should default to permitted. This keeps the SDK
 * opt-in: dropping in a provider adds enforcement, removing it disables it.
 */
export declare function useAccessControl(): AccessControl | null;

/**
 * Announce transient messages to screen readers through one shared live region
 * pair.
 *
 * Reach for this when something happened that a sighted user can see and a screen
 * reader user cannot: a filter narrowed a list, a row saved, a copy succeeded, an
 * upload failed. It is **not** for content that is already on screen inside a
 * region with a role — a status pill, a toast that renders as `role="status"`,
 * a form error tied to its input — announcing those again reads them twice.
 *
 * !!! warning "Never wrap streaming text in a live region"
 *     A live region over text that grows token by token makes the reader start the
 *     whole answer again on every token. Announce the **edges** instead — "gerando
 *     resposta" and "resposta concluída" — and leave the transcript in a plain
 *     `role="log"` the user reads at their own pace. `AIChat` does exactly that.
 *
 * Mounting the hook creates the regions even before the first message. That is not
 * tidiness: a live region inserted into the DOM in the same frame as its first
 * content routinely loses that announcement, because the assistive technology has
 * to have registered the region before it can notice a change inside it.
 *
 * @returns A stable `announce(message, politeness?)` function.
 *
 * @example
 * const announce = useAnnounce();
 *
 * function onFilter(rows: Row[]) {
 *     announce(`${rows.length} resultados`);
 * }
 */
export declare function useAnnounce(): (message: string, politeness?: AnnouncePoliteness) => void;

/**
 * Run an async function and track its `idle/pending/success/error` state.
 *
 * - Discards results from stale runs (race-condition safe).
 * - `immediate` (default `false`) triggers the function on mount and when
 *   `deps` change. With `false`, call `run()` manually.
 * - Returns a stable object so callers can destructure or pass around safely.
 *
 * For server data with caching, prefer React Query — `useAsync` is the
 * minimal one-shot primitive without dependencies.
 */
export declare function useAsync<T>(asyncFn: () => Promise<T>, deps?: ReadonlyArray<unknown>, options?: {
    immediate?: boolean;
}): UseAsyncResult<T>;

export declare interface UseAsyncResult<T> {
    status: AsyncStatus;
    data: T | undefined;
    error: unknown;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    /** Trigger the async function. Resolves with the new data or rejects. */
    run: () => Promise<T>;
    /** Reset state back to idle. */
    reset: () => void;
}

/**
 * The player lives in a state initializer, not in a lazily-written ref: the
 * initializer runs exactly once and is not a side effect during render, which is
 * what the ref version was. The player identity never changes, so state holds it
 * fine and the value is non-null from the first render.
 *
 * Hook-managed audio player. Each component instance gets its own
 * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for
 * notification chimes, UI feedback sounds, and per-component soundtracks.
 */
export declare function useAudio(): UseAudioResult;

/**
 * Keep one {@link AudioBus} alive for as long as the component is mounted.
 *
 * The bus is built on the first render and closed on unmount, which matters more
 * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows
 * around six), so a bus leaked on unmount eventually breaks every later one on
 * the page.
 *
 * Options are read once. A bus is a device route and a mixing graph, not a
 * render output — rebuilding it because a prop changed would drop every attached
 * source mid-sentence. Change gain and output through the bus itself.
 *
 * @param options - See {@link AudioBusOptions}. Read on the first render only.
 * @returns The bus, stable for the component's lifetime.
 *
 * @example
 * const bus = useAudioBus({ maxGain: 3 });
 *
 * useEffect(() => {
 *   const handle = bus.attach(stream, { gain: 1 });
 *   return () => handle.stop();
 * }, [bus, stream]);
 */
export declare function useAudioBus(options?: AudioBusOptions): AudioBus;

/**
 * Record the given stream, with a clock, a level meter and a state machine.
 *
 * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until
 * there is one, so a page can render the whole recorder UI before permission is
 * granted and simply have it disabled.
 *
 * The clock and the level are published on an interval (`tickMs`, default 100 ms)
 * rather than per animation frame. A hook that set state 60 times a second would
 * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and
 * a meter, and the underlying `createLevelMeter` is still available for anyone who
 * wants a frame-accurate bar written straight to the DOM.
 *
 * @param stream - The stream to record, or `null` while permission is pending.
 * @param options - See {@link UseAudioRecorderOptions}.
 *
 * @example
 * const mic = useMicrophone();
 * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });
 * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>
 */
export declare function useAudioRecorder(stream: MediaStream | null, options?: UseAudioRecorderOptions): UseAudioRecorderResult;

/** Options for {@link useAudioRecorder}. */
export declare interface UseAudioRecorderOptions extends AudioRecorderOptions {
    /**
     * Stop automatically after this many milliseconds.
     *
     * Worth setting on anything user-facing: a recording left running by accident is
     * a memory buffer that grows until the tab dies.
     */
    maxDurationMs?: number;
    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */
    onRecorded?: (recording: AudioRecording) => void;
    /** How often the clock and the level are published, in ms. Default 100. */
    tickMs?: number;
    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */
    disableLevelMeter?: boolean;
}

/** Value returned by {@link useAudioRecorder}. */
export declare interface UseAudioRecorderResult {
    status: AudioRecorderStatus;
    /** Recorded length so far, excluding paused time. */
    durationMs: number;
    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */
    level: number;
    /** The finished recording, or `null` before the first `stop()`. */
    recording: AudioRecording | null;
    /** Recorder-level error (encoder failure, device pulled mid-recording). */
    error: unknown;
    /** `false` when there is no stream yet, or the browser cannot record. */
    ready: boolean;
    start: () => void;
    pause: () => void;
    resume: () => void;
    /** Stop and resolve with the recording. Also published on `recording`. */
    stop: () => Promise<AudioRecording | null>;
    /** Stop and throw the audio away. */
    cancel: () => void;
}

export declare interface UseAudioResult {
    /** Play `src` on the hook's private player. */
    play: (src: string, options?: PlayAudioOptions) => Promise<void>;
    /** Stop the current clip. */
    stop: () => void;
    /**
     * Whether the browser's autoplay policy has been satisfied. Becomes
     * `true` after the first successful `play()`.
     */
    unlocked: boolean;
}

/**
 * Read barcodes and QR codes from the camera.
 *
 * The camera and its classified errors come from `useCameraStream`, so this hook is
 * only the decoding half: it drives a `BarcodeDetector` over the preview on an
 * interval, suppresses the same value repeating, and exposes the torch.
 *
 * **Mounting this opens the camera.** It inherits that from `useCameraStream`, which
 * acquires on mount — so mount it *after* the user asks to scan (a button that reveals
 * the scanner), never on a page that merely contains one. A permission prompt nobody
 * provoked is the most reliable way to earn a permanent block, after which
 * `getUserMedia` rejects without ever prompting again.
 *
 * `supported` deserves a branch in the UI, not an assertion: `BarcodeDetector` is
 * Chromium-only and missing on Windows/Linux desktop, Firefox and everything on iOS.
 * Inject a `detector` to cover those, or tell the user to type the code.
 *
 * @param options - See {@link UseBarcodeScannerOptions}.
 * @returns The camera plumbing plus the scan state.
 *
 * @example
 * const scanner = useBarcodeScanner({
 *     formats: ["ean_13"],
 *     onScan: ({ rawValue }) => addToCart(rawValue),
 * });
 * return <video ref={scanner.videoRef} muted playsInline />;
 */
export declare function useBarcodeScanner(options?: UseBarcodeScannerOptions): UseBarcodeScannerResult;

/** Options for {@link useBarcodeScanner}. */
export declare interface UseBarcodeScannerOptions {
    /** Symbologies to look for. Defaults to {@link DEFAULT_BARCODE_FORMATS}. */
    formats?: readonly BarcodeFormat[];
    /** Called for every accepted read — that is, after repeat suppression. */
    onScan?: (result: BarcodeScanResult) => void;
    /**
     * How often a frame is examined, in ms. Default 200.
     *
     * Not `requestAnimationFrame`: decoding is 10–40 ms of main-thread work on a
     * phone, so running it per frame competes with the preview it is reading from and
     * makes the video stutter. Five looks per second is faster than a human can aim.
     */
    intervalMs?: number;
    /**
     * Ignore the **same** value again for this long, in ms. Default 2500.
     *
     * A symbol stays in frame for as long as the user holds the camera there, so a
     * scanner without this fires the same code five times a second — which, wired to
     * "add item to cart", is a bug the user pays for. A *different* value is never
     * suppressed.
     */
    repeatDelayMs?: number;
    /** Stop looking without releasing the camera — a confirmation sheet is open. */
    paused?: boolean;
    /**
     * A decoder to use instead of the native one.
     *
     * The way to support Safari and Firefox: hand in a polyfill and everything else
     * here works unchanged. See {@link isBarcodeDetectionSupported} for why the SDK
     * does not bundle one.
     */
    detector?: BarcodeDetectorLike;
    /** Camera constraints, forwarded to `useCameraStream`. Defaults to the rear camera. */
    constraints?: MediaStreamConstraints;
    /**
     * A frame the engine refused to decode.
     *
     * Not "nothing found" — that resolves to an empty list and is the normal case.
     * This is the engine itself failing, which the loop survives because it is
     * usually transient (a frame arriving between two resolutions).
     */
    onError?: (error: unknown) => void;
}

/** Value returned by {@link useBarcodeScanner}. */
export declare interface UseBarcodeScannerResult {
    /** Attach to a `<video ref={…} muted playsInline />`. */
    videoRef: RefObject<HTMLVideoElement | null>;
    /** Camera lifecycle. `"ready"` means the preview is running. */
    status: CameraStreamStatus;
    /** Classified camera error, or `null`. */
    error: CameraStreamError | null;
    /** `false` when there is no decoder — no native API and none injected. */
    supported: boolean;
    /**
     * Formats actually in use: the requested ones intersected with what the engine
     * reports. Empty while the probe is in flight, or when nothing matched.
     */
    formats: readonly BarcodeFormat[];
    /** Whether the detect loop is running right now. */
    scanning: boolean;
    /** The most recent accepted read, or `null`. */
    result: BarcodeScanResult | null;
    /** The LED torch of this camera, when it has one. */
    torch: UseTorchResult;
    /** Re-open the camera after an error (the user changed the permission). */
    retry: () => void;
}

/**
 * React hook for the PWA install prompt. Captures the `beforeinstallprompt`
 * event so you can defer the install UI to a moment that fits your UX.
 */
export declare function useBeforeInstallPrompt(): UseBeforeInstallPromptResult;

export declare interface UseBeforeInstallPromptResult {
    /** True when the browser fired `beforeinstallprompt` and the user has not yet decided. */
    installable: boolean;
    /** True after the user accepts the install prompt. */
    installed: boolean;
    /**
     * True when the app is already running as an installed PWA (display-mode
     * `standalone`/`fullscreen`/`minimal-ui`, or iOS `navigator.standalone`).
     * Use it to hide install affordances for users who already installed.
     */
    isStandalone: boolean;
    /** Show the install prompt. Resolves with the user's choice. */
    prompt: () => Promise<"accepted" | "dismissed" | "unsupported">;
}

/**
 * Reactive viewport-breakpoint hook.
 *
 * Returns the current breakpoint key plus `above` / `below` helpers and
 * `isMobile` / `isTablet` / `isDesktop` flags. SSR-safe — returns `xs` /
 * `width: 0` on the server, then updates after mount.
 */
export declare function useBreakpoint(): BreakpointHelpers;

/**
 * Resolve an access check against the {@link AccessControl} in context.
 *
 * Handles sync booleans, sync {@link CanResult}, and promises of either. When
 * no provider is present, access is allowed (see `useAccessControl`). The check
 * re-runs whenever the params change.
 *
 * @param params - The action/resource being checked.
 */
export declare function useCan(params: CanParams): UseCanResult;

export declare interface UseCanResult {
    /** Whether the action is permitted. Defaults to `true` while loading is not the concern of the caller. */
    allowed: boolean;
    /** `true` while an async `can` check is pending. */
    isLoading: boolean;
    /** Optional explanation, typically present when `allowed` is `false`. */
    reason?: string;
}

/**
 * Call `handler` when a `mousedown` / `touchstart` occurs outside the returned
 * ref's element. SSR-safe — listeners are only attached in the browser.
 *
 * @typeParam T - element type to attach the ref to.
 * @param handler - invoked on an outside interaction.
 * @returns A ref to attach to the element treated as "inside".
 */
export declare function useClickOutside<T extends HTMLElement = HTMLElement>(handler: () => void): RefObject<T | null>;

/**
 * Client-side filter helper. Performs a case-insensitive match on the listed
 * keys when no custom predicate is provided.
 *
 * @param items - Source list.
 * @param search - Search string.
 * @param keysOrPredicate - Either a list of keys to match against or a custom predicate.
 * @returns Filtered list (referential identity preserved when search is empty).
 */
export declare function useClientFilter<T extends Record<string, unknown>>(items: T[], search: string, keysOrPredicate: (keyof T)[] | FilterPredicate<T>): T[];

/**
 * Wrapper around `navigator.clipboard.writeText` with a transient `copied`
 * flag for UI feedback ("Copied!" toast). Falls back gracefully when the
 * Clipboard API is unavailable.
 */
export declare function useClipboard(options?: UseClipboardOptions): UseClipboardResult;

export declare interface UseClipboardOptions {
    /** Time (ms) before the `copied` flag resets back to false. Default: 1500. */
    resetAfter?: number;
}

export declare interface UseClipboardResult {
    /** True briefly after a successful copy. */
    copied: boolean;
    /** Copy a string to the clipboard. Returns `true` on success. */
    copy: (text: string) => Promise<boolean>;
    /** Manually reset the `copied` flag. */
    reset: () => void;
}

/**
 * Counts down the time left on a window that started at a known instant.
 *
 * Written around a timestamp rather than a decrementing counter on purpose: the
 * remaining time is recomputed from `Date.now()` on every tick, so a throttled
 * background tab, a slow frame or a `setInterval` that drifts cannot make the
 * countdown disagree with the clock. Remounting recovers the correct value too,
 * which a counter held in state cannot do.
 *
 * The interval stops once it reaches zero instead of ticking forever behind a
 * clamp — `useInterval` pauses on a `null` delay, so reaching zero is what tears
 * the timer down.
 *
 * @param durationMs - Length of the window.
 * @param startedAt - Epoch ms the window opened (`Date.now()` when it started).
 * @param options - Tick cadence.
 * @returns Milliseconds remaining, never below `0`.
 *
 * @example
 * const remaining = useCountdown(60_000, lastSentAt);
 *
 * <button disabled={remaining > 0}>
 *   {remaining > 0 ? `Reenviar em ${Math.ceil(remaining / 1000)}s` : "Reenviar código"}
 * </button>
 */
export declare function useCountdown(durationMs: number, startedAt: number, options?: UseCountdownOptions): number;

/** Options for {@link useCountdown}. */
export declare interface UseCountdownOptions {
    /**
     * How often the remaining time is recomputed, in ms. Default `1000`, which
     * suits a "try again in 3s" label; drop it to ~50 to drive a progress bar.
     */
    tickMs?: number;
}

/**
 * Numeric counter clamped to an optional `[min, max]` range.
 *
 * @param initial - initial value (default `0`), clamped to the range.
 * @param options - optional `min` / `max` bounds.
 * @returns Tuple `[count, { increment, decrement, set, reset }]`.
 */
export declare function useCounter(initial?: number, options?: UseCounterOptions): [number, CounterHandlers];

export declare interface UseCounterOptions {
    min?: number;
    max?: number;
}

/**
 * Create a record and invalidate the resource list cache on success.
 *
 * @param resource - The resource name.
 * @param options - Extra TanStack Mutation options.
 * @returns The mutation; `mutate(data)` creates the record.
 */
export declare function useCreate<T>(resource: string, options?: UseCreateOptions<T>): UseMutationResult<T, Error, unknown>;

/** Options for the create mutation (mutationFn + onSuccess are provided). */
export declare type UseCreateOptions<T> = Omit<UseMutationOptions<T, Error, unknown>, "mutationFn">;

/**
 * Cursor-pagination hook over TanStack Query's `useInfiniteQuery` for the
 * Tempest `CursorPaginationSchema` envelope
 * (`{ items, next_cursor, has_more, limit }`).
 *
 * The opaque `next_cursor` is fed straight back as the next page param; the
 * loop stops when `has_more` is false (or `next_cursor` is null).
 *
 * @example
 * const feed = useCursorQuery<Post>({
 *     queryKey: ["feed"],
 *     limit: 30,
 *     queryFn: (params) => postsService.listPosts(params),
 * });
 * // feed.items, feed.fetchNextPage(), feed.hasNextPage
 */
export declare function useCursorQuery<T>(options: UseCursorQueryOptions<T>): UseCursorQueryResult<T>;

export declare interface UseCursorQueryOptions<T> extends Omit<UseInfiniteQueryOptions<CursorPage<T>, Error, InfiniteData<CursorPage<T>, string | null>, QueryKey, string | null>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> {
    /** Base query key — `limit`/sort is appended for cache isolation. */
    queryKey: QueryKey;
    /** Fetcher receiving the cursor params; return the backend envelope. */
    queryFn: (params: CursorParams) => Promise<CursorPage<T>> | CursorPage<T>;
    /** Batch size sent as `limit`. Default: 20. */
    limit?: number;
    /** Initial `order_by`. */
    orderBy?: string;
    /** Initial `ascending`. Default: false. */
    ascending?: boolean;
}

export declare interface UseCursorQueryResult<T> {
    /** All rows fetched so far, flattened across batches. */
    items: T[];
    /** The raw batches, in fetch order. */
    pages: CursorPage<T>[];
    hasNextPage: boolean;
    isLoading: boolean;
    isFetchingNextPage: boolean;
    error: Error | null;
    /** Fetch the next batch (no-op when exhausted). */
    fetchNextPage: () => void;
    /** Refetch from the first batch. */
    refetch: () => void;
}

/**
 * Read the {@link DataProvider} from context.
 *
 * @returns The data provider supplied to the nearest {@link TempestDataProvider}.
 * @throws {Error} When used outside a {@link TempestDataProvider}.
 */
export declare function useDataProvider(): DataProvider;

/**
 * Debounce a fast-changing value. Returns the latest value once `delay` ms
 * have elapsed without further changes.
 *
 * @param value - The value to debounce.
 * @param delay - Delay in milliseconds (default 300).
 * @returns The debounced value.
 */
export declare function useDebounce<T>(value: T, delay?: number): T;

/**
 * Memoize a value with a structural equality check. Use when an object/array
 * created during render is fed to `useEffect` dependencies and you want to
 * avoid spurious effect runs when only the reference changes.
 *
 * The cache is a ref read and written during render. That is flagged by the React
 * Compiler rules and is nonetheless correct here: the write is idempotent — a
 * discarded render either wrote a structurally equal value or nothing at all — so
 * replaying the render cannot change the result.
 */
export declare function useDeepMemo<T>(value: T): T;

/**
 * Delete a record by id and invalidate the resource list cache on success.
 *
 * @param resource - The resource name.
 * @param options - Extra TanStack Mutation options.
 * @returns The mutation; `mutate(id)` deletes the record.
 */
export declare function useDelete<T>(resource: string, options?: UseDeleteOptions<T>): UseMutationResult<T, Error, string | number>;

/** Options for the delete mutation (mutationFn + onSuccess are provided). */
export declare type UseDeleteOptions<T> = Omit<UseMutationOptions<T, Error, string | number>, "mutationFn">;

export declare function useDescribeApiError(): (error: unknown, fallback: string, options?: DescribeApiErrorOptions) => string;

/**
 * Manage open/closed boolean state with stable `open`/`close`/`toggle` handlers.
 *
 * Richer than {@link useToggle} for UI elements like modals, drawers and
 * popovers: the handlers are referentially stable across renders.
 *
 * @param initial - initial opened state (default `false`).
 * @returns Tuple `[opened, { open, close, toggle }]`.
 */
export declare function useDisclosure(initial?: boolean): [boolean, DisclosureHandlers];

/**
 * Set `document.title` while the component is mounted, restoring the previous
 * title on unmount. SSR-safe — no-op when `document` is unavailable.
 *
 * @param title - the title to apply.
 */
export declare function useDocumentTitle(title: string): void;

/** Subscribe to `document.visibilityState`. Returns `"visible"` during SSR. */
export declare function useDocumentVisibility(): DocumentVisibility;

/**
 * Hook that propagates errors to the nearest {@link ErrorBoundary}.
 *
 * React error boundaries only catch errors thrown during render. Async errors
 * (failed mutations, websocket failures, etc.) need to be re-thrown in a
 * render pass — that is what `throwError` does.
 *
 * @example
 * const throwError = useErrorHandler();
 * useEffect(() => {
 *     stream.on("error", throwError);
 * }, []);
 */
export declare function useErrorHandler(): (error: unknown) => void;

/**
 * Subscribe to a DOM event with React-friendly semantics.
 *
 * - Handler is stored in a ref so callers can pass inline functions without
 *   resubscribing on every render.
 * - `target` defaults to `window`. Accepts a raw `EventTarget` (window, document,
 *   element) OR a ref pointing at one.
 * - Returns nothing — cleanup is automatic on unmount or when `eventName`/`target` change.
 *
 * @tempest-limits param-count — deliberately the same positional shape as
 * `addEventListener(type, listener, options)`, with the target inserted where React
 * needs it. A hook that mirrors a DOM API is read by everyone who already knows the
 * DOM API; a bespoke options bag would make the familiar call unfamiliar.
 */
export declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, target?: AnyEventTarget, options?: AddEventListenerOptions | boolean): void;

export declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, target?: AnyEventTarget, options?: AddEventListenerOptions | boolean): void;

export declare function useEventListener<K extends keyof HTMLElementEventMap>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, target?: AnyEventTarget, options?: AddEventListenerOptions | boolean): void;

/**
 * React hook wrapper around {@link createEventStream}. Connection lifecycle is
 * tied to the component (and the `url`/`enabled` dependencies); the stream
 * closes on unmount.
 *
 * Pass `schema` to have every frame validated before it reaches `onMessage`,
 * instead of trusting the type argument: without it `data` is announced as `T`
 * on the strength of the generic alone, which is a promise about the server
 * that TypeScript cannot keep. It is read when the stream opens, so declare it
 * outside the component rather than building one inline per render.
 *
 * @example
 * useEventStream<Notification>(`${API}/notifications/stream`, {
 *     enabled: !!user,
 *     withCredentials: true,
 *     onMessage: ({ data }) => addNotification(data),
 * });
 *
 * @example
 * // Validated: a frame that does not match never reaches `onMessage`
 * const notificationSchema = z.object({ id: z.string(), message: z.string() });
 *
 * useEventStream<Notification>(`${API}/notifications/stream`, {
 *     schema: notificationSchema,
 *     onValidationError: (issues) => logger.warn("stream drift", { issues }),
 *     onMessage: ({ data }) => addNotification(data),
 * });
 */
export declare function useEventStream<T = unknown>(url: string, options?: UseEventStreamOptions<T>): UseEventStreamResult<T>;

export declare interface UseEventStreamOptions<T> extends Omit<CreateEventStreamOptions<T>, "onStatusChange"> {
    /** When false, the stream is not opened. Useful for "wait for auth". Default: true. */
    enabled?: boolean;
}

export declare interface UseEventStreamResult<T> {
    status: EventStreamStatus;
    /** Last message received (excluding heartbeats). */
    lastMessage: EventStreamMessage<T> | null;
    /** Force a reconnect. */
    reconnect: () => void;
}

/**
 * Swap the document favicon by updating the `<link rel="icon">` href.
 * Creates the link element when it is missing. SSR-safe — no-op when
 * `document` is unavailable.
 *
 * @param href - the favicon URL to apply.
 */
export declare function useFavicon(href: string): void;

/**
 * Read a boolean flag and re-render when the adapter fires `onChange`.
 *
 * @example
 * const showNewFeed = useFeatureFlag("new-feed", false);
 */
export declare function useFeatureFlag(key: string, defaultValue?: boolean): boolean;

export { useFieldArray }

export { UseFieldArrayReturn }

/**
 * Read a typed flag value (string / number / boolean / null) and re-render
 * on change.
 */
export declare function useFlagValue<T extends FlagValue = FlagValue>(key: string, defaultValue?: T): T;

/**
 * Trap keyboard focus inside `containerRef` while `active` is true. Cycles
 * Tab and Shift+Tab between the first and last focusable descendants. Pair
 * with Modal/Drawer for fully-accessible overlays.
 */
export declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, active: boolean): void;

export { useForm }

export { useFormContext }

export { UseFormProps }

export { UseFormRegister }

export { UseFormReturn }

export { useFormState }

/**
 * Drive an immersive mode whose state stays true to the browser.
 *
 * The mistake this exists to remove is storing `isFullscreen` in state and
 * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your
 * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an
 * API fullscreen is active — and each of those leaves the flag saying "sair" over
 * a page that is already windowed. The only honest source is the
 * `fullscreenchange` event, which fires for every one of them, so that is what
 * this hook reads and what the returned `isFullscreen` reflects. The action
 * callbacks never touch it.
 *
 * The subscription is not this hook's own: it lives in `useFullscreenElement`,
 * shared with `usePortalHost`, which needs the same fact to decide where an
 * overlay mounts while fullscreen is on. Two independent listeners for one event
 * would mean two copies of the WebKit prefix dance and two places to fix the next
 * quirk, so the primitive answers "which element is presented" once and each
 * consumer asks its own question of the answer.
 *
 * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,
 * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —
 * because Safari on iPad still ships them and nothing else.
 *
 * `isFullscreen` is identity against the target, not containment: a `<video>`
 * inside your element going fullscreen on its own is not your element being
 * presented, and reporting `true` there would put your exit control inside a
 * subtree the browser is not painting.
 *
 * @param ref - The element to present. Omit it to present the whole page
 * (`document.documentElement`).
 * @returns `{ isFullscreen, supported, enter, exit, toggle }`.
 * @throws Nothing during render. `enter()` and `toggle()` reject with the
 * browser's own error when the request is refused — most often a `TypeError`
 * because the call did not come from a user gesture — and with an `Error` when
 * there is no element to present or the environment ships no Fullscreen API.
 *
 * @example
 * const stage = useRef<HTMLDivElement>(null);
 * const { isFullscreen, supported, toggle } = useFullscreen(stage);
 *
 * <div ref={stage}>
 *   <video src="/aula.mp4" controls />
 *   {supported ? (
 *     <button onClick={() => void toggle().catch(() => setRefused(true))}>
 *       {isFullscreen ? "Sair da tela cheia" : "Tela cheia"}
 *     </button>
 *   ) : null}
 * </div>
 */
export declare function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult;

/** Value returned by {@link useFullscreen}. */
export declare interface UseFullscreenResult {
    /** Whether the target element is the one the browser is presenting right now. */
    isFullscreen: boolean;
    /** Whether a request stands a chance at all — hide the control when `false`. */
    supported: boolean;
    /** Present the target. Must be called from a user gesture. Rejects if refused. */
    enter: () => Promise<void>;
    /** Leave fullscreen. Resolves immediately when nothing is presented. */
    exit: () => Promise<void>;
    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */
    toggle: () => Promise<void>;
}

/**
 * React hook around the Geolocation API.
 *
 * The effect depends on the individual `PositionOptions` fields instead of the
 * rest object, which is a new reference on every render and would restart the
 * watch continuously. `exhaustive-deps` is silenced there because those fields
 * are the whole of what the effect reads from it.
 *
 * @param options - Geolocation options plus `watch` and `disabled` switches.
 * @returns The latest position, error and loading state.
 */
export declare function useGeolocation(options?: UseGeolocationOptions): GeolocationState;

export declare interface UseGeolocationOptions extends PositionOptions {
    /** Use `watchPosition` instead of one-shot `getCurrentPosition`. Default: false. */
    watch?: boolean;
    /** Disable the hook without unmounting. Default: false. */
    disabled?: boolean;
}

/**
 * Track whether the pointer is hovering over the referenced element.
 * Returns `false` on touch-only devices (no pointer hover).
 *
 * @example
 * const ref = useRef<HTMLDivElement>(null);
 * const hovered = useHover(ref);
 * return <div ref={ref}>{hovered ? "✨" : ""}</div>;
 */
export declare function useHover<T extends HTMLElement>(ref: RefObject<T | null>): boolean;

/**
 * Access translation helpers. Must be used inside an {@link I18nProvider}.
 */
export declare function useI18n(): I18nContextValue;

/**
 * Detect when the user has been idle for `timeout` ms (no interaction).
 * Returns `true` once the threshold elapses and back to `false` on activity.
 */
export declare function useIdle(timeout?: number): boolean;

/**
 * React hook that resolves how (and whether) to offer PWA installation.
 *
 * It caches the `beforeinstallprompt` event, detects iOS/iPadOS, detects
 * Android Chromium forks that lack the prompt API, detects standalone display
 * mode, and applies a decline cooldown persisted in `localStorage`. The
 * resulting `method` tells the UI which install affordance to render.
 *
 * Both sides of that persistence are best-effort: `localStorage` throws in
 * Safari private mode and in a cross-origin frame with storage blocked, and an
 * exception raised while resolving an install CTA would take the page down with
 * it. A refused read means "no decline recorded"; a refused write means the CTA
 * may come back next visit.
 *
 * The decline persistence is pluggable through
 * {@link UseInstallPromptOptions.declineStorageKey} and
 * {@link UseInstallPromptOptions.declineCooldownMs} — no app-specific storage
 * layer is required, and it is SSR-guarded.
 *
 * @param options - Optional storage key, cooldown, and fallback-delay tuning.
 * @returns The install state plus `install()` and `recordDecline()` actions.
 *
 * @example
 * const { method, install } = useInstallPrompt();
 * if (method === "native") return <button onClick={install}>Install</button>;
 */
export declare function useInstallPrompt(options?: UseInstallPromptOptions): UseInstallPromptResult;

/** Options for {@link useInstallPrompt}. */
export declare interface UseInstallPromptOptions {
    /**
     * `localStorage` key used to persist the decline timestamp. Defaults to
     * `"tempest:install-declined-at"`.
     */
    declineStorageKey?: string;
    /**
     * How long, in ms, the install CTA stays hidden after the user declines.
     * Defaults to 7 days.
     */
    declineCooldownMs?: number;
    /**
     * How long, in ms, to wait for a `beforeinstallprompt` event before
     * resolving to the `"manual"` method. Defaults to `3000`.
     */
    manualFallbackDelayMs?: number;
}

/** State returned by {@link useInstallPrompt}. */
export declare interface UseInstallPromptResult {
    /** The cached `beforeinstallprompt` event, or `null` when unavailable. */
    deferredPrompt: BeforeInstallPromptEvent | null;
    /** True when the app can be installed through any supported method. */
    canInstall: boolean;
    /** True when running on iOS/iPadOS Safari. */
    isIOS: boolean;
    /** True when already running as an installed PWA. */
    isStandalone: boolean;
    /** True when the browser is an Android Chromium fork with no prompt API. */
    isManualAndroid: boolean;
    /** True when no `beforeinstallprompt` arrived within the timeout window. */
    promptTimedOut: boolean;
    /** The resolved install strategy the UI should follow. */
    method: InstallMethod;
    /** An `intent://` URL to re-open the page in Chrome on Android, else `null`. */
    openInChromeIntent: string | null;
    /**
     * Triggers the native prompt.
     *
     * @returns `true` when the user accepted the install, `false` otherwise.
     */
    install: () => Promise<boolean>;
    /** Records that the user declined the CTA, starting the cooldown window. */
    recordDecline: () => void;
}

/**
 * Track whether the referenced element intersects the viewport. Useful for
 * lazy-loading images, "load more" sentinels, and animation triggers.
 *
 * @returns `IntersectionObserverEntry | null`. `null` until the first observation.
 */
export declare function useIntersectionObserver(ref: RefObject<Element | null>, options?: UseIntersectionObserverOptions): IntersectionObserverEntry | null;

export declare interface UseIntersectionObserverOptions extends IntersectionObserverInit {
    /** Stop observing after the first intersection (one-shot). Default: false. */
    once?: boolean;
}

/**
 * Reactive `setInterval`. Pass `null` as `delay` to pause. `fn` is stored in
 * a ref so inline callbacks don't reset the interval on every render.
 *
 * @example
 * useInterval(() => poll(), enabled ? 5000 : null);
 */
export declare function useInterval(fn: () => void, delay: number | null): void;

/**
 * Return `true` on the first render of the component and `false` thereafter.
 *
 * Reads *and* flips a ref during render, which the React Compiler rules flag on
 * sight — here it is the entire hook. Under StrictMode's double render in dev the
 * second pass already sees `false`, so treat the result as "first committed
 * render" and not as a strict render counter.
 *
 * @returns Whether the current render is the first one.
 */
export declare function useIsFirstRender(): boolean;

/**
 * Bind a global keyboard shortcut. Supports modifier combinations and a
 * cross-OS `mod` key (Ctrl on Windows/Linux, Cmd on macOS).
 *
 * The effect depends on the individual `shortcut` fields rather than on the
 * object itself: callers pass an inline literal (`{ key: "k", mod: true }`),
 * which is a fresh reference on every render and would otherwise tear down and
 * re-add the listener each time. `exhaustive-deps` is silenced for that line
 * because the destructured fields are the complete dependency set.
 *
 * @example
 * useKeyboardShortcut({ key: "k", mod: true }, () => openSearch());
 */
export declare function useKeyboardShortcut(shortcut: KeyboardShortcut, handler: (event: KeyboardEvent) => void, options?: UseKeyboardShortcutOptions): void;

export declare interface UseKeyboardShortcutOptions {
    /** Disable the shortcut without unmounting. Default: false. */
    disabled?: boolean;
    /** Listen to the entire window. Pass `false` to scope to a specific element via the handler. Default: true. */
    global?: boolean;
    /** Suppress the event from firing inside `<input>`/`<textarea>`/`[contenteditable]`. Default: true. */
    ignoreInput?: boolean;
}

/**
 * Keeps a ref pointing at the most recent value it was given.
 *
 * The escape hatch for reading fresh state inside something that must not be
 * re-created when that state changes: an interval, a subscription, an event
 * listener registered once on mount. Listing the value in the effect's
 * dependencies would tear the effect down and set it back up on every change;
 * omitting it captures the value from the render that created the closure and
 * never sees another. The ref is neither — a stable object whose `current` is
 * always current.
 *
 * The assignment happens **during render**, for the same reason
 * {@link useStableCallback} does it: moving it into an effect opens a
 * one-commit staleness window, where an effect declared earlier in the same
 * commit reads the previous render's value.
 *
 * Reach for {@link useStableCallback} instead when the value is a function you
 * want to *call* — it hands back a callable with a stable identity, rather than
 * making every call site reach through `.current`.
 *
 * **List the returned ref in your effect's dependencies.** It is a stable object,
 * so the effect never re-runs because of it, but `react-hooks/exhaustive-deps`
 * cannot prove that for a custom hook the way it does for a bare `useRef`.
 * Listing it lets the rule verify the array instead of taking an omission on
 * trust.
 *
 * **Not for holding the previous value.** The write happens during render, so
 * `.current` is already the current value by the time any effect reads it. A hook
 * that wants the value from the *previous* commit — `usePrevious` — needs the
 * effect-based write, and swapping it for this would make it return the present.
 *
 * @typeParam T - The tracked value.
 * @param value - The value to track. Written on every render.
 * @returns A stable ref whose `current` holds the latest `value`.
 *
 * @example
 * const optionsRef = useLatestRef(options);
 *
 * useEffect(() => {
 *   const id = setInterval(() => poll(optionsRef.current), 5_000);
 *   return () => clearInterval(id);
 * }, []); // the interval survives every options change, and still reads the latest
 */
export declare function useLatestRef<T>(value: T): RefObject<T>;

/**
 * Poll one connection's throughput, resolution and round trip.
 *
 * Sampling runs only while the connection is `"connected"`, so a link that is
 * still negotiating or already gone costs nothing. The last reading is kept
 * across pauses rather than cleared, because a badge that blanks every time the
 * tab loses focus reads as a broken connection.
 *
 * Coming back from a pause resets the baseline first. Without that, the sample
 * after a five-minute background stretch divides five minutes of bytes by five
 * minutes and reports the average of a period the person is not asking about.
 *
 * @param connection - The connection to watch, or `null` before one exists.
 * @param options - See {@link UseLinkStatsOptions}.
 * @returns The latest reading, or `null` before the first sample lands.
 *
 * @example
 * const stats = useLinkStats(pc);
 *
 * return <span>{stats ? `${stats.kbps} kbps · ${stats.rttMs ?? "—"} ms` : "medindo…"}</span>;
 */
export declare function useLinkStats(connection: RTCPeerConnection | null, options?: UseLinkStatsOptions): LinkStats | null;

/** Options for {@link useLinkStats}. */
export declare interface UseLinkStatsOptions {
    /**
     * How often to sample, in milliseconds. Default `2000`.
     *
     * `getStats()` walks every report a connection holds, and a mesh runs one
     * per participant — on the device least able to pay for it. The numbers feed
     * a latency badge and a throughput figure nobody reads at 1 Hz, so the
     * default is deliberately slower than a frame budget suggests.
     */
    intervalMs?: number;
    /**
     * Stop sampling while the tab is in the background. Default `true`.
     *
     * The audio path is untouched by this — people in a backgrounded call still
     * expect to hear it. What stops is the measuring, which nobody can see.
     */
    pauseWhenHidden?: boolean;
    /** Which media the throughput counts. Default `"video"`. */
    kind?: LinkStatsKind;
}

/**
 * Query a paginated list of a resource through the active {@link useDataProvider}.
 *
 * @param resource - The resource name.
 * @param params - Pagination, sort and filter parameters.
 * @param options - Extra TanStack Query options.
 * @returns The TanStack Query result for the offset page.
 */
export declare function useList<T>(resource: string, params?: GetListParams, options?: UseListOptions<T>): UseQueryResult<OffsetPage<T>, Error>;

/** Extra TanStack Query options for {@link useList} (key + fn are provided). */
export declare type UseListOptions<T> = Omit<UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>>, "queryKey" | "queryFn">;

/**
 * Manage an array as state with a rich set of immutable handlers.
 *
 * @typeParam T - element type.
 * @param initial - initial list (default `[]`).
 * @returns Tuple `[list, handlers]`.
 */
export declare function useListState<T>(initial?: T[]): [T[], ListStateHandlers<T>];

/**
 * State synced with `localStorage`. SSR-safe — initial render returns the
 * provided default; the stored value is hydrated after mount. Updates to the
 * same key in other tabs are picked up via the `storage` event.
 *
 * @tempest-limits empty-catch — the three swallows here are the hook's contract.
 * A write that hits the quota (or Safari private mode) still updates React state,
 * so the session keeps working and only persistence is lost; a `storage` event
 * carrying a value this tab cannot deserialize is another tab's bug, and the
 * useful response is to keep the value already rendered rather than tear the
 * component down over a foreign write.
 *
 * @param key - localStorage key.
 * @param defaultValue - value used when nothing is stored or in SSR.
 * @param options - custom `serialize` / `deserialize` (default JSON).
 * @returns Tuple `[value, setValue, remove]`.
 */
export declare function useLocalStorage<T>(key: string, defaultValue: T, options?: LocalStorageOptions<T>): [T, (value: T | ((prev: T) => T)) => void, () => void];

export { useLocation }

/**
 * Detect long-press / long-tap gestures. Fires `fn` after `delay` ms
 * while the element is held. Cancels on move beyond `moveThreshold` or
 * pointer up before `delay`.
 *
 * @example
 * const ref = useRef<HTMLDivElement>(null);
 * useLongPress(ref, () => openContextMenu(), { delay: 600 });
 */
export declare function useLongPress<T extends HTMLElement>(ref: RefObject<T | null>, fn: () => void, options?: UseLongPressOptions): void;

/**
 * Returns DOM event handlers that detect a long press (touch or mouse hold)
 * and invoke `onLongPress` once after `delayMs`.
 *
 * Cancels on touch movement or pointer release. Also wires `contextmenu` to
 * fire `onLongPress` immediately so a right-click on desktop opens selection
 * mode the same way an Android long-press does on mobile.
 *
 * The hook does not `preventDefault` on the underlying click — the consumer
 * decides whether the subsequent click should still fire. Track that with the
 * returned `wasLongPress()` guard to tell "long-press fired" apart from a
 * "regular click".
 *
 * Unlike {@link useLongPress}, which attaches pointer listeners to a `ref`,
 * this variant returns handler props you spread directly onto an element and
 * exposes a `wasLongPress()` guard.
 *
 * @param onLongPress - Callback invoked once the hold threshold is reached.
 * @param options - Optional `delayMs` and `disabled` flags.
 * @returns The spreadable handlers plus a `wasLongPress()` guard.
 *
 * @example
 * const longPress = useLongPressHandlers(() => enterSelectionMode(), { delayMs: 600 });
 * <button {...longPress} onClick={() => { if (!longPress.wasLongPress()) navigate(); }}>
 *   Item
 * </button>
 */
export declare function useLongPressHandlers(onLongPress: () => void, options?: UseLongPressHandlersOptions): UseLongPressHandlersResult;

/** Options accepted by {@link useLongPressHandlers}. */
export declare interface UseLongPressHandlersOptions {
    /** Hold duration in ms before `onLongPress` fires. Defaults to `500`. */
    delayMs?: number;
    /** When `true`, the hook is inert and every handler is a no-op. */
    disabled?: boolean;
}

/** Return shape of {@link useLongPressHandlers}. */
export declare type UseLongPressHandlersResult = LongPressHandlers & {
    /**
     * Reads whether the most recent interaction fired a long-press. Use it in
     * the element's `onClick` to suppress the click that follows a long-press.
     */
    wasLongPress: () => boolean;
};

export declare interface UseLongPressOptions {
    /** Press duration in ms. Default `500`. */
    delay?: number;
    /** Pixel threshold — finger/mouse movement beyond this cancels the press. Default `10`. */
    moveThreshold?: number;
}

/**
 * Reactive `Map` wrapper. Mutating via `set` / `delete` / `clear` triggers a
 * re-render and yields a fresh `map` reference each time.
 *
 * @typeParam K - key type.
 * @typeParam V - value type.
 * @param initial - initial entries.
 * @returns `{ map, set, delete, clear, get, has, size }`.
 */
export declare function useMap<K, V>(initial?: Iterable<readonly [K, V]>): UseMapResult<K, V>;

export declare interface UseMapResult<K, V> {
    map: ReadonlyMap<K, V>;
    set: (key: K, value: V) => void;
    delete: (key: K) => void;
    clear: () => void;
    get: (key: K) => V | undefined;
    has: (key: K) => boolean;
    size: number;
}

export { useMatch }

/**
 * List capture and playback devices, and keep the list fresh.
 *
 * Two things about `enumerateDevices` that decide how a picker must be built:
 *
 * 1. **Labels are gated behind permission.** Before the user grants a capture
 *    permission, every `label` is `""` — the list length and ids are real, the names
 *    are not. A device picker rendered at that point is a column of blanks, so
 *    `labelsAvailable` is exposed to gate it. Ask for the microphone first, then
 *    show the picker.
 * 2. **The list changes while the page is open.** Plugging in a headset mid-recording
 *    is the normal case, not an edge case, so the hook subscribes to `devicechange`
 *    instead of enumerating once on mount.
 *
 * `audioOutputs` is empty on browsers with no output routing at all (Safari and
 * Firefox do not implement `setSinkId`); an empty array there means "you cannot
 * offer this choice", not "no speakers".
 *
 * @returns The device lists, whether labels are filled in, and a `refresh()`.
 *
 * @example
 * const { audioInputs, labelsAvailable } = useMediaDevices();
 * // ...after the mic permission is granted:
 * {labelsAvailable && <Select options={audioInputs.map((d) => ({ value: d.deviceId, label: d.label }))} />}
 */
export declare function useMediaDevices(): UseMediaDevicesResult;

/** Value returned by {@link useMediaDevices}. */
export declare interface UseMediaDevicesResult {
    /** Every device, in the order the browser listed them. */
    devices: MediaDeviceOption[];
    /** Microphones and other audio sources. */
    audioInputs: MediaDeviceOption[];
    /** Speakers and headsets. Empty on browsers with no output routing (Safari, Firefox). */
    audioOutputs: MediaDeviceOption[];
    /** Cameras. */
    videoInputs: MediaDeviceOption[];
    /**
     * Whether labels are filled in.
     *
     * `false` means the list is real but anonymous — render a picker only after a
     * capture permission has been granted, or the user sees "" repeated N times.
     */
    labelsAvailable: boolean;
    /** `enumerateDevices` is unavailable in this browser. */
    supported: boolean;
    /** Re-enumerate. The hook already does this on `devicechange`. */
    refresh: () => void;
}

/**
 * Read a capture permission **without triggering the prompt**.
 *
 * This is the piece that makes a good permission flow possible. `getUserMedia` is
 * the only way to *get* a device, but calling it is also the only way to *ask*, and
 * a prompt fired on page load — before the user has pressed anything — is the
 * single most reliable way to earn a permanent "Block". Reading the state first
 * lets a page explain why it needs the microphone, and only then ask.
 *
 * It also separates "never asked" from "denied", which matters because they need
 * opposite UI: `"prompt"` gets a button, `"denied"` gets instructions for the
 * browser's site settings, since no amount of clicking will re-prompt.
 *
 * Safari does not expose `microphone` to the Permissions API and throws on the
 * query, which surfaces as `state: "unknown"` and `supported: false` — treat that
 * as "you will have to ask to find out", not as an error.
 *
 * @param name - Which permission to observe.
 * @returns The live state, whether it could be read, and a manual `refresh()`.
 *
 * @example
 * const { state } = useMediaPermission("microphone");
 * if (state === "denied") return <p>Libere o microfone nas configurações do site.</p>;
 * return <button onClick={start}>Gravar</button>;
 */
export declare function useMediaPermission(name: MediaPermissionName): UseMediaPermissionResult;

/** Value returned by {@link useMediaPermission}. */
export declare interface UseMediaPermissionResult {
    /** Current state. Updates live when the user changes it in browser settings. */
    state: MediaPermissionState;
    /** Whether the Permissions API could answer at all. */
    supported: boolean;
    /** Re-read the permission. Rarely needed — the hook subscribes to changes. */
    refresh: () => void;
}

/**
 * Subscribe to a CSS media query and re-render on match changes.
 *
 * @param query - A standard CSS media query string, e.g. "(max-width: 768px)".
 * @returns True when the query matches.
 */
export declare function useMediaQuery(query: string): boolean;

/**
 * Acquire a microphone `MediaStream`, classified errors included, and release it
 * properly.
 *
 * Releasing matters more than it looks. Every track has to be stopped by hand:
 * dropping the last reference to a `MediaStream` does **not** turn off the
 * microphone, so the browser keeps showing its recording indicator and the OS keeps
 * the device busy — which then makes the *next* `getUserMedia` fail with
 * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,
 * and before re-opening.
 *
 * @param options - See {@link UseMicrophoneOptions}.
 * @returns The stream, its status, a classified error, and `start`/`stop`.
 *
 * @example
 * const mic = useMicrophone();
 * const recorder = useAudioRecorder(mic.stream);
 * <button onClick={mic.start}>Liberar microfone</button>
 */
export declare function useMicrophone(options?: UseMicrophoneOptions): UseMicrophoneResult;

/** Options for {@link useMicrophone}. */
export declare interface UseMicrophoneOptions {
    /**
     * Open the stream on mount instead of waiting for `start()`. Default `false`.
     *
     * Left off on purpose. Opening on mount means prompting on mount, and a
     * permission prompt the user did not provoke is the most reliable way to earn a
     * permanent "Block" — after which `getUserMedia` rejects without ever prompting
     * again. Wire `start()` to the button that needs the microphone.
     */
    autoStart?: boolean;
    /** Specific microphone, from `useMediaDevices().audioInputs`. */
    deviceId?: string;
    /**
     * Browser voice processing. All three default to `true`, which is what speech
     * wants; turn them off for music, where a gate chewing on a decaying note is
     * worse than the room noise it removes.
     */
    echoCancellation?: boolean;
    noiseSuppression?: boolean;
    autoGainControl?: boolean;
    /** Escape hatch: full constraints, replacing everything above. */
    constraints?: MediaStreamConstraints;
}

/** Value returned by {@link useMicrophone}. */
export declare interface UseMicrophoneResult {
    status: MicrophoneStatus;
    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */
    stream: MediaStream | null;
    /** Classified error, or `null` outside the `error` status. */
    error: MediaAccessError | null;
    /** Open the stream. Safe to call when already open — it is a no-op. */
    start: () => void;
    /** Release the microphone. The browser's recording indicator only clears here. */
    stop: () => void;
}

/**
 * Access the imperative modals API. Must be used within a {@link ModalsProvider}.
 *
 * @example
 * const modals = useModals();
 * modals.confirm({ message: "Excluir item?", danger: true, onConfirm: del });
 *
 * @throws Error when called outside a {@link ModalsProvider}.
 */
export declare function useModals(): ModalsApi;

export { useNavigate }

/**
 * Client-side inbox state for received notifications.
 *
 * Newest first, deduplicated by `id`, capped at `limit`. Pairs with
 * `NotificationCenter` for the UI and with the `push` module for the source:
 * point a service worker's `postMessage` at it and a push that arrives while the
 * app is open shows up in the inbox instead of only as an OS notification.
 *
 * Persistence is deliberately left out — where an inbox belongs (server, Dexie,
 * `localStorage`) is an app decision. Use `onChange` to write it wherever it goes,
 * and `initialItems` to read it back.
 *
 * @example
 * const inbox = useNotificationInbox({
 *     initialItems: await api.notifications.list(),
 *     onChange: (items) => storage.set("inbox", items),
 * });
 *
 * <NotificationCenter
 *     items={inbox.items}
 *     onMarkRead={inbox.markRead}
 *     onMarkAllRead={inbox.markAllRead}
 *     onDismiss={inbox.remove}
 * />
 */
export declare function useNotificationInbox(options?: UseNotificationInboxOptions): UseNotificationInboxResult;

export declare interface UseNotificationInboxOptions {
    /** Entries the inbox starts with — typically what the API returned. */
    initialItems?: readonly NotificationItem[];
    /**
     * Listen for `message` events from the service worker and add whatever
     * arrives. Default `true`.
     *
     * This is the missing half of web push: a service worker runs outside the
     * page and cannot touch React state, so a push that arrives while the app is
     * open shows an OS notification and then vanishes as far as the UI is
     * concerned. Have the worker `postMessage` the payload and it lands here.
     */
    listenToServiceWorker?: boolean;
    /**
     * Message `type` to accept from the worker. Default `"tempest:notification"`.
     *
     * Filtering by type matters because the SW message channel is shared — a
     * sync-progress ping or a cache-updated notice would otherwise show up in the
     * user's inbox.
     */
    messageType?: string;
    /**
     * Cap on stored entries; the oldest are dropped past it. Default `100`.
     *
     * An inbox fed by push grows without bound otherwise, and it lives in memory.
     */
    limit?: number;
    /** Called whenever the list changes — the hook for persisting it. */
    onChange?: (items: readonly NotificationItem[]) => void;
}

export declare interface UseNotificationInboxResult {
    items: NotificationItem[];
    unreadCount: number;
    /** Add an entry, or update the existing one with the same id. */
    add: (item: NotificationItem) => void;
    markRead: (id: string) => void;
    markUnread: (id: string) => void;
    markAllRead: () => void;
    remove: (id: string) => void;
    clear: () => void;
}

/**
 * Run an OAuth-callback "exchange" exactly once on mount. Designed for
 * `/callback` routes that receive provider redirects and need to swap a
 * code/token for an app session via the backend.
 *
 * Survives React StrictMode double-mounting in dev — uses a ref guard to
 * ensure `exchange` runs once.
 *
 * @example
 * function OAuthCallback() {
 *     const { loading, error } = useOAuthCallback({
 *         exchange: async () => {
 *             const code = new URLSearchParams(location.search).get("code")!;
 *             return api.post("/auth/google/exchange", { body: { code } });
 *         },
 *         onSuccess: ({ token, user }) => {
 *             useAuthStore.getState().setSession({ user, token });
 *             navigate("/dashboard", { replace: true });
 *         },
 *         onError: () => navigate("/login?error=oauth", { replace: true }),
 *     });
 *
 *     if (loading) return <Spinner />;
 *     if (error) return <ErrorState description="OAuth falhou" />;
 *     return null;
 * }
 */
export declare function useOAuthCallback<T>(options: UseOAuthCallbackOptions<T>): UseOAuthCallbackResult<T>;

export declare interface UseOAuthCallbackOptions<T> {
    /** Function that exchanges the provider response for an app session. Called once on mount. */
    exchange: () => Promise<T>;
    /** Fired with the result on success. Receives the value resolved by `exchange`. */
    onSuccess?: (result: T) => void | Promise<void>;
    /** Fired when `exchange` throws or rejects. */
    onError?: (error: unknown) => void;
}

export declare interface UseOAuthCallbackResult<T> {
    /** `true` while the exchange promise is pending. */
    loading: boolean;
    /** Last resolved value, when `status === "success"`. */
    data: T | null;
    /** Last rejection reason, when `status === "error"`. */
    error: unknown;
    /** Aggregated state — `"pending"`, `"success"`, or `"error"`. */
    status: "pending" | "success" | "error";
}

/**
 * Create an object URL for a `Blob` (or `File`) and revoke it automatically on
 * unmount or whenever the blob changes. Returns `null` for nullish input.
 *
 * @param blob - the blob to expose as an object URL, or `null`/`undefined`.
 * @returns The object URL string, or `null` when there is no blob.
 */
export declare function useObjectUrl(blob: Blob | null | undefined): string | null;

/**
 * Optimistic mutation that writes to an {@link OfflineSync} outbox instead of
 * hitting the network directly, bridging the sync engine and TanStack Query.
 *
 * On `mutate` it enqueues the entry, optimistically patches the given query
 * cache key and kicks a flush; if the enqueue itself throws, the cache is
 * rolled back to its previous value. Server delivery happens later inside the
 * engine's flush loop, so the UI updates instantly and survives reloads and
 * offline periods.
 *
 * @typeParam TVariables - The `mutate(variables)` input shape.
 * @typeParam TData - The cached query data optimistically patched.
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 * @param options - Engine, variables→entry mapping and cache wiring.
 * @returns The TanStack {@link UseMutationResult}; the mutation resolves to the
 *   generated outbox entry id.
 *
 * @example
 * const addNote = useOfflineMutation({
 *     sync: notesSync,
 *     queryKey: ["notes"],
 *     toEntry: (note: Note) => ({ op: "create", recordId: note.id, payload: note }),
 *     applyOptimistic: (current: Note[] = [], note) => [...current, note],
 * });
 * addNote.mutate(newNote);
 */
export declare function useOfflineMutation<TVariables, TData = unknown, TPayload = unknown>(options: UseOfflineMutationOptions<TVariables, TData, TPayload>): UseMutationResult<string, Error, TVariables, MutationContext<TData>>;

/**
 * Configuration for {@link useOfflineMutation}.
 *
 * @typeParam TVariables - The `mutate(variables)` input shape.
 * @typeParam TData - The cached query data optimistically patched.
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 */
export declare interface UseOfflineMutationOptions<TVariables, TData, TPayload> {
    /** The engine the mutation enqueues into. */
    sync: OfflineSync<TPayload>;
    /** Map `mutate` variables into an outbox entry. */
    toEntry: (variables: TVariables) => OutboxDraft<TPayload>;
    /**
     * Query key to optimistically patch and (optionally) invalidate. Omit to
     * only enqueue without touching the React Query cache.
     */
    queryKey?: QueryKey;
    /**
     * Produce the next cached value from the current one and the variables.
     * Runs in `onMutate`; the previous value is restored automatically if the
     * enqueue throws. Requires `queryKey`.
     */
    applyOptimistic?: (current: TData | undefined, variables: TVariables) => TData;
    /**
     * Trigger a flush after enqueueing. `true` (default) uses
     * `"after-mutation"`; pass a custom {@link SyncTrigger} string, or `false`
     * to leave flushing to the caller / auto-flush hooks.
     */
    flush?: boolean | SyncTrigger;
    /** Invalidate `queryKey` in `onSettled` so a later read refetches. Default `false`. */
    invalidate?: boolean;
}

/**
 * Subscribe a React component to an {@link OfflineSync} engine.
 *
 * Re-renders whenever the engine's {@link SyncState} changes (enqueue, flush
 * transition, outbox clear) via `useSyncExternalStore`, and optionally wires
 * auto-flush on mount, on the `online` event and on an interval. The engine
 * itself is created once by the app and passed in — the hook never owns it, so
 * multiple components can observe the same queue.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 * @param sync - The engine returned by `createOfflineSync`.
 * @param options - Auto-flush triggers.
 * @returns The reactive state merged with `enqueue`/`flush` actions.
 *
 * @example
 * const { pending, syncing, phase, flush } = useOfflineSync(notesSync, {
 *     flushOnMount: true,
 *     intervalMs: 30_000,
 * });
 * return <SyncStatusBadge pending={pending} syncing={syncing} phase={phase} />;
 */
export declare function useOfflineSync<TPayload>(sync: OfflineSync<TPayload>, options?: UseOfflineSyncOptions): UseOfflineSyncResult<TPayload>;

/**
 * Options for {@link useOfflineSync}. All auto-flush triggers are opt-in except
 * `flushOnOnline`, which defaults to `true` so the app catches up the moment
 * connectivity returns.
 */
export declare interface UseOfflineSyncOptions {
    /** Flush once when the component mounts (trigger `"boot"`). Default `false`. */
    flushOnMount?: boolean;
    /**
     * Flush when the browser fires the `online` event (trigger
     * `"online-event"`). Default `true`.
     */
    flushOnOnline?: boolean;
    /**
     * Flush on this interval in milliseconds (trigger `"interval"`). `0`
     * disables the timer. Default `0`.
     */
    intervalMs?: number;
}

/**
 * Reactive view of an {@link OfflineSync} engine, plus its imperative actions.
 * Extends {@link SyncState} so `phase`, `pending`, `lastSummary`, `lastError`
 * and `lastSyncedAt` are read directly off the result.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 */
export declare interface UseOfflineSyncResult<TPayload> extends SyncState {
    /** `true` while a flush run is in progress (`phase === "syncing"`). */
    syncing: boolean;
    /** Queue a mutation. Mirrors {@link OfflineSync.enqueue}. */
    enqueue: (op: OutboxOp, recordId: string, payload?: TPayload) => Promise<string>;
    /** Trigger a flush run. Mirrors {@link OfflineSync.flush}. */
    flush: (trigger?: SyncTrigger) => Promise<SyncRunSummary>;
}

/**
 * Query a single record by id through the active {@link useDataProvider}.
 *
 * The query is disabled while `id` is `null`/`undefined`.
 *
 * @param resource - The resource name.
 * @param id - The record id.
 * @param options - Extra TanStack Query options.
 * @returns The TanStack Query result for the record.
 */
export declare function useOne<T>(resource: string, id: string | number | null | undefined, options?: UseOneOptions<T>): UseQueryResult<T, Error>;

/** Extra TanStack Query options for {@link useOne} (key + fn + enabled are provided). */
export declare type UseOneOptions<T> = Omit<UseQueryOptions<T, Error, T>, "queryKey" | "queryFn" | "enabled"> & {
    enabled?: boolean;
};

/**
 * Track connectivity and re-render on changes.
 *
 * With no options it mirrors `navigator.onLine` (assuming online during SSR and
 * before the first event). Pass `pingUrl` to additionally probe real
 * reachability — the browser's `onLine` flag lies behind captive portals and
 * dead links, so the probe downgrades the result to `false` when the network is
 * unusable even though `navigator.onLine` is `true`.
 *
 * @param options - Optional reachability-probe configuration.
 * @returns `true` when the device is online (and reachable, when probing).
 *
 * @example
 * const online = useOnline(); // navigator.onLine only
 * const reallyOnline = useOnline({ pingUrl: "/health", intervalMs: 15_000 });
 */
export declare function useOnline(options?: UseOnlineOptions): boolean;

/**
 * Options for {@link useOnline}. Omit them for the cheap `navigator.onLine`
 * behaviour; pass `pingUrl` to add a real-reachability probe on top.
 */
export declare interface UseOnlineOptions {
    /**
     * URL to probe for real connectivity. `navigator.onLine` reports `true`
     * behind a captive portal or when the machine has a link but no internet;
     * a periodic `HEAD` to this URL catches those cases. When set, the result
     * is `navigator.onLine && lastProbeSucceeded`.
     */
    pingUrl?: string;
    /** How often to probe, in ms. Default `30000`. */
    intervalMs?: number;
    /** Abort a probe after this many ms and treat it as offline. Default `5000`. */
    timeoutMs?: number;
}

/**
 * Access translation helpers when there may be no {@link I18nProvider} above.
 *
 * Returns `null` instead of throwing, which is what a piece of the SDK needs
 * when it wants to be translated where a catalog exists and still work where one
 * does not — i18n is opt-in in this SDK, and a helper that demanded a provider
 * would turn "you did not configure translations" into a crash.
 *
 * @returns The context value, or `null` outside a provider.
 */
export declare function useOptionalI18n(): I18nContextValue | null;

/**
 * Offset-pagination hook over TanStack Query for the fastapi-pagination /
 * Tempest envelope (`{ items, total, page, size, pages }`).
 *
 * It owns the page state, sends `page` + the size param (`size` by default,
 * or `page_size` via `sizeParam`) plus optional `order_by`/`ascending` to your
 * fetcher, keeps the previous page visible while the next loads, and derives
 * `hasNext`/`hasPrev`/`pageCount`.
 *
 * @example
 * const users = usePaginatedQuery<User>({
 *     queryKey: ["users"],
 *     pageSize: 25,
 *     queryFn: (params) => usersService.listUsers(params),
 * });
 * // users.items, users.next(), users.hasNext, users.pageCount
 */
export declare function usePaginatedQuery<T>(options: UsePaginatedQueryOptions<T>): UsePaginatedQueryResult<T>;

export declare interface UsePaginatedQueryOptions<T> extends Omit<UseQueryOptions<OffsetPage<T>, Error, OffsetPage<T>, QueryKey>, "queryKey" | "queryFn"> {
    /** Base query key — the current page/sort is appended for cache isolation. */
    queryKey: QueryKey;
    /** Fetcher receiving the offset params; return the backend envelope. */
    queryFn: (params: OffsetParams) => Promise<OffsetPage<T>> | OffsetPage<T>;
    /** Initial 1-based page. Default: 1. */
    initialPage?: number;
    /** Page size. Default: 20. */
    pageSize?: number;
    /**
     * Query-param name for the page size. fastapi-pagination uses `"size"`
     * (default); SDK `BasePaginationFilterSchema` configs may use `"page_size"`.
     */
    sizeParam?: "size" | "page_size";
    /** Initial `order_by` (only sent when set). */
    orderBy?: string;
    /** Initial `ascending` (only sent when `orderBy` is set). Default: false. */
    ascending?: boolean;
}

export declare interface UsePaginatedQueryResult<T> {
    /** The current page envelope, or undefined while the first load is pending. */
    page: OffsetPage<T> | undefined;
    /** The rows of the current page (empty array while pending). */
    items: T[];
    /** Current 1-based page number (controlled by the hook). */
    pageNumber: number;
    /** Total page count from the last successful response. */
    pageCount: number;
    /** Total row count from the last successful response. */
    total: number;
    hasNext: boolean;
    hasPrev: boolean;
    isLoading: boolean;
    isFetching: boolean;
    error: Error | null;
    /** Jump to a specific 1-based page (clamped to >= 1). */
    setPage: (page: number) => void;
    /** Go to the next page when available. */
    next: () => void;
    /** Go to the previous page when available. */
    prev: () => void;
    /** Refetch the current page. */
    refetch: () => void;
}

/**
 * Manage page/size state for paginated lists. Reset goes back to page 1
 * without touching the page size.
 *
 * @param initialPage - Starting page (default 1).
 * @param initialSize - Starting page size (default 50).
 * @returns Pagination state and setters.
 */
export declare function usePagination(initialPage?: number, initialSize?: number): UsePaginationResult;

export declare interface UsePaginationResult {
    page: number;
    size: number;
    setPage: (page: number) => void;
    setSize: (size: number) => void;
    reset: () => void;
}

export { useParams }

/**
 * Probe what this device can do, once per mount.
 *
 * @param client - Client whose probes to call.
 * @returns The three capability answers, two of them async.
 */
export declare function usePasskeyCapabilities(client?: PasskeyClient): PasskeyCapabilities;

/**
 * Register a passkey: fetch options, run `navigator.credentials.create`, hand the
 * credential to your backend.
 *
 * `register()` **resolves** rather than rejects on failure, because every failure
 * here is already state the UI has to render (`error.kind`, `status`). Forcing a
 * `try/catch` around a button handler that also has to set state would only
 * duplicate what the hook holds.
 *
 * @param options - Transport callbacks plus optional client and listeners.
 * @returns Ceremony state, the `register` action, and the capability probes.
 *
 * @example
 * const passkey = usePasskeyRegistration({
 *     getOptions: () => api.post("/webauthn/register/begin"),
 *     verify: (credential) => api.post("/webauthn/register/finish", { body: credential }),
 * });
 *
 * if (passkey.platformAvailable === false) return null;
 * return (
 *     <button onClick={() => void passkey.register()} disabled={passkey.status === "prompting"}>
 *         Criar passkey
 *     </button>
 * );
 */
export declare function usePasskeyRegistration<TResult = unknown>(options: UsePasskeyRegistrationOptions<TResult>): UsePasskeyRegistrationResult<TResult>;

/** Options for {@link usePasskeyRegistration}. */
export declare interface UsePasskeyRegistrationOptions<TResult> {
    /** Fetch server options — your `POST /webauthn/register/begin`. */
    getOptions: () => Promise<PasskeyCreationOptionsJSON>;
    /** Send the credential to be verified — your `POST /webauthn/register/finish`. */
    verify: (credential: PasskeyRegistrationJSON) => Promise<TResult>;
    /** Client to use. Defaults to a shared `createPasskeyClient()`. */
    client?: PasskeyClient;
    /** Called with whatever `verify` resolved to. */
    onSuccess?: (result: TResult) => void;
    /** Called with the classified failure. */
    onError?: (error: PasskeyError) => void;
}

/** Value returned by {@link usePasskeyRegistration}. */
export declare interface UsePasskeyRegistrationResult<TResult> extends PasskeyCapabilities {
    /** Run the ceremony. Resolves `null` on failure — read `error` for the reason. */
    register: () => Promise<TResult | null>;
    /** Current phase. */
    status: PasskeyStatus;
    /** Last failure, cleared when a new attempt starts. */
    error: PasskeyError | null;
    /** Whatever `verify` resolved to, on success. */
    data: TResult | null;
    /** Close the browser sheet from your own UI. */
    cancel: () => void;
    /** Back to `"idle"`, clearing `error` and `data`. */
    reset: () => void;
}

/**
 * Sign in with a passkey, with or without the autofill flow.
 *
 * Two ways in, and a good login page wires both. `signIn()` is the explicit
 * button. `conditional: true` arms the pleasant one: the browser lists the user's
 * passkeys inside the username field itself, so signing in is one tap and no
 * password was ever typed. The field must carry
 * `autocomplete="username webauthn"` or the list never appears — the hook cannot
 * do that part for you.
 *
 * A conditional request that is aborted (unmount, or the user typing a password
 * instead) is **not** surfaced as an error: nothing failed, the user chose
 * another door.
 *
 * @param options - Transport callbacks, `conditional`, optional client and listeners.
 * @returns Ceremony state, the `signIn` action, and the capability probes.
 *
 * @example
 * const passkey = usePasskeySignIn({
 *     conditional: true,
 *     getOptions: () => api.post("/webauthn/signin/begin"),
 *     verify: (assertion) => api.post("/webauthn/signin/finish", { body: assertion }),
 *     onSuccess: (session) => auth.setToken(session.access_token),
 * });
 *
 * <input name="email" autoComplete="username webauthn" />
 * <button onClick={() => void passkey.signIn()}>Entrar com passkey</button>
 */
export declare function usePasskeySignIn<TResult = unknown>(options: UsePasskeySignInOptions<TResult>): UsePasskeySignInResult<TResult>;

/** Options for {@link usePasskeySignIn}. */
export declare interface UsePasskeySignInOptions<TResult> {
    /** Fetch server options — your `POST /webauthn/signin/begin`. */
    getOptions: () => Promise<PasskeyRequestOptionsJSON>;
    /** Send the assertion to be verified — your `POST /webauthn/signin/finish`. */
    verify: (assertion: PasskeyAuthenticationJSON) => Promise<TResult>;
    /** Client to use. Defaults to a shared `createPasskeyClient()`. */
    client?: PasskeyClient;
    /**
     * Arm the autofill flow on mount (`mediation: "conditional"`).
     *
     * The request stays pending, invisibly, until the user picks a passkey from
     * the browser's autofill list — so the field it should appear on needs
     * `autocomplete="username webauthn"`. Only one conditional request may be live
     * per page, and it is aborted on unmount.
     */
    conditional?: boolean;
    /** Called with whatever `verify` resolved to. */
    onSuccess?: (result: TResult) => void;
    /** Called with the classified failure. */
    onError?: (error: PasskeyError) => void;
}

/** Value returned by {@link usePasskeySignIn}. */
export declare interface UsePasskeySignInResult<TResult> extends PasskeyCapabilities {
    /** Run the modal ceremony. Resolves `null` on failure. */
    signIn: () => Promise<TResult | null>;
    /** Current phase. */
    status: PasskeyStatus;
    /** Last failure, cleared when a new attempt starts. */
    error: PasskeyError | null;
    /** Whatever `verify` resolved to, on success. */
    data: TResult | null;
    /** True while an armed conditional (autofill) request is waiting. */
    conditionalPending: boolean;
    /** Close the browser sheet from your own UI. */
    cancel: () => void;
    /** Back to `"idle"`, clearing `error` and `data`. */
    reset: () => void;
}

/**
 * Poll an async factory on a fixed interval. Skips overlapping requests if a
 * prior call has not finished. Pause via `disabled` or `stopWhen`.
 */
export declare function usePoll<T>(factory: () => Promise<T>, options: UsePollOptions<T>): UsePollResult<T>;

export declare interface UsePollOptions<T> {
    /** Polling interval in ms. */
    interval: number;
    /** Disable polling without unmounting. Default: false. */
    disabled?: boolean;
    /** Stop polling once the predicate returns true. */
    stopWhen?: (data: T) => boolean;
    /** Called on each error. */
    onError?: (error: unknown) => void;
}

export declare interface UsePollResult<T> {
    data: T | null;
    error: unknown;
    loading: boolean;
    stop: () => void;
    start: () => void;
}

/**
 * React hook wrapping {@link createPositionTracker}. Records a live GPS
 * trajectory tied to the component lifecycle — the watch is torn down on
 * unmount. Fully browser-side; no external service.
 *
 * @example
 * const { points, distanceKm, isTracking, start, stop } = usePositionTracker({
 *   minDistanceKm: 0.01,
 * });
 * return (
 *   <>
 *     <button onClick={isTracking ? stop : start}>{isTracking ? "Parar" : "Rastrear"}</button>
 *     <TrajectoryMap points={points} />
 *     <span>{distanceKm.toFixed(2)} km</span>
 *   </>
 * );
 */
export declare function usePositionTracker(options?: UsePositionTrackerOptions): UsePositionTrackerResult;

export declare interface UsePositionTrackerOptions extends Omit<CreatePositionTrackerOptions, "onUpdate" | "onStatusChange"> {
    /** Start tracking automatically on mount. Default: `false`. */
    autoStart?: boolean;
}

export declare interface UsePositionTrackerResult {
    /** Recorded trajectory (newest last). */
    points: readonly TrackPoint[];
    /** Most recent point, or `null` before the first fix. */
    lastPoint: TrackPoint | null;
    /** Total distance of the trajectory in kilometers. */
    distanceKm: number;
    /** Current tracker status. */
    status: TrackerStatus;
    /** True while `status === "tracking"`. */
    isTracking: boolean;
    /** Begin watching position. */
    start: () => void;
    /** Stop watching, keeping the trajectory. */
    stop: () => void;
    /** Stop and discard the trajectory. */
    clear: () => void;
}

/**
 * Return the value from the previous render. `undefined` on the first render.
 *
 * @example
 * const previousCount = usePrevious(count);
 * useEffect(() => {
 *     if (previousCount !== undefined && previousCount !== count) {
 *         analytics.track("count.changed", { from: previousCount, to: count });
 *     }
 * }, [count, previousCount]);
 */
export declare function usePrevious<T>(value: T): T | undefined;

/**
 * React hook around {@link WebPushClient}. Tracks subscription, permission and
 * loading state; exposes imperative `subscribe`/`unsubscribe` actions.
 *
 * The hook does NOT register the service worker — the host app must do that
 * (e.g. via `vite-plugin-pwa` or a manual `navigator.serviceWorker.register`).
 *
 * @example
 * const push = usePushSubscription({
 *     vapidPublicKey: import.meta.env.VITE_VAPID_PUBLIC_KEY,
 *     onSubscribe: (sub) => api.post("/webpush/subscribe", { body: sub }),
 *     onUnsubscribe: () => api.delete("/webpush/my"),
 * });
 */
export declare function usePushSubscription(config: WebPushClientConfig): UsePushSubscriptionResult;

export declare interface UsePushSubscriptionResult {
    /** True when the browser exposes the Push + Notification APIs. */
    supported: boolean;
    /** Current `Notification.permission` value, or `"unsupported"`. */
    permission: NotificationPermission | "unsupported";
    /** True when a subscription is active on this device. */
    subscribed: boolean;
    /** True while a subscribe/unsubscribe call is in-flight. */
    loading: boolean;
    /** Last error thrown by subscribe/unsubscribe, if any. */
    error: Error | null;
    subscribe: () => Promise<void>;
    unsubscribe: () => Promise<void>;
    /** Re-read the current subscription/permission state from the browser. */
    refresh: () => Promise<void>;
}

/**
 * Hold a key to transmit; release it to go silent again.
 *
 * Looks like `keydown`/`keyup` and is not, because three things go wrong:
 *
 * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the
 *    browser never sees the `keyup`, and the microphone stays open for as long as
 *    the person is looking at another window — exactly what push-to-talk exists
 *    to prevent.
 * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,
 *    and without the `repeat` check `onDown` fires on every one of them.
 * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an
 *    `<input>` means the space never reaches the message being written.
 *
 * Unmounting releases too, for the same reason `blur` does: the callback that
 * stops transmitting has to run even when the component holding it goes away
 * mid-press.
 *
 * The callbacks are read through a ref that a commit-time effect refreshes, so
 * passing inline arrows neither tears the listeners down on every render nor
 * writes to the ref during one — a render React discards would leave the ref
 * pointing at callbacks that never became the UI.
 *
 * @param options - See {@link UsePushToTalkOptions}.
 *
 * @example
 * usePushToTalk({
 *     code: "Space",
 *     onDown: () => setMicEnabled(true),
 *     onUp: () => setMicEnabled(false),
 * });
 */
export declare function usePushToTalk({ code, onDown, onUp, enabled, }: UsePushToTalkOptions): void;

/** Options for {@link usePushToTalk}. */
export declare interface UsePushToTalkOptions {
    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */
    code?: string;
    /** Called once when the key goes down. */
    onDown: () => void;
    /** Called when the key comes up, the window blurs, or the hook unmounts. */
    onUp: () => void;
    /**
     * Whether the binding is live. Default `true`.
     *
     * Turning it off releases first, so flipping a call from push-to-talk to an
     * open microphone while the key is held does not leave `onUp` unfired.
     */
    enabled?: boolean;
}

/**
 * FIFO queue with an optional `limit`. When more items are added than `limit`
 * allows, the surplus is kept in an internal overflow buffer and surfaces into
 * `queue` as room frees up (e.g. after `cleanQueue`). Loosely mirrors Mantine's
 * `useQueue` shape.
 *
 * @typeParam T - element type.
 * @param options - `initialValues` and `limit` (default limit `Infinity`).
 * @returns `{ queue, add, update, cleanQueue, size }`.
 */
export declare function useQueue<T>(options?: UseQueueOptions<T>): UseQueueResult<T>;

export declare interface UseQueueOptions<T> {
    initialValues?: T[];
    limit?: number;
}

export declare interface UseQueueResult<T> {
    /** Items currently held within the queue (up to `limit`). */
    queue: T[];
    /** Append items; overflow beyond `limit` is held back, not dropped. */
    add: (...items: T[]) => void;
    /** Replace the held queue via a mapper over the current held items. */
    update: (fn: (state: T[]) => T[]) => void;
    /** Drop all currently held (visible) items, keeping any overflow. */
    cleanQueue: () => void;
    /** Number of visible items in the queue. */
    size: number;
}

/**
 * Track size changes of a DOM element via `ResizeObserver`.
 * Returns `null` until the first measurement.
 */
export declare function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null;

export { useRouteError }

/**
 * Capture a screen, a window or a tab with `getDisplayMedia`.
 *
 * Three states decide whether this feels right, and two of them are easy to miss:
 *
 * - **The user dismissed the picker.** A rejection, but not a failure. It leaves
 *   `error` at `null` and the status back at `"idle"`, and calls `onCancelled`.
 * - **The user stopped the share from the browser's own bar.** Nothing in your UI was
 *   clicked and no promise rejects — the *only* signal is the video track's `ended`
 *   event, so the hook listens for it and clears the stream. Without that listener, an
 *   app shows "gravando" over a stream that is already dead.
 * - **The share is live.** `surface` says what was picked and `hasAudio` says whether
 *   audio actually came along, which is not what you asked for but what you got.
 *
 * The stream is owned here: `stop()` and unmount both release every track. A recorder
 * built on it (`useVideoRecorder`) deliberately does not, so stopping a recording
 * leaves the share running for the next take.
 *
 * @param options - See {@link UseScreenCaptureOptions}.
 * @returns The stream, its status, a classified error and `start`/`stop`.
 *
 * @example
 * const screen = useScreenCapture({ preferCurrentTab: true, onEnded: () => save() });
 * const rec = useVideoRecorder(screen.stream);
 * <button onClick={screen.start}>Compartilhar tela</button>
 */
export declare function useScreenCapture(options?: UseScreenCaptureOptions): UseScreenCaptureResult;

/** Options for {@link useScreenCapture}. */
export declare interface UseScreenCaptureOptions {
    /**
     * Capture the tab's audio too. Default `false`.
     *
     * Chromium only offers this for a **tab** — sharing a window or a whole screen
     * yields no audio track no matter what you ask for, and Safari has no display
     * audio at all. Ask for it and check what you got.
     */
    audio?: boolean;
    /**
     * Which surface the picker should offer first — `"browser"` is a tab.
     *
     * A hint, never a guarantee: the user can always pick something else, and Firefox
     * ignores it. Read `surface` afterwards to learn what actually happened.
     */
    displaySurface?: DisplaySurfaceHint;
    /**
     * Put *this* tab at the top of the picker. Default `false`.
     *
     * The right setting for "record what you are seeing right now" in a support flow.
     * Chromium only.
     */
    preferCurrentTab?: boolean;
    /** Offer this tab in the list at all. `"exclude"` prevents the hall-of-mirrors capture. */
    selfBrowserSurface?: "include" | "exclude";
    /** Let the user switch to a different surface mid-share, without a new prompt. */
    surfaceSwitching?: "include" | "exclude";
    /** Include the system audio when a whole screen is shared. Chromium, Windows only. */
    systemAudio?: "include" | "exclude";
    /** Escape hatch: full options, replacing everything above. */
    options?: DisplayMediaStreamOptions;
    /**
     * The user stopped the share from the browser's own bar.
     *
     * The single most important callback here — see the note on
     * {@link useScreenCapture}.
     */
    onEnded?: () => void;
    /**
     * The user dismissed the picker. **Not an error.**
     *
     * Receives the rejection so an app that needs to tell a dismissal from an OS-level
     * block (macOS screen-recording permission) can look at the message. Most should
     * simply return the UI to its previous state.
     */
    onCancelled?: (reason: unknown) => void;
}

/** Value returned by {@link useScreenCapture}. */
export declare interface UseScreenCaptureResult {
    status: ScreenCaptureStatus;
    /** The live stream, or `null`. Feed it to {@link useVideoRecorder} or a `<video>`. */
    stream: MediaStream | null;
    /** Classified error, or `null`. A cancelled picker leaves this `null`. */
    error: MediaAccessError | null;
    /** What the user actually picked, when the browser reports it. */
    surface: string | null;
    /** Whether the stream carries an audio track — ask, do not assume. */
    hasAudio: boolean;
    /** `false` when `getDisplayMedia` is missing (every browser on iOS, insecure pages). */
    supported: boolean;
    /** Open the picker. Must be called from a user gesture. */
    start: () => void;
    /** Stop sharing from the app side. Fires nothing — you asked for it. */
    stop: () => void;
}

/**
 * Lock `<body>` scroll while `active` is true. Restores the previous overflow
 * value on unmount. Safe to nest: stacks the restoration via a counter.
 */
export declare function useScrollLock(active: boolean): void;

/**
 * Track whether an element's content currently overflows its box.
 *
 * The use this exists for is keyboard access. A scroll container holding no
 * focusable content is unreachable by keyboard: the user can see there is more
 * content past the edge and has no way to get to it, because focus never lands
 * anywhere the arrow keys would scroll. Giving the container `tabIndex={0}`
 * fixes it — but doing that unconditionally puts a tab stop on every such
 * container on the page, including the ones whose content fits and have nothing
 * to scroll. The stop is only wanted while the overflow is real, which is what
 * this reports. (It is also what axe checks as `scrollable-region-focusable`.)
 *
 * Both the container and its content are observed: content can outgrow a box
 * whose own dimensions never change, and a box can shrink around content that
 * never changes. Watching one alone misses half the transitions.
 *
 * A one-pixel difference is ignored — that is layout rounding, not overflow.
 *
 * @param ref - The scroll container.
 * @param axis - Which axis to measure. Defaults to `"both"`.
 * @returns `true` while the content is larger than the box on that axis.
 *
 * @example
 * const ref = useRef<HTMLDivElement>(null);
 * const scrollable = useScrollOverflow(ref, "horizontal");
 *
 * <div
 *   ref={ref}
 *   tabIndex={scrollable ? 0 : undefined}
 *   role={scrollable ? "group" : undefined}
 *   aria-label={scrollable ? "Tabela rolável" : undefined}
 * >
 */
export declare function useScrollOverflow(ref: RefObject<HTMLElement | null>, axis?: ScrollOverflowAxis): boolean;

export { useSearchParams }

/**
 * Register a service worker and expose a user-driven update flow.
 *
 * Wraps {@link registerServiceWorker}: when a fresh worker finishes installing
 * while the page is still controlled by the old one, `updateAvailable` flips to
 * `true`. Call `applyUpdate` — typically from an "atualizar" toast — to tell the
 * waiting worker to activate and reload the page once it takes control.
 *
 * Skips cleanly when the runtime has no service-worker support (`registration`
 * stays `null`, `updateAvailable` stays `false`).
 *
 * @param options - Registration options (`url` required); `autoUpdate` should
 *   stay off so the reload is user-confirmed.
 * @returns The update state and `applyUpdate` action.
 *
 * @example
 * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: "/sw.js" });
 * return (
 *     <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />
 * );
 */
export declare function useServiceWorkerUpdate(options: UseServiceWorkerUpdateOptions): UseServiceWorkerUpdateResult;

/**
 * Options for {@link useServiceWorkerUpdate}. Mirrors the registration options
 * minus the callbacks the hook owns internally (`onUpdate`); `onReady` and
 * `onError` still pass through for host-side logging.
 *
 * Leave `autoUpdate` off (the default): this hook exists to hand the reload
 * decision to the user, so a silent auto-reload would defeat the prompt.
 */
export declare type UseServiceWorkerUpdateOptions = Omit<RegisterServiceWorkerOptions, "onUpdate">;

/** Reactive service-worker update state plus the apply action. */
export declare interface UseServiceWorkerUpdateResult {
    /** `true` once a new worker has installed and is waiting to activate. */
    updateAvailable: boolean;
    /**
     * Activate the waiting worker and reload the page once it takes control.
     * No-op when no update is waiting.
     */
    applyUpdate: () => void;
    /** The active registration, or `null` before it resolves / when unsupported. */
    registration: ServiceWorkerRegistration | null;
}

/**
 * Reactive `Set` wrapper. Mutating via `add` / `delete` / `clear` / `toggle`
 * triggers a re-render and yields a fresh `set` reference each time.
 *
 * @typeParam T - element type.
 * @param initial - initial values.
 * @returns `{ set, add, delete, clear, has, toggle, size }`.
 */
export declare function useSet<T>(initial?: Iterable<T>): UseSetResult<T>;

export declare interface UseSetResult<T> {
    set: ReadonlySet<T>;
    add: (value: T) => void;
    delete: (value: T) => void;
    clear: () => void;
    has: (value: T) => boolean;
    toggle: (value: T) => void;
    size: number;
}

/**
 * Component-scoped {@link createSfxPool}, with the lifecycle wired up.
 *
 * The pool is created once — through a lazy `useState` initializer, so no
 * element is allocated on a render that gets discarded — and disposed on
 * unmount, so its elements do not outlive the screen that owns them.
 *
 * `volume` is tracked separately: changing it calls `setVolume` on the existing
 * pool rather than rebuilding it, which would throw away every clip the user
 * has already downloaded — exactly the cost the pool exists to avoid.
 * `baseUrl`, `voices` and `maxSources` are read once, at creation. The options
 * object is forwarded whole rather than rebuilt field by field, so a field added
 * to {@link SfxPoolOptions} does not silently stop reaching the pool.
 *
 * @param options - Passed through to {@link createSfxPool}.
 * @returns A stable pool handle.
 *
 * @example
 * const sfx = useSfxPool({ volume: settings.sfxVolume / 100, baseUrl: import.meta.env.BASE_URL });
 *
 * useEffect(() => { sfx.preload(["sfx/select.mp3", "sfx/back.mp3"]); }, [sfx]);
 *
 * <button onClick={() => sfx.play("sfx/select.mp3")}>Confirmar</button>
 */
export declare function useSfxPool(options?: SfxPoolOptions): SfxPool;

/**
 * Drag-to-reorder for a list, with a **keyboard path of equal standing**.
 *
 * Pointer events cover mouse, touch and stylus through one code path, and pointer
 * capture keeps the drag alive when the pointer leaves the item. `Space` picks an
 * item up, the arrows move it, `Space`/`Enter` drops it and `Escape` cancels —
 * because a reorder that only works by dragging excludes keyboard users
 * completely, which is where most drag-and-drop implementations fail.
 *
 * The hook owns interaction only: it never mutates your data. `onReorder` fires
 * once per committed move and you apply it, typically with {@link moveItem}. That
 * keeps the list a controlled value and avoids a re-render per pointer frame.
 *
 * Hit-testing reads the live DOM rects of `[data-sortable-index]` children rather
 * than assuming a fixed row height, so it works with rows of different sizes.
 *
 * A change in `itemCount` cancels an in-flight drag: the list no longer has the
 * indices the drag was based on, and committing anyway would move the wrong row.
 *
 * Note for consumers: the indices and groups are exposed as **state** (so rendering
 * from them is reactive) and mirrored into refs only so the window-level `pointerup`
 * listener can read both synchronously. Because the handlers returned by
 * `getItemProps` close over those mirrors, the React Compiler `refs` rule reports
 * the *call site* — a component spreading these props may need a file-level
 * exemption, as `Kanban` documents.
 *
 * @example
 * ```tsx
 * const [items, setItems] = useState(["Alfa", "Bravo", "Charlie"]);
 * const sortable = useSortable({
 *   itemCount: items.length,
 *   onReorder: ({ from, to }) => setItems((current) => moveItem(current, from, to)),
 * });
 *
 * <ul {...sortable.getListProps()} aria-label="Prioridade" ref={sortable.setContainer}>
 *   {items.map((item, index) => (
 *     <li key={item} {...sortable.getItemProps(index)}>
 *       {item}
 *     </li>
 *   ))}
 * </ul>
 * ```
 */
export declare function useSortable(options: UseSortableOptions): UseSortableResult;

export declare interface UseSortableOptions {
    /**
     * How many items are in the sortable. Changing it cancels an in-flight drag.
     *
     * With groups, pass the **total** across groups: the number only has to change
     * whenever the indices the drag was based on stop being valid.
     */
    itemCount: number;
    /**
     * Called once, when a move is committed — on pointer release or on a keyboard
     * move. Never called mid-drag, so a controlled list re-renders once instead of
     * on every pointer frame.
     */
    onReorder: (target: SortableDropTarget) => void;
    /** Blocks all interaction. */
    disabled?: boolean;
    /**
     * Description announced for each item, so a screen reader user learns the
     * keyboard contract. Default is in English — override it to localize.
     */
    roleDescription?: string;
}

export declare interface UseSortableResult {
    /** Index being dragged, or `null` when idle. */
    activeIndex: number | null;
    /** Index the item would land on, or `null` when idle. */
    overIndex: number | null;
    /** Group the dragged item came from, when using groups. */
    activeGroup?: string;
    /** Group the item is currently over, when using groups. */
    overGroup?: string;
    /**
     * Spread on each item. Pass `group` when the sortable spans several lists (a
     * Kanban column id), so a drop can land in a different group.
     */
    getItemProps: (index: number, group?: string) => SortableItemProps;
    /**
     * Spread on an **empty** group's drop area, so an item can be moved into a
     * column that has no cards yet — hit-testing works off item rects, and a group
     * with no items has none.
     */
    getEmptyGroupProps: (group: string) => {
        "data-sortable-group": string;
        "data-sortable-empty": true;
    };
    /** Spread on the list container (`role="listbox"` + a label of your own). */
    getListProps: () => {
        role: "listbox";
        "aria-orientation": "vertical";
    };
    /** Abort the current drag without reordering. */
    cancel: () => void;
    /**
     * Callback ref for the element that contains the sortable items — hit-testing
     * searches inside it.
     *
     * Named `setContainer` rather than `ref` because it is a **callback**, not a ref
     * object: `ref={sortable.setContainer}`. The old name also read as a readable
     * ref to the React Compiler rules, which flagged every consumer.
     */
    setContainer: (node: HTMLElement | null) => void;
}

/**
 * Dictate into your app with the Web Speech API — no dependency, no API key.
 *
 * ## Recognition is not local
 *
 * **Chromium streams the captured audio to a Google server to transcribe it.** Nothing
 * about the API says so, there is no setting that changes it, and it happens on every
 * `start()`. Anything the user says while a session is open leaves the device. Do not
 * put this on a field that takes clinical notes, credentials, or a client's financial
 * detail without telling them first — and if the data cannot leave your infrastructure,
 * this API is the wrong tool and a self-hosted model is the right one.
 *
 * ## What the states mean
 *
 * `transcript` accumulates the phrases the engine has **settled** on; `interim` is the
 * guess it is still revising and is replaced wholesale on every event, so rendering
 * `transcript + interim` gives the live caption effect and rendering `transcript` alone
 * gives the committed text. `no-speech` and `aborted` come through `onError` but are
 * routine — a user who pressed the button and said nothing is not a failure to report.
 *
 * There is deliberately **no auto-restart** when the engine ends a session on silence.
 * A restart loop is how an app ends up holding the microphone indefinitely — and, in
 * Chromium, streaming audio to a third party indefinitely. Show that listening stopped
 * and let the user press again.
 *
 * @param options - See {@link UseSpeechRecognitionOptions}.
 * @returns Session state, the transcript and the controls.
 *
 * @example
 * const speech = useSpeechRecognition({ onFinal: (text) => setPrompt(text) });
 * <button onClick={speech.listening ? speech.stop : speech.start}>
 *     {speech.listening ? "Parar" : "Ditar"}
 * </button>
 * <p>{speech.transcript}{speech.interim}</p>
 */
export declare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionResult;

/** Options for {@link useSpeechRecognition}. */
export declare interface UseSpeechRecognitionOptions {
    /** BCP-47 tag. Default `"pt-BR"`. */
    lang?: string;
    /**
     * Keep listening after the first phrase settles. Default `false`.
     *
     * Even with this on, the engine ends the session by itself after a stretch of
     * silence — that is a server-side timeout, not a bug — so watch `listening` rather
     * than assuming the microphone stays open.
     */
    continuous?: boolean;
    /** Publish the running guess as it changes. Default `true`. */
    interimResults?: boolean;
    /** How many readings per phrase to ask for. Default 1. */
    maxAlternatives?: number;
    /** Every update, settled or not. */
    onResult?: (result: {
        transcript: string;
        isFinal: boolean;
    }) => void;
    /** Only the settled text of a phrase. The one to wire dictation to. */
    onFinal?: (transcript: string) => void;
    /** Classified failure. `no-speech` and `aborted` arrive here too — they are routine. */
    onError?: (error: SpeechError) => void;
    /** The session ended, for any reason. */
    onEnd?: () => void;
    /** Build the recogniser yourself — another engine, or a stub in a test. */
    factory?: () => SpeechRecognitionLike;
}

/** Value returned by {@link useSpeechRecognition}. */
export declare interface UseSpeechRecognitionResult {
    /** `false` in Firefox and in every browser that is not Chromium-based. */
    supported: boolean;
    /** Whether a session is open right now. */
    listening: boolean;
    /** Everything settled so far in this session. Cleared by `reset()`. */
    transcript: string;
    /** The running guess. Replaced on every event, empty once the phrase settles. */
    interim: string;
    /** Classified error, or `null`. */
    error: SpeechError | null;
    /** Open a session. No-op while already listening. */
    start: () => void;
    /** Close the session, keeping what was recognised. */
    stop: () => void;
    /** Close the session and throw the pending phrase away. */
    abort: () => void;
    /** Clear `transcript`, `interim` and `error`. Does not stop a session. */
    reset: () => void;
}

/**
 * Returns a stable function reference that always invokes the latest
 * `callback` argument. Use to break dependency cycles in effects without
 * triggering re-runs when the callback identity changes.
 *
 * Built on {@link useLatestRef}, which owns the render-time assignment and the
 * reason it is not an effect: an effect would satisfy the React Compiler rules
 * but open a one-commit staleness window. What this adds is the callable with a
 * stable identity, so callers do not reach through `.current`. Prefer React's
 * `useEffectEvent` once it ships as stable.
 *
 * The ref is listed as a dependency because it is one — a stable object across
 * renders, so the returned identity never changes. Listing it is what lets the
 * exhaustive-deps rule verify that instead of taking an empty array on trust.
 */
export declare function useStableCallback<TArgs extends unknown[], TReturn>(callback: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;

/**
 * Track the origin's storage usage, quota and persistence flag, refreshing on
 * demand. Pair with {@link requestPersistentStorage} to surface a "usando X de
 * Y MB" meter and a "tornar armazenamento permanente" action.
 *
 * @param options - `pollMs` re-reads the estimate on an interval (`0` = off,
 *   the default).
 * @returns The reactive storage state and actions.
 *
 * @example
 * const { usage, quota, ratio, persisted, requestPersist } = useStorageEstimate();
 * return <Meter value={ratio ?? 0} onClick={requestPersist} />;
 */
export declare function useStorageEstimate(options?: {
    pollMs?: number;
}): UseStorageEstimateResult;

/** Reactive storage-quota state exposed by {@link useStorageEstimate}. */
export declare interface UseStorageEstimateResult extends StorageEstimate_2 {
    /** `true` when the Storage API is available. */
    supported: boolean;
    /** `usage / quota` in `[0, 1]`, or `null` when either value is unknown. */
    ratio: number | null;
    /** Whether storage is persisted, `null` before the first read / unsupported. */
    persisted: boolean | null;
    /** `true` during the initial read or a `refresh`. */
    loading: boolean;
    /** Re-read usage/quota and the persisted flag from the browser. */
    refresh: () => Promise<void>;
    /** Request persistent storage; refreshes state and returns the outcome. */
    requestPersist: () => Promise<boolean>;
}

/**
 * Subscribe to an {@link OfflineSync} engine and return a display-only
 * {@link SyncStatus}. A thin read-only companion to {@link useOfflineSync},
 * intended to feed a `<SyncStatusBadge>` without exposing flush actions.
 *
 * @typeParam TPayload - Record snapshot carried by outbox entries.
 * @param sync - The engine returned by `createOfflineSync`.
 * @returns The compact status snapshot.
 */
export declare function useSyncStatus<TPayload>(sync: OfflineSync<TPayload>): SyncStatus;

/**
 * Access the active telemetry adapter. Returns `null` when no provider is
 * mounted (calls are silently dropped — useful for unit tests).
 */
export declare function useTelemetry(): TelemetryAdapter | null;

/**
 * Read and mutate the current theme. Must be used inside a {@link ThemeProvider}.
 */
export declare function useTheme(): ThemeContextValue;

/**
 * Return a value that updates at most once every `delay` ms. Complements
 * `useDebounce` — throttle emits on the leading edge and again after the
 * interval; debounce only emits after a period of stillness.
 *
 * @example
 * const throttledScroll = useThrottle(scrollY, 100);
 */
export declare function useThrottle<T>(value: T, delay: number): T;

/**
 * Run a callback after `delay` ms. Pass `null` to disable. Resets when
 * `delay` changes; the callback ref always points at the latest closure.
 *
 * @example
 * useTimeout(() => setShow(false), show ? 3000 : null);
 */
export declare function useTimeout(fn: () => void, delay: number | null): void;

/**
 * Access the toast API. Must be used inside a {@link ToastProvider}.
 *
 * @returns Methods to show and dismiss toasts.
 */
export declare function useToast(): ToastApi;

/**
 * Boolean state with `toggle`/`setTrue`/`setFalse` helpers.
 *
 * @param initial - initial value (default `false`).
 * @returns Tuple `[value, helpers]`.
 */
export declare function useToggle(initial?: boolean): [boolean, ToggleHelpers];

/**
 * Drive the camera's LED torch on the video track of a stream.
 *
 * The lamp is not a device you can open — it is a **constraint on a live video
 * track**, so there is nothing to control until a camera stream exists, and it
 * disappears when that stream is released. That is also why `supported` can only be
 * answered after the track is live: the same code is `true` on an Android rear camera
 * and `false` on the front one of the same phone.
 *
 * Capability detection prefers `getCapabilities()` and falls back to
 * `getSettings()`, because Firefox implements neither the torch nor
 * `getCapabilities()` and Safari reports the setting without the capability. When
 * neither mentions `torch`, the hook reports `supported: false` instead of offering a
 * button that silently does nothing.
 *
 * @param stream - A live camera stream, or `null` before permission lands.
 * @returns Whether a lamp exists, its state, and setters.
 *
 * @example
 * const camera = useBarcodeScanner();
 * {camera.torch.supported && (
 *     <button onClick={() => void camera.torch.toggle()}>Lanterna</button>
 * )}
 */
export declare function useTorch(stream: MediaStream | null): UseTorchResult;

/** Value returned by {@link useTorch}. */
export declare interface UseTorchResult {
    /** Whether this track has a controllable lamp. `false` on every desktop webcam. */
    supported: boolean;
    /** Whether the lamp is on, as far as this hook knows. */
    on: boolean;
    /**
     * Turn the lamp on or off.
     *
     * @param next - `true` to light it up.
     * @returns `false` when the track refused — treat that as "no torch".
     */
    set: (next: boolean) => Promise<boolean>;
    /** Flip it. Same return contract as {@link UseTorchResult.set}. */
    toggle: () => Promise<boolean>;
}

/**
 * Shortcut for components that only need the `t` function — avoids destructuring.
 */
export declare function useTranslate(): I18nContextValue["t"];

/**
 * Reveals a string one character at a time.
 *
 * Changing `text` restarts the reveal. The reset happens during render rather
 * than in an effect, so the new string never flashes in full for one frame
 * before the animation takes over.
 *
 * Always give the reader a way out: an animation that cannot be skipped is a
 * tax on anyone re-reading or moving fast, which is what `skip` is for.
 *
 * How far the reveal got is derived rather than stored: a `speedMs` of `0` reads
 * as "all of it" without a state write, and `useInterval` pausing on a `null`
 * delay is what stops the timer at the end. Both used to need an effect that
 * cleared its own interval from inside a state updater.
 *
 * @param text - The full string to reveal. Nullish is treated as empty.
 * @param speedMs - Delay between characters. `0` or less renders instantly,
 *   which is the hook-safe way to honour `prefers-reduced-motion`.
 * @returns The revealed prefix, whether it finished, and a `skip` action.
 *
 * @example
 * const reduced = useMediaQuery("(prefers-reduced-motion: reduce)");
 * const { displayedText, isComplete, skip } = useTypewriter(line, reduced ? 0 : 30);
 *
 * return <p onClick={skip}>{displayedText}{isComplete ? "" : "▌"}</p>;
 */
export declare function useTypewriter(text: string, speedMs: number): UseTypewriterResult;

/** State returned by {@link useTypewriter}. */
export declare interface UseTypewriterResult {
    /** The prefix of `text` revealed so far. */
    displayedText: string;
    /** `true` once the whole string is on screen. */
    isComplete: boolean;
    /** Reveal the rest immediately — wire it to a tap or a key press. */
    skip: () => void;
}

/**
 * Update a record and invalidate both the list and the single-record caches.
 *
 * @param resource - The resource name.
 * @param options - Extra TanStack Mutation options.
 * @returns The mutation; `mutate({ id, data })` updates the record.
 */
export declare function useUpdate<T>(resource: string, options?: UseUpdateOptions<T>): UseMutationResult<T, Error, UpdateVariables>;

/** Options for the update mutation (mutationFn + onSuccess are provided). */
export declare type UseUpdateOptions<T> = Omit<UseMutationOptions<T, Error, UpdateVariables>, "mutationFn">;

/**
 * React hook for the public ViaCEP service (`viacep.com.br`). No backend
 * required. Returns address fields when the CEP exists, or sets `error` for
 * invalid CEPs.
 */
export declare function useViaCEP(): UseViaCEPResult;

export declare interface UseViaCEPResult {
    loading: boolean;
    error: string | null;
    data: ViaCEPResult | null;
    /** Fetch the given CEP (8 digits or masked). Sets `data`/`error`. Returns the result. */
    lookup: (cep: string) => Promise<ViaCEPResult | null>;
    reset: () => void;
}

/**
 * Record a video stream — from {@link useScreenCapture}, from a camera, or from a
 * canvas.
 *
 * Pass the stream in; the hook stays `ready: false` until there is one, so a page can
 * render the whole recorder UI before the user has picked a screen and simply have it
 * disabled.
 *
 * There is no level meter here, which is the one real difference from
 * `useAudioRecorder`: metering a screen share means opening an `AudioContext` on a
 * stream that usually has no audio track at all, and browsers cap the number of live
 * contexts. If you are recording a camera **and** want a level, run
 * `createLevelMeter` on the same stream yourself.
 *
 * The clock is published every `tickMs` (default 250 ms) rather than per frame: a
 * video recording UI shows `0:07`, and a hook that re-rendered its parent 60 times a
 * second to move a one-second counter would be the most expensive thing on the page.
 *
 * @param stream - The stream to record, or `null` while the picker is open.
 * @param options - See {@link UseVideoRecorderOptions}.
 *
 * @example
 * const screen = useScreenCapture();
 * const rec = useVideoRecorder(screen.stream, { maxDurationMs: 120_000 });
 * <button disabled={!rec.ready} onClick={rec.start}>Gravar tela</button>
 */
export declare function useVideoRecorder(stream: MediaStream | null, options?: UseVideoRecorderOptions): UseVideoRecorderResult;

/** Options for {@link useVideoRecorder}. */
export declare interface UseVideoRecorderOptions extends VideoRecorderOptions {
    /**
     * Stop automatically after this many milliseconds.
     *
     * Worth setting on anything user-facing, and more so than for audio: a minute of
     * 1080p at 2.5 Mbps is roughly 19 MB, so a recording left running by accident
     * fills memory an order of magnitude faster than a voice note does.
     */
    maxDurationMs?: number;
    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */
    onRecorded?: (recording: VideoRecording) => void;
    /** How often the clock is published, in ms. Default 250. */
    tickMs?: number;
}

/** Value returned by {@link useVideoRecorder}. */
export declare interface UseVideoRecorderResult {
    status: MediaRecorderStatus;
    /** Recorded length so far, excluding paused time. */
    durationMs: number;
    /** The finished recording, or `null` before the first `stop()`. */
    recording: VideoRecording | null;
    /** Recorder-level error (encoder failure, share revoked mid-recording). */
    error: unknown;
    /** `false` when there is no stream yet, or the browser cannot record video. */
    ready: boolean;
    start: () => void;
    pause: () => void;
    resume: () => void;
    /** Stop and resolve with the recording. Also published on `recording`. */
    stop: () => Promise<VideoRecording | null>;
    /** Stop and throw the video away. */
    cancel: () => void;
}

export { useWatch }

/**
 * React hook around {@link createWebSocket}. Manages the connection lifecycle
 * for the host component and tears it down on unmount.
 *
 * Every callback is read through a ref, so `onOpen` / `onMessage` / `onClose` /
 * `onError` / `onReconnecting` / `onReconnected` / `onLost` always run the
 * latest closure — an inline arrow function is fine and never reopens the
 * socket. Connection-shaping options (`protocols`, `maxRetries`,
 * `initialBackoff`, `maxBackoff`, `jitter`, `handshakeTimeout`,
 * `silenceTimeout`, `waitForOnline`, `pingInterval`, `queueWhileClosed`) are
 * baked into the connection, so changing one reopens it with the new value
 * rather than being silently ignored.
 *
 * `schema` is read when the socket opens, so declare it outside the component
 * (or memoize it): a schema built inline is a new object on every render, and
 * the one in force is whichever existed at the last open.
 *
 * @param url - Full ws:// or wss:// URL.
 * @param options - Connection configuration and callbacks.
 * @returns Status, last frame, and the `send` / `reconnect` controls.
 */
export declare function useWebSocket<T = unknown>(url: string, options?: UseWebSocketOptions<T>): UseWebSocketResult<T>;

export declare interface UseWebSocketOptions<T> extends Omit<CreateWebSocketOptions<T>, "onStatusChange"> {
    /** When false, the socket is not opened. Default: true. */
    enabled?: boolean;
}

export declare interface UseWebSocketResult<T> {
    status: WebSocketStatus;
    /**
     * Last decoded frame received.
     *
     * A snapshot, not a stream: two frames arriving in the same tick collapse
     * into a single render and only the later one is ever visible. One server
     * action often emits several frames in a row, so anything that must see
     * every message has to use `onMessage`, which fires once per frame. Read
     * `lastMessage` for "what is the current state" rendering only.
     */
    lastMessage: WebSocketMessage<T> | null;
    /** Send a payload through the active connection. Returns false when not open. */
    send: (payload: string | Blob | BufferSource) => boolean;
    /** Force a reconnect, resetting the retry counter. */
    reconnect: () => void;
    /**
     * Change the silence watchdog at runtime, in ms. `0` disables it.
     *
     * For a server that announces its own heartbeat interval in the first frame,
     * so the tolerated silence is not hard-coded on both ends.
     */
    setSilenceTimeout: (ms: number) => void;
}

/**
 * Reactive window dimensions. SSR-safe — returns `{ width: 0, height: 0 }`
 * until the first client render.
 *
 * @example
 * const { width, height } = useWindowSize();
 * const columns = width < 640 ? 1 : width < 1024 ? 2 : 3;
 */
export declare function useWindowSize(): WindowSize;

/**
 * Convenience wrapper around `react-hook-form`'s `useForm` that wires a zod
 * resolver and infers the form's value type from the schema.
 *
 * Both `react-hook-form` and `zod` are optional peer dependencies — install
 * them when your app uses forms.
 *
 * @example
 * const form = useZodForm(loginSchema, { defaultValues: { email: "" } });
 * form.register("email");
 */
export declare function useZodForm<TSchema extends z.ZodTypeAny, TValues extends FieldValues = z.infer<TSchema> & FieldValues>(schema: TSchema, options?: Omit<UseFormProps<TValues>, "resolver">): UseFormReturn<TValues>;

/**
 * Validate a Brazilian CNPJ using the standard check-digit algorithm.
 * Accepts masked or raw input; rejects all-equal digits.
 */
export declare function validateCNPJ(value: string): boolean;

/**
 * Validate a Brazilian CPF using the standard check-digit algorithm.
 * Accepts masked or raw input; rejects all-equal digits ("111.111.111-11").
 */
export declare function validateCPF(value: string): boolean;

/**
 * Validate `values` against a zod schema and return a per-field error map
 * compatible with most form libraries.
 *
 * Field paths follow zod's `issue.path.join(".")` convention — nested fields
 * become `"address.city"`, array entries `"items.0.name"`. The first issue
 * per path wins (subsequent ones are dropped to keep error UIs tidy).
 *
 * @param schema - zod schema describing the form shape.
 * @param values - Raw form values (typed as `unknown`).
 * @returns Either `{ success: true, data, errors: {} }` or `{ success: false, errors }`.
 */
export declare function validateForm<TSchema extends z.ZodTypeAny>(schema: TSchema, values: unknown): ValidateFormResult<z.infer<TSchema>>;

export declare interface ValidateFormFailure {
    success: false;
    errors: Record<string, string>;
}

export declare type ValidateFormResult<T> = ValidateFormSuccess<T> | ValidateFormFailure;

export declare interface ValidateFormSuccess<T> {
    success: true;
    data: T;
    errors: Record<string, string>;
}

export declare interface ViaCEPResult {
    cep: string;
    logradouro: string;
    complemento: string;
    bairro: string;
    localidade: string;
    uf: string;
    ibge?: string;
    gia?: string;
    ddd?: string;
    siafi?: string;
}

/**
 * Playback transport for one video: play/pause, seek, volume, speed, fullscreen.
 *
 * Built on a real `<video>` element, and deliberately **not** an overlay: the
 * controls sit in a bar under the frame rather than on top of it. Controls drawn
 * over video have to earn their contrast against arbitrary pixels, which no
 * `--tempest-*` token can promise — every text token in this SDK is resolved
 * against a known surface, and the two contrast defects this repo shipped were
 * both a text token used over a surface it was never checked against. A bar with
 * its own surface inherits the theme and is legible by construction.
 *
 * The seek bar, the volume slider and the speed picker are bare `<input>` and
 * `<select>` elements rather than the SDK's `Slider` and `Select`: those are form
 * fields, with a label row and a value badge, and a transport wants neither. The
 * native elements keep the keyboard and screen-reader behaviour that matters here
 * for free.
 *
 * @example
 * const rec = useVideoRecorder(screen.stream);
 * {rec.recording && (
 *     <VideoPlayer src={rec.recording.blob} durationMs={rec.recording.durationMs} />
 * )}
 */
export declare function VideoPlayer({ src, durationMs, poster, tracks, aspectRatio, rate, rates, onRateChange, shiftPitch, fullscreen, autoPlay, loop, muted, locale, actions, onEnded, onError, disabled, className, ...rest }: VideoPlayerProps): JSX.Element;

export declare interface VideoPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_2> {
    /**
     * What to play — a URL, or a `Blob`/`File` straight from a recorder.
     *
     * A `Blob` is wrapped in an object URL that is revoked when it changes or the
     * component unmounts, so a session that records twenty clips does not leak
     * twenty URLs for the lifetime of the tab.
     */
    src: string | Blob | null;
    /**
     * Known length in milliseconds.
     *
     * Pass it whenever you have it — a recording from `useVideoRecorder` always
     * does. Without it the element's own `duration` is used, and a fresh
     * `MediaRecorder` blob may report `Infinity` until it is probed for one.
     */
    durationMs?: number;
    /** Still shown before playback. Pair it with `captureFrame` from `/imaging`. */
    poster?: string;
    /** Caption and subtitle files. */
    tracks?: readonly VideoTextTrack[];
    /** Frame shape while the video has no intrinsic size yet. Default `16 / 9`. */
    aspectRatio?: number;
    /**
     * Playback rate. Controlled when passed with `onRateChange`.
     *
     * Written to both `playbackRate` and `defaultPlaybackRate`, because the
     * element resets the first to the second when a source loads — a player that
     * only writes `playbackRate` silently drops back to 1× on every clip change.
     */
    rate?: number;
    /** Presets the control offers. `[]` hides it. Default {@link DEFAULT_PLAYBACK_RATES}. */
    rates?: readonly number[];
    /** Called with the rate the viewer picked. */
    onRateChange?: (rate: number) => void;
    /** Let the pitch rise with the rate (`preservesPitch = false`). Default `false`. */
    shiftPitch?: boolean;
    /** Offer a fullscreen button where the browser supports it. Default `true`. */
    fullscreen?: boolean;
    /** Start playing as soon as `src` is ready. Default `false`. */
    autoPlay?: boolean;
    /** Loop. Default `false`. */
    loop?: boolean;
    /** Start muted. Autoplay without a gesture needs this. Default `false`. */
    muted?: boolean;
    /** Locale for the labels. Default `"pt-BR"`. */
    locale?: "pt-BR" | "en";
    /** Rendered at the end of the control row — a download button, a delete button. */
    actions?: ReactNode;
    /** Fired when playback reaches the end. */
    onEnded?: () => void;
    /** Fired when the element reports a decode/network error. */
    onError?: (error: unknown) => void;
    /** No `src` yet, or playback not allowed. */
    disabled?: boolean;
}

/** Imperative video recorder. Same shape as the audio one. */
export declare type VideoRecorderHandle = MediaRecorderHandle;

/** Options for {@link createVideoRecorder}. */
export declare interface VideoRecorderOptions {
    /**
     * Force a container. Throws when the browser cannot produce it.
     *
     * Leave it out. The default negotiates from {@link VIDEO_MIME_CANDIDATES}, which
     * is the only way one call site works on both Chromium and Safari.
     */
    mimeType?: string;
    /**
     * Target video bitrate.
     *
     * The browser's default is conservative and a screen recording of text at
     * 1080p looks smeared under it. 2_500_000 is a good floor for a UI capture,
     * 8_000_000 for full-motion camera video.
     */
    videoBitsPerSecond?: number;
    /** Target audio bitrate, when the stream carries audio. 64000–128000 is plenty. */
    audioBitsPerSecond?: number;
    /**
     * Emit a chunk every N ms through `onChunk`, for streaming upload.
     *
     * Worth setting for video far sooner than for audio: a minute of 1080p at
     * 2.5 Mbps is roughly 19 MB sitting in memory.
     */
    timesliceMs?: number;
    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
    onChunk?: (chunk: Blob) => void;
    /** Recorder-level failure (screen share revoked mid-recording, encoder error). */
    onError?: (error: unknown) => void;
}

/**
 * A finished video recording.
 *
 * Structurally the same three fields as an audio one — there is nothing
 * video-specific to add, and inventing a `width`/`height` here would be a lie: the
 * browser negotiates the frame size with the device and can change it mid-recording.
 * Read it from the track's `getSettings()` if you need it.
 */
export declare type VideoRecording = MediaRecording;

/** One caption or subtitle file, rendered as a `<track>`. */
export declare interface VideoTextTrack {
    /** URL of the WebVTT file. */
    src: string;
    /** BCP 47 language tag, e.g. `"pt-BR"`. */
    srcLang: string;
    /** Name shown in the browser's own track menu. */
    label: string;
    /** Track kind. Default `"captions"`. */
    kind?: "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
    /** Whether this track is on unless the viewer picks another. */
    default?: boolean;
}

/**
 * Fixed-height virtual list. Renders only the visible window plus a small
 * overscan buffer. Suitable for lists of thousands of identical rows.
 *
 * For variable heights, use `react-window`/`@tanstack/react-virtual` — those
 * solve a more general problem at the cost of extra setup.
 */
export declare function VirtualList<T>({ items, itemHeight, renderItem, height, overscan, getKey, className, style, label, }: VirtualListProps<T>): JSX.Element;

export declare interface VirtualListProps<T> {
    items: T[];
    /** Fixed pixel height for each row. */
    itemHeight: number;
    /** Render a single row. */
    renderItem: (item: T, index: number) => ReactNode;
    /** Container height (px) or any CSS length. */
    height: number | string;
    /** Number of items rendered above/below the viewport. Default: 4. */
    overscan?: number;
    /** Stable key derivation; defaults to the index. */
    getKey?: (item: T, index: number) => string | number;
    className?: string;
    style?: CSSProperties;
    /**
     * Accessible name for the list. Worth setting when the list scrolls: it
     * then carries a tab stop of its own, and a focus stop that announces
     * nothing is worse than no focus stop.
     */
    label?: string;
}

/**
 * A table that stays responsive at 10k+ rows by rendering only the visible window.
 *
 * `Table` renders every row it is given and `DataTable` paginates to keep that
 * count small; neither has an answer for "show me all 40 000 rows in one
 * scrollable grid". This does, at the cost of one constraint: **`rowHeight` must
 * be uniform**, since mapping a scroll offset to a row index is what makes the
 * window computable without measuring anything.
 *
 * It stays a real `<table>`. The window is produced by two spacer rows — one
 * above the visible slice, one below — instead of absolutely positioning rows.
 * That is deliberate: `position: absolute` on `<tr>` collapses table layout, so
 * every column width would have to be computed by hand, and the element would
 * stop being a table for assistive technology. With spacer rows the browser keeps
 * doing column layout and screen readers keep announcing a grid.
 *
 * Because only a slice is in the DOM, `aria-rowcount` on the table and
 * `aria-rowindex` on each row carry the real numbers — without them a screen
 * reader announces "row 3 of 20" while the user is on row 5003 of 40 000.
 *
 * @example
 * <VirtualTable
 *     data={rows}
 *     columns={[
 *         { key: "id", header: "#", width: 80, sortable: true },
 *         { key: "name", header: "Nome", width: 240, sortable: true },
 *         { key: "total", header: "Total", align: "right", width: 120, sortable: true },
 *     ]}
 *     rowHeight={40}
 *     height={480}
 *     rowKey={(row) => row.id}
 * />
 */
export declare function VirtualTable<T>({ data, columns, rowHeight, height, overscan, rowKey, initialSort, onRowClick, emptyMessage, caption, scrollToIndex, className, ...rest }: VirtualTableProps<T>): JSX.Element;

export declare interface VirtualTableColumn<T> {
    /** Property of the row this column reads from. Doubles as the cell key. */
    key: keyof T;
    /** Column heading. */
    header: ReactNode;
    /** Custom cell renderer. Defaults to `row[key]`. */
    render?: (row: T, index: number) => ReactNode;
    /** Enable click-to-sort on this column's header. */
    sortable?: boolean;
    /** Text alignment. */
    align?: TableAlign;
    /**
     * Column width. Recommended for every column: virtualized rows enter and
     * leave the DOM as you scroll, so letting the browser auto-size columns from
     * whatever is currently rendered makes them jump mid-scroll.
     */
    width?: string | number;
}

export declare interface VirtualTableProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
    /** Full dataset. Every row is accounted for; only the visible ones render. */
    data: T[];
    /** Column definitions. */
    columns: VirtualTableColumn<T>[];
    /**
     * Row height in px. Must be uniform and must match what the CSS produces,
     * because it is what maps scroll offset to row index.
     */
    rowHeight: number;
    /** Height of the scroll viewport — a number of px or any CSS length. */
    height: number | string;
    /** Rows rendered above and below the viewport. Default `4`. */
    overscan?: number;
    /** Stable key extractor. Defaults to the row's index in `data`. */
    rowKey?: (row: T, index: number) => string | number;
    /** Sort applied before any header interaction. */
    initialSort?: VirtualTableSort<T>;
    /** Called when a row is activated by click, `Enter` or `Space`. */
    onRowClick?: (row: T, index: number) => void;
    /** Content shown when `data` is empty. */
    emptyMessage?: ReactNode;
    /** Accessible name for the table. Rendered as a visually hidden `<caption>`. */
    caption?: ReactNode;
    /** Scroll this row into view whenever it changes. */
    scrollToIndex?: number;
}

export declare interface VirtualTableSort<T> {
    key: keyof T;
    direction: VirtualTableSortDirection;
}

export declare type VirtualTableSortDirection = "asc" | "desc";

/**
 * Turns to render, in order.
 *
 * System turns are dropped unless asked for: a system prompt is configuration, and
 * an app that shows it by default leaks its own instructions into the transcript.
 *
 * @param params.messages - The thread, oldest first. Never reordered.
 * @param params.showSystem - Keep `"system"` turns. Default `false`.
 * @returns The visible turns, in the given order.
 */
export declare function visibleTurns({ messages, showSystem, }: {
    messages: readonly AIChatMessage[];
    showSystem?: boolean;
}): AIChatMessage[];

/**
 * Render content that is hidden visually but remains available to screen
 * readers — the standard "sr-only" pattern. Useful for accessible labels on
 * icon-only controls.
 *
 * @example
 * <button><Icon /><VisuallyHidden>Close</VisuallyHidden></button>
 */
export declare function VisuallyHidden({ as, className, children, ...props }: VisuallyHiddenProps): DOMElement<{
    defaultChecked?: boolean | undefined;
    defaultValue?: string | number | readonly string[] | undefined;
    suppressContentEditableWarning?: boolean | undefined;
    suppressHydrationWarning?: boolean | undefined;
    accessKey?: string | undefined;
    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
    autoFocus?: boolean | undefined;
    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
    contextMenu?: string | undefined;
    dir?: string | undefined;
    draggable?: (boolean | "true" | "false") | undefined;
    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
    hidden?: boolean | undefined;
    id?: string | undefined;
    lang?: string | undefined;
    nonce?: string | undefined;
    slot?: string | undefined;
    spellCheck?: (boolean | "true" | "false") | undefined;
    style?: CSSProperties | undefined;
    tabIndex?: number | undefined;
    title?: string | undefined;
    translate?: "yes" | "no" | undefined;
    radioGroup?: string | undefined;
    role?: AriaRole | undefined;
    about?: string | undefined;
    content?: string | undefined;
    datatype?: string | undefined;
    inlist?: any;
    prefix?: string | undefined;
    property?: string | undefined;
    rel?: string | undefined;
    resource?: string | undefined;
    rev?: string | undefined;
    typeof?: string | undefined;
    vocab?: string | undefined;
    autoCorrect?: string | undefined;
    autoSave?: string | undefined;
    color?: string | undefined;
    itemProp?: string | undefined;
    itemScope?: boolean | undefined;
    itemType?: string | undefined;
    itemID?: string | undefined;
    itemRef?: string | undefined;
    results?: number | undefined;
    security?: string | undefined;
    unselectable?: "on" | "off" | undefined;
    popover?: "" | "auto" | "manual" | "hint" | undefined;
    popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
    popoverTarget?: string | undefined;
    inert?: boolean | undefined;
    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
    is?: string | undefined;
    exportparts?: string | undefined;
    part?: string | undefined;
    "aria-activedescendant"?: string | undefined;
    "aria-atomic"?: (boolean | "true" | "false") | undefined;
    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
    "aria-braillelabel"?: string | undefined;
    "aria-brailleroledescription"?: string | undefined;
    "aria-busy"?: (boolean | "true" | "false") | undefined;
    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
    "aria-colcount"?: number | undefined;
    "aria-colindex"?: number | undefined;
    "aria-colindextext"?: string | undefined;
    "aria-colspan"?: number | undefined;
    "aria-controls"?: string | undefined;
    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
    "aria-describedby"?: string | undefined;
    "aria-description"?: string | undefined;
    "aria-details"?: string | undefined;
    "aria-disabled"?: (boolean | "true" | "false") | undefined;
    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
    "aria-errormessage"?: string | undefined;
    "aria-expanded"?: (boolean | "true" | "false") | undefined;
    "aria-flowto"?: string | undefined;
    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
    "aria-hidden"?: (boolean | "true" | "false") | undefined;
    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
    "aria-keyshortcuts"?: string | undefined;
    "aria-label"?: string | undefined;
    "aria-labelledby"?: string | undefined;
    "aria-level"?: number | undefined;
    "aria-live"?: "off" | "assertive" | "polite" | undefined;
    "aria-modal"?: (boolean | "true" | "false") | undefined;
    "aria-multiline"?: (boolean | "true" | "false") | undefined;
    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
    "aria-orientation"?: "horizontal" | "vertical" | undefined;
    "aria-owns"?: string | undefined;
    "aria-placeholder"?: string | undefined;
    "aria-posinset"?: number | undefined;
    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
    "aria-readonly"?: (boolean | "true" | "false") | undefined;
    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
    "aria-required"?: (boolean | "true" | "false") | undefined;
    "aria-roledescription"?: string | undefined;
    "aria-rowcount"?: number | undefined;
    "aria-rowindex"?: number | undefined;
    "aria-rowindextext"?: string | undefined;
    "aria-rowspan"?: number | undefined;
    "aria-selected"?: (boolean | "true" | "false") | undefined;
    "aria-setsize"?: number | undefined;
    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
    "aria-valuemax"?: number | undefined;
    "aria-valuemin"?: number | undefined;
    "aria-valuenow"?: number | undefined;
    "aria-valuetext"?: string | undefined;
    dangerouslySetInnerHTML?: {
        __html: string | TrustedHTML;
    } | undefined;
    onCopy?: ClipboardEventHandler<HTMLElement> | undefined;
    onCopyCapture?: ClipboardEventHandler<HTMLElement> | undefined;
    onCut?: ClipboardEventHandler<HTMLElement> | undefined;
    onCutCapture?: ClipboardEventHandler<HTMLElement> | undefined;
    onPaste?: ClipboardEventHandler<HTMLElement> | undefined;
    onPasteCapture?: ClipboardEventHandler<HTMLElement> | undefined;
    onCompositionEnd?: CompositionEventHandler<HTMLElement> | undefined;
    onCompositionEndCapture?: CompositionEventHandler<HTMLElement> | undefined;
    onCompositionStart?: CompositionEventHandler<HTMLElement> | undefined;
    onCompositionStartCapture?: CompositionEventHandler<HTMLElement> | undefined;
    onCompositionUpdate?: CompositionEventHandler<HTMLElement> | undefined;
    onCompositionUpdateCapture?: CompositionEventHandler<HTMLElement> | undefined;
    onFocus?: FocusEventHandler<HTMLElement> | undefined;
    onFocusCapture?: FocusEventHandler<HTMLElement> | undefined;
    onBlur?: FocusEventHandler<HTMLElement> | undefined;
    onBlurCapture?: FocusEventHandler<HTMLElement> | undefined;
    onChange?: ChangeEventHandler<HTMLElement, Element> | undefined;
    onChangeCapture?: ChangeEventHandler<HTMLElement, Element> | undefined;
    onBeforeInput?: InputEventHandler<HTMLElement> | undefined;
    onBeforeInputCapture?: InputEventHandler<HTMLElement> | undefined;
    onInput?: InputEventHandler<HTMLElement> | undefined;
    onInputCapture?: InputEventHandler<HTMLElement> | undefined;
    onReset?: ReactEventHandler<HTMLElement> | undefined;
    onResetCapture?: ReactEventHandler<HTMLElement> | undefined;
    onSubmit?: SubmitEventHandler<HTMLElement> | undefined;
    onSubmitCapture?: SubmitEventHandler<HTMLElement> | undefined;
    onInvalid?: ReactEventHandler<HTMLElement> | undefined;
    onInvalidCapture?: ReactEventHandler<HTMLElement> | undefined;
    onLoad?: ReactEventHandler<HTMLElement> | undefined;
    onLoadCapture?: ReactEventHandler<HTMLElement> | undefined;
    onError?: ReactEventHandler<HTMLElement> | undefined;
    onErrorCapture?: ReactEventHandler<HTMLElement> | undefined;
    onKeyDown?: KeyboardEventHandler<HTMLElement> | undefined;
    onKeyDownCapture?: KeyboardEventHandler<HTMLElement> | undefined;
    onKeyPress?: KeyboardEventHandler<HTMLElement> | undefined;
    onKeyPressCapture?: KeyboardEventHandler<HTMLElement> | undefined;
    onKeyUp?: KeyboardEventHandler<HTMLElement> | undefined;
    onKeyUpCapture?: KeyboardEventHandler<HTMLElement> | undefined;
    onAbort?: ReactEventHandler<HTMLElement> | undefined;
    onAbortCapture?: ReactEventHandler<HTMLElement> | undefined;
    onCanPlay?: ReactEventHandler<HTMLElement> | undefined;
    onCanPlayCapture?: ReactEventHandler<HTMLElement> | undefined;
    onCanPlayThrough?: ReactEventHandler<HTMLElement> | undefined;
    onCanPlayThroughCapture?: ReactEventHandler<HTMLElement> | undefined;
    onDurationChange?: ReactEventHandler<HTMLElement> | undefined;
    onDurationChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
    onEmptied?: ReactEventHandler<HTMLElement> | undefined;
    onEmptiedCapture?: ReactEventHandler<HTMLElement> | undefined;
    onEncrypted?: ReactEventHandler<HTMLElement> | undefined;
    onEncryptedCapture?: ReactEventHandler<HTMLElement> | undefined;
    onEnded?: ReactEventHandler<HTMLElement> | undefined;
    onEndedCapture?: ReactEventHandler<HTMLElement> | undefined;
    onLoadedData?: ReactEventHandler<HTMLElement> | undefined;
    onLoadedDataCapture?: ReactEventHandler<HTMLElement> | undefined;
    onLoadedMetadata?: ReactEventHandler<HTMLElement> | undefined;
    onLoadedMetadataCapture?: ReactEventHandler<HTMLElement> | undefined;
    onLoadStart?: ReactEventHandler<HTMLElement> | undefined;
    onLoadStartCapture?: ReactEventHandler<HTMLElement> | undefined;
    onPause?: ReactEventHandler<HTMLElement> | undefined;
    onPauseCapture?: ReactEventHandler<HTMLElement> | undefined;
    onPlay?: ReactEventHandler<HTMLElement> | undefined;
    onPlayCapture?: ReactEventHandler<HTMLElement> | undefined;
    onPlaying?: ReactEventHandler<HTMLElement> | undefined;
    onPlayingCapture?: ReactEventHandler<HTMLElement> | undefined;
    onProgress?: ReactEventHandler<HTMLElement> | undefined;
    onProgressCapture?: ReactEventHandler<HTMLElement> | undefined;
    onRateChange?: ReactEventHandler<HTMLElement> | undefined;
    onRateChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
    onSeeked?: ReactEventHandler<HTMLElement> | undefined;
    onSeekedCapture?: ReactEventHandler<HTMLElement> | undefined;
    onSeeking?: ReactEventHandler<HTMLElement> | undefined;
    onSeekingCapture?: ReactEventHandler<HTMLElement> | undefined;
    onStalled?: ReactEventHandler<HTMLElement> | undefined;
    onStalledCapture?: ReactEventHandler<HTMLElement> | undefined;
    onSuspend?: ReactEventHandler<HTMLElement> | undefined;
    onSuspendCapture?: ReactEventHandler<HTMLElement> | undefined;
    onTimeUpdate?: ReactEventHandler<HTMLElement> | undefined;
    onTimeUpdateCapture?: ReactEventHandler<HTMLElement> | undefined;
    onVolumeChange?: ReactEventHandler<HTMLElement> | undefined;
    onVolumeChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
    onWaiting?: ReactEventHandler<HTMLElement> | undefined;
    onWaitingCapture?: ReactEventHandler<HTMLElement> | undefined;
    onAuxClick?: MouseEventHandler<HTMLElement> | undefined;
    onAuxClickCapture?: MouseEventHandler<HTMLElement> | undefined;
    onClick?: MouseEventHandler<HTMLElement> | undefined;
    onClickCapture?: MouseEventHandler<HTMLElement> | undefined;
    onContextMenu?: MouseEventHandler<HTMLElement> | undefined;
    onContextMenuCapture?: MouseEventHandler<HTMLElement> | undefined;
    onDoubleClick?: MouseEventHandler<HTMLElement> | undefined;
    onDoubleClickCapture?: MouseEventHandler<HTMLElement> | undefined;
    onDrag?: DragEventHandler<HTMLElement> | undefined;
    onDragCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragEnd?: DragEventHandler<HTMLElement> | undefined;
    onDragEndCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragEnter?: DragEventHandler<HTMLElement> | undefined;
    onDragEnterCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragExit?: DragEventHandler<HTMLElement> | undefined;
    onDragExitCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragLeave?: DragEventHandler<HTMLElement> | undefined;
    onDragLeaveCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragOver?: DragEventHandler<HTMLElement> | undefined;
    onDragOverCapture?: DragEventHandler<HTMLElement> | undefined;
    onDragStart?: DragEventHandler<HTMLElement> | undefined;
    onDragStartCapture?: DragEventHandler<HTMLElement> | undefined;
    onDrop?: DragEventHandler<HTMLElement> | undefined;
    onDropCapture?: DragEventHandler<HTMLElement> | undefined;
    onMouseDown?: MouseEventHandler<HTMLElement> | undefined;
    onMouseDownCapture?: MouseEventHandler<HTMLElement> | undefined;
    onMouseEnter?: MouseEventHandler<HTMLElement> | undefined;
    onMouseLeave?: MouseEventHandler<HTMLElement> | undefined;
    onMouseMove?: MouseEventHandler<HTMLElement> | undefined;
    onMouseMoveCapture?: MouseEventHandler<HTMLElement> | undefined;
    onMouseOut?: MouseEventHandler<HTMLElement> | undefined;
    onMouseOutCapture?: MouseEventHandler<HTMLElement> | undefined;
    onMouseOver?: MouseEventHandler<HTMLElement> | undefined;
    onMouseOverCapture?: MouseEventHandler<HTMLElement> | undefined;
    onMouseUp?: MouseEventHandler<HTMLElement> | undefined;
    onMouseUpCapture?: MouseEventHandler<HTMLElement> | undefined;
    onSelect?: ReactEventHandler<HTMLElement> | undefined;
    onSelectCapture?: ReactEventHandler<HTMLElement> | undefined;
    onTouchCancel?: TouchEventHandler<HTMLElement> | undefined;
    onTouchCancelCapture?: TouchEventHandler<HTMLElement> | undefined;
    onTouchEnd?: TouchEventHandler<HTMLElement> | undefined;
    onTouchEndCapture?: TouchEventHandler<HTMLElement> | undefined;
    onTouchMove?: TouchEventHandler<HTMLElement> | undefined;
    onTouchMoveCapture?: TouchEventHandler<HTMLElement> | undefined;
    onTouchStart?: TouchEventHandler<HTMLElement> | undefined;
    onTouchStartCapture?: TouchEventHandler<HTMLElement> | undefined;
    onPointerDown?: PointerEventHandler<HTMLElement> | undefined;
    onPointerDownCapture?: PointerEventHandler<HTMLElement> | undefined;
    onPointerMove?: PointerEventHandler<HTMLElement> | undefined;
    onPointerMoveCapture?: PointerEventHandler<HTMLElement> | undefined;
    onPointerUp?: PointerEventHandler<HTMLElement> | undefined;
    onPointerUpCapture?: PointerEventHandler<HTMLElement> | undefined;
    onPointerCancel?: PointerEventHandler<HTMLElement> | undefined;
    onPointerCancelCapture?: PointerEventHandler<HTMLElement> | undefined;
    onPointerEnter?: PointerEventHandler<HTMLElement> | undefined;
    onPointerLeave?: PointerEventHandler<HTMLElement> | undefined;
    onPointerOver?: PointerEventHandler<HTMLElement> | undefined;
    onPointerOverCapture?: PointerEventHandler<HTMLElement> | undefined;
    onPointerOut?: PointerEventHandler<HTMLElement> | undefined;
    onPointerOutCapture?: PointerEventHandler<HTMLElement> | undefined;
    onGotPointerCapture?: PointerEventHandler<HTMLElement> | undefined;
    onGotPointerCaptureCapture?: PointerEventHandler<HTMLElement> | undefined;
    onLostPointerCapture?: PointerEventHandler<HTMLElement> | undefined;
    onLostPointerCaptureCapture?: PointerEventHandler<HTMLElement> | undefined;
    onScroll?: UIEventHandler<HTMLElement> | undefined;
    onScrollCapture?: UIEventHandler<HTMLElement> | undefined;
    onScrollEnd?: UIEventHandler<HTMLElement> | undefined;
    onScrollEndCapture?: UIEventHandler<HTMLElement> | undefined;
    onWheel?: WheelEventHandler<HTMLElement> | undefined;
    onWheelCapture?: WheelEventHandler<HTMLElement> | undefined;
    onAnimationStart?: AnimationEventHandler<HTMLElement> | undefined;
    onAnimationStartCapture?: AnimationEventHandler<HTMLElement> | undefined;
    onAnimationEnd?: AnimationEventHandler<HTMLElement> | undefined;
    onAnimationEndCapture?: AnimationEventHandler<HTMLElement> | undefined;
    onAnimationIteration?: AnimationEventHandler<HTMLElement> | undefined;
    onAnimationIterationCapture?: AnimationEventHandler<HTMLElement> | undefined;
    onToggle?: ToggleEventHandler<HTMLElement> | undefined;
    onBeforeToggle?: ToggleEventHandler<HTMLElement> | undefined;
    onTransitionCancel?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionCancelCapture?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionEnd?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionEndCapture?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionRun?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionRunCapture?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionStart?: TransitionEventHandler<HTMLElement> | undefined;
    onTransitionStartCapture?: TransitionEventHandler<HTMLElement> | undefined;
    className: string;
}, Element>;

export declare interface VisuallyHiddenProps extends HTMLAttributes<HTMLElement> {
    /** Intrinsic element to render. Defaults to "span". */
    as?: keyof JSX.IntrinsicElements;
}

/** A running voice-activity monitor. */
export declare interface VoiceActivityMonitor {
    /** Whether the track is currently carrying speech. */
    readonly speaking: boolean;
    /** Stop sampling and release the analysis graph. */
    stop: () => void;
}

/** Options for {@link monitorVoiceActivity}. */
export declare interface VoiceActivityOptions {
    /** RMS at or above which a window counts as speech. Default `0.045`. */
    threshold?: number;
    /** How long the state stays `true` after the level drops. Default `350`. */
    releaseMs?: number;
    /** How often the level is sampled, in ms. Default `100`. */
    pollMs?: number;
    /**
     * Reuse an existing `AudioContext` instead of creating one.
     *
     * A monitor per remote participant hits the browser's cap on live contexts
     * (Chrome allows around six) in a five-person call. Open one and share it.
     */
    context?: AudioContext;
}

/** A running voice chain. */
export declare interface VoiceChain {
    /** The processed track to publish. */
    track: MediaStreamTrack;
    /** Stop the detectors, disconnect the graph, and release the track. */
    release: () => void;
    /**
     * Whether a graph was actually built.
     *
     * `false` when this engine has no Web Audio, and also when the settings asked
     * for nothing — in both cases `track` is `source`, untouched.
     */
    readonly supported: boolean;
}

/** Options for {@link createVoiceChain}. */
export declare interface VoiceChainOptions {
    /** Output multiplier, applied after every stage and before the limiter. Default `1`. */
    gain?: number;
    /**
     * Reuse an existing `AudioContext` instead of creating one.
     *
     * Browsers cap live contexts (Chrome allows around six), so a page that already
     * has one — a level meter, an audio bus — should hand it over.
     */
    context?: AudioContext;
    /**
     * Whether `release()` also stops `source`. Default `true`.
     *
     * Pass `false` when the track belongs to somebody else: a settings dialog
     * building a second chain over its live preview would otherwise kill the meter
     * the person is watching while they listen.
     */
    ownsSource?: boolean;
}

/** Which stages a voice chain builds. */
export declare interface VoiceChainSettings {
    /** Cut everything below speech: fans, traffic rumble, desk knocks, plosives. */
    highPass: boolean;
    /** Silence the line when nobody is talking. */
    gate: boolean;
    /** RMS below which the gate closes, 0..1. See {@link suggestGateThreshold}. */
    gateThreshold: number;
    /** Even out the distance between a whisper and a shout. */
    compressor: boolean;
    /** Lift the consonant band so speech reads without getting louder. */
    presence: boolean;
    /** Roll off hiss above what speech uses. */
    hissCut: boolean;
    /** Ride down harsh S and CH sounds. */
    deEsser: boolean;
    /**
     * Hard ceiling before the signal leaves.
     *
     * On by default and worth leaving on: the leveller is 3:1, which controls the
     * average and lets a peak through, and `gain` can reach well above 1.
     */
    limiter: boolean;
}

/** A running monitor. */
export declare interface VoiceMonitor {
    /** Stop listening and release the graph. Does **not** stop the source track. */
    stop: () => void;
}

/**
 * Pluggable persistence for the pull watermark (the "changed since" cursor).
 * Pass an object with a `storageKey` to use a `localStorage`-backed default.
 */
export declare interface WatermarkStore {
    /** Read the current watermark, or `null` when none is stored. */
    get: () => string | null;
    /** Persist a new watermark. */
    set: (value: string) => void;
    /** Drop the watermark (e.g. on logout / account switch). */
    clear: () => void;
}

/** Options for {@link blobToWav}. */
export declare interface WavOptions {
    /**
     * Mix down to one channel. Default `false`.
     *
     * Worth turning on for speech headed to a server: a microphone recorded in stereo
     * carries two nearly identical channels and doubles the upload for nothing.
     */
    mono?: boolean;
    /**
     * Resample to this rate. Default: keep the source rate.
     *
     * 16000 is the rate most speech-to-text APIs want, and dropping 48 kHz to 16 kHz
     * removes two thirds of the bytes with no audible loss on voice.
     */
    sampleRate?: number;
}

/**
 * Browser-side Web Push helper. Wraps `Notification.requestPermission`,
 * `pushManager.subscribe`, and the corresponding teardown. Transport is up to
 * the caller via `onSubscribe` / `onUnsubscribe` callbacks.
 */
export declare class WebPushClient {
    private readonly config;
    constructor(config: WebPushClientConfig);
    /** Whether the runtime supports the Push API. */
    static isSupported(): boolean;
    private registration;
    /** Current `Notification.permission` value, or `"unsupported"`. */
    permission(): NotificationPermission | "unsupported";
    /**
     * Ask the user for notification permission.
     *
     * @throws {WebPushUnsupportedError} If the runtime lacks the Notification API.
     * @returns The resulting `NotificationPermission` value.
     */
    requestPermission(): Promise<NotificationPermission>;
    /** Return the active push subscription, if any. */
    getSubscription(): Promise<PushSubscription | null>;
    /** True when a subscription already exists for this browser. */
    isSubscribed(): Promise<boolean>;
    /**
     * Subscribe the current device. Requests permission, creates a push
     * subscription if none exists, and forwards the JSON payload to
     * `onSubscribe` for backend persistence.
     *
     * @returns The active `PushSubscription`.
     * @throws {WebPushUnsupportedError} If Web Push is unavailable.
     * @throws {WebPushPermissionDeniedError} If the user denies the prompt.
     */
    subscribe(): Promise<PushSubscription>;
    /**
     * Cancel the current subscription. Calls `onUnsubscribe` first (so the
     * backend can purge the record) and then `subscription.unsubscribe()`.
     *
     * @returns True when an active subscription was removed, false otherwise.
     */
    unsubscribe(): Promise<boolean>;
}

export declare interface WebPushClientConfig {
    /** VAPID public key (URL-safe base64). */
    vapidPublicKey: string;
    /**
     * Persist the subscription on the backend. The SDK does not own this call —
     * the host app decides the endpoint and how the payload is serialized.
     */
    onSubscribe: (subscription: PushSubscriptionJSON) => Promise<void> | void;
    /** Remove the subscription from the backend. Called before `subscription.unsubscribe()`. */
    onUnsubscribe?: (subscription: PushSubscriptionJSON) => Promise<void> | void;
    /**
     * Override how the service worker registration is obtained.
     * Defaults to `navigator.serviceWorker.ready` — provide this only when you
     * register the SW yourself and want to reuse the registration.
     */
    getRegistration?: () => Promise<ServiceWorkerRegistration>;
}

export declare class WebPushPermissionDeniedError extends Error {
    constructor();
}

export declare class WebPushUnsupportedError extends Error {
    constructor();
}

export declare interface WebSocketController {
    /** Send a payload over the current connection. No-op when not open. */
    send: (payload: string | Blob | BufferSource) => boolean;
    /** Close the connection and stop reconnecting. */
    close: (code?: number, reason?: string) => void;
    /** Force an immediate reconnect, resetting the retry counter. */
    reconnect: () => void;
    /**
     * Change the silence watchdog at runtime, in ms. `0` disables it.
     *
     * For the common case where the server announces its heartbeat interval in
     * the first frame, so the tolerated silence is not hard-coded on both ends:
     *
     * ```ts
     * onMessage: ({ data }) => {
     *   if (data.type === "welcome") socket.setSilenceTimeout(data.heartbeat_seconds * 2500);
     * }
     * ```
     */
    setSilenceTimeout: (ms: number) => void;
    /**
     * Resolves on the first successful open, rejects when the socket is lost
     * before ever opening.
     *
     * Joining and dropping are different events: a call that never connected has
     * to be reported, while one that dropped mid-session should reconnect
     * quietly. Await this for the join, handle
     * {@link CreateWebSocketOptions.onLost} for the drop. Pair it with
     * `maxRetries: 0` when the first attempt should fail fast instead of
     * spending the whole schedule on a server that is not there.
     */
    opened: Promise<void>;
    /** Current connection status. */
    readonly status: WebSocketStatus;
}

/** Why a socket stopped trying to come back. */
export declare type WebSocketLostReason = "rejected" | "exhausted";

export declare interface WebSocketMessage<T> {
    /** Parsed payload — validated when `schema` is set, JSON-decoded when possible, raw string otherwise. */
    data: T;
    /** The original `MessageEvent`. */
    raw: MessageEvent;
}

export declare type WebSocketStatus = "idle" | "connecting" | "open" | "closing" | "closed" | "error";

export declare type WeekStart = 0 | 1;

declare type WeekStart_2 = 0 | 1;

export declare interface WindowSize {
    width: number;
    height: number;
}

/**
 * A bound Zustand hook augmented with auto-generated per-field selector hooks
 * under `.use`. Reading a single field via `store.use.field()` subscribes the
 * component only to that field, avoiding re-renders when unrelated slices change.
 */
export declare type WithSelectors<S> = S extends {
    getState: () => infer T;
} ? S & {
    use: {
        [K in keyof T]: () => T[K];
    };
} : never;

/**
 * Race `promise` against a timeout.
 *
 * Resolves/rejects with `promise` when it settles first. If `ms` elapses
 * before that, the returned promise rejects with an `Error` whose `name` is
 * `"TimeoutError"`.
 *
 * @example
 * await withTimeout(fetch("/slow"), 3000);
 * await withTimeout(fetch("/slow"), 3000, "request too slow");
 */
export declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;

/**
 * Multi-step flow: step indicator, one body at a time, and navigation that
 * respects per-step validation.
 *
 * `Stepper` draws the indicator; this owns the part every app was rewriting — the
 * active index, the async gate before advancing, the disabled/pending buttons and
 * the completion call.
 *
 * Only the active step's body is mounted. Uncommitted input in a step you leave is
 * therefore lost unless the state lives outside (react-hook-form's `FormProvider`,
 * a store, a parent `useState`) — which is the right place for it anyway, since
 * the last step usually needs to submit everything at once.
 *
 * @example
 * ```tsx
 * const form = useZodForm(schema);
 *
 * <FormProvider {...form}>
 *   <Wizard
 *     steps={[
 *       {
 *         id: "dados",
 *         label: "Dados",
 *         validate: () => form.trigger(["nome", "email"]),
 *         content: (
 *           <>
 *             <FormField name="nome" label="Nome"><Input /></FormField>
 *             <FormField name="email" label="E-mail"><Input type="email" /></FormField>
 *           </>
 *         ),
 *       },
 *       { id: "revisao", label: "Revisão", content: <Review /> },
 *     ]}
 *     onComplete={form.handleSubmit(onSubmit)}
 *   />
 * </FormProvider>
 * ```
 */
export declare function Wizard({ steps, activeIndex, defaultActiveIndex, onStepChange, onComplete, nextLabel, backLabel, finishLabel, optionalLabel, clickableSteps, renderActions, className, }: WizardProps): JSX.Element;

/** Flow controls handed to a step body and to `renderActions`. */
export declare interface WizardControls {
    /** Zero-based index of the current step. */
    activeIndex: number;
    /** The current step. */
    step: WizardStep;
    /** `true` while a `validate` promise is pending. */
    validating: boolean;
    isFirst: boolean;
    isLast: boolean;
    /** Run the current step's `validate` and advance when it passes. */
    next: () => Promise<void>;
    /** Go back one step. No validation — going back never blocks. */
    back: () => void;
    /** Jump to an index. Forward jumps validate every step in between. */
    goTo: (index: number) => Promise<void>;
}

export declare interface WizardProps {
    steps: WizardStep[];
    /** Controlled active index. */
    activeIndex?: number;
    /** Uncontrolled initial index. Default `0`. */
    defaultActiveIndex?: number;
    onStepChange?: (index: number, step: WizardStep) => void;
    /** Called when the last step passes validation. */
    onComplete?: () => void | Promise<void>;
    /** Label of the advance button. Default `"Next"`. */
    nextLabel?: string;
    /** Label of the back button. Default `"Back"`. */
    backLabel?: string;
    /** Label of the button on the last step. Default `"Finish"`. */
    finishLabel?: string;
    /**
     * Suffix appended to an optional step's description in the indicator.
     * Default `"(optional)"` — override it to localize, since the SDK ships no
     * translation for component-internal copy.
     */
    optionalLabel?: string;
    /**
     * Allow clicking the indicator to jump. Default `false` — a wizard exists
     * because order matters, and a free jump skips the gates.
     */
    clickableSteps?: boolean;
    /** Replace the default button row. */
    renderActions?: (controls: WizardControls) => ReactNode;
    className?: string;
}

/** One step of the flow. */
export declare interface WizardStep {
    /** Stable identifier. */
    id: string;
    /** Step label shown in the indicator. */
    label: string;
    /** Optional description under the label. */
    description?: string;
    /** Step body. A function receives the flow controls, for a "skip" link inside the form. */
    content: ReactNode | ((controls: WizardControls) => ReactNode);
    /**
     * Gate for leaving this step forward. Return `false` (or a rejected/`false`
     * promise) to keep the user here — typically `() => form.trigger()`.
     * Async is supported: the Next button shows a pending state while it runs.
     */
    validate?: () => boolean | Promise<boolean>;
    /** Marks the step as optional, so `onComplete` can ignore it. */
    optional?: boolean;
}

/**
 * Write a minimal single-sheet Office Open XML (`.xlsx`) workbook and return
 * its bytes. No extra dependency beyond `fflate` — the archive is assembled and
 * deflated in-process.
 *
 * The output is UTF-8 throughout, so accents round-trip in
 * Excel/LibreOffice/Google Sheets without the BOM-detection fragility that
 * plagues CSV exports. The XML stays compact: inline strings (no shared-string
 * table), no styles, no merged cells. Numeric cells use the native `"n"` type
 * so spreadsheets recognise them as numbers; `null` renders as an empty cell.
 *
 * @param headers - Column headers written as the first row.
 * @param rows - Data rows; each value is a string, a number, or `null` (empty).
 * @returns The `.xlsx` file contents, backed by a plain `ArrayBuffer` so the
 *   bytes go straight into `new Blob([...])` — the default `Uint8Array` is
 *   `Uint8Array<ArrayBufferLike>`, which `BlobPart` rejects because it also
 *   admits `SharedArrayBuffer`.
 *
 * @example
 * const bytes = writeXlsx(
 *   ["Name", "Score"],
 *   [["Ada", 99], ["Alan", null]],
 * );
 * const blob = new Blob([bytes], {
 *   type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
 * });
 */
export declare function writeXlsx(headers: readonly string[], rows: readonly (readonly (string | number | null)[])[]): Uint8Array<ArrayBuffer>;

/**
 * Minimal `react-hook-form` resolver built on top of zod. Mirrors the shape
 * produced by `@hookform/resolvers/zod` so it can be passed straight to
 * `useForm({ resolver })`.
 *
 * Typed with react-hook-form's own `Resolver`, not a local look-alike: a
 * structurally similar type of our own compiled fine here and was then rejected
 * at the `useForm({ resolver })` call site — the only place a resolver is ever
 * used — which is why `useZodForm` had to cast its way past it.
 *
 * Of the resolver options only `criteriaMode` is read; the rest of
 * `ResolverOptions` is accepted and ignored, because react-hook-form always
 * passes the whole object.
 *
 * @example
 * const form = useForm<LoginForm>({ resolver: zodResolver(loginSchema) });
 */
export declare function zodResolver<TSchema extends z.ZodTypeAny>(schema: TSchema): Resolver<z.infer<TSchema> & FieldValues>;

export { }