tempest-react-sdk 0.5.1 → 0.8.0

package/dist/tempest-react-sdk.d.ts

@@ -1,38 +1,73 @@
+import { AnimationEventHandler } from 'react';
+import { AriaRole } from 'react';
+import { BrowserRouter } from 'react-router-dom';
 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-dom';
 import { HTMLAttributes } from 'react';
+import { ImgHTMLAttributes } from 'react';
+import { InputEventHandler } from 'react';
 import { InputHTMLAttributes } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { JSX as JSX_2 } from 'react';
+import { KeyboardEventHandler } from 'react';
+import { LabelHTMLAttributes } from 'react';
 import { lazy } from 'react';
+import { Link } from 'react-router-dom';
+import { MemoryRouter } from 'react-router-dom';
+import { MouseEventHandler } from 'react';
+import { Navigate } from 'react-router-dom';
+import { NavigateOptions } from 'react-router-dom';
+import { NavLink } from 'react-router-dom';
+import { Outlet } from 'react-router-dom';
+import { Params } from 'react-router-dom';
 import { Path } from 'react-hook-form';
 import { PersistOptions } from 'zustand/middleware';
+import { PointerEventHandler } from 'react';
 import { QueryClient } 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-dom';
 import { RefAttributes } from 'react';
 import { RefObject } from 'react';
+import { Route } from 'react-router-dom';
+import { Routes } from 'react-router-dom';
 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-dom';
+import { ToggleEventHandler } 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';
@@ -42,7 +77,14 @@ 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 { useLocation } from 'react-router-dom';
+import { useMatch } from 'react-router-dom';
+import { useNavigate } from 'react-router-dom';
+import { useParams } from 'react-router-dom';
+import { useRouteError } from 'react-router-dom';
+import { useSearchParams } from 'react-router-dom';
 import { useWatch } from 'react-hook-form';
+import { WheelEventHandler } from 'react';
 import { z } from 'zod';
 
 /**
@@ -136,6 +178,68 @@ export declare interface ApiError {
     body?: unknown;
 }
 
+/**
+ * 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, 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. */
+    fallback?: ReactNode;
+}
+
 /**
  * Full app layout — composes [[Navbar]] + [[Sidebar]] + content +
  * [[BottomNavigation]] + footer with responsive behaviour:
@@ -191,6 +295,29 @@ export declare interface AspectRatioProps extends HTMLAttributes<HTMLDivElement>
     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";
 
 export declare interface AudioPlayer {
@@ -429,6 +556,8 @@ export declare interface BreakpointHelpers {
 /** Pixel value paired with each breakpoint key. */
 export declare const BREAKPOINTS: Record<Breakpoint, number>;
 
+export { BrowserRouter }
+
 /**
  * Primary action button with variants, sizes and a loading state that
  * preserves layout via an absolutely-positioned spinner.
@@ -465,6 +594,58 @@ export declare const CACHE_TIME: {
     readonly LONG: number;
 };
 
+/**
+ * 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;
+
+/**
+ * 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.
@@ -485,6 +666,40 @@ export declare interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>,
     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>;
 
 /**
@@ -550,6 +765,23 @@ export declare interface ChipInputProps {
     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).
  *
@@ -562,6 +794,25 @@ export declare function clamp(value: number, min: number, max: number): number;
 
 declare type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];
 
+/**
+ * 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.
  *
@@ -575,6 +826,31 @@ value: string;
 onChange: (value: string) => void;
 } & RefAttributes<HTMLInputElement>>;
 
+/**
+ * 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;
+}
+
 /**
  * Combobox — text input with a filterable dropdown of options.
  *
@@ -605,6 +881,65 @@ export declare interface ComboboxProps {
     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;
+}
+
+/**
+ * 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"`.
@@ -644,10 +979,65 @@ export declare interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
 
 export declare type ContainerSize = "sm" | "md" | "lg" | "xl" | "full";
 
+/**
+ * Right-click context menu.
+ *
+ * - Opens at the cursor position on `onContextMenu` (default browser menu suppressed).
+ * - Rendered through a {@link Portal} so it escapes parent overflow/stacking contexts.
+ * - Closes on outside click, Escape, or item selection.
+ * - Arrow Up/Down move focus across selectable items; Enter activates the focused item.
+ *
+ * @param props - The context menu props.
+ * @returns The trigger wrapper plus the portalled menu when open.
+ */
+export declare function ContextMenu({ items, children, className }: 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;
+}
+
 export { Control }
 
 export { Controller }
 
+/**
+ * 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.
+ *
+ * @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 const CPFInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange"> & {
 value: string;
 onChange: (value: string) => void;
@@ -933,6 +1323,23 @@ export declare function createQueryKeys<TKey extends string, TEntries extends Re
  */
 export declare function createRefreshQueue(refresh: () => Promise<void>): () => Promise<void>;
 
+/**
+ * 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
@@ -969,6 +1376,63 @@ export declare interface CreateSentryTelemetryAdapterOptions {
     breadcrumbCategory?: string;
 }
 
+/**
+ * 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"];
+}
+
 /**
  * Open a WebSocket with automatic exponential-backoff reconnect, optional
  * heartbeat pings, and typed JSON parsing.
@@ -1004,6 +1468,93 @@ export declare interface CreateWebSocketOptions<T> {
     onStatusChange?: (status: WebSocketStatus) => void;
 }
 
+/**
+ * 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;
+}
+
+/**
+ * Stateful, headless data table built on top of {@link Table}. Adds
+ * client-side searching, click-to-sort columns, and pagination 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.
+ */
+export declare function DataTable<T>({ data, columns, pageSize, searchable, searchKeys, initialSort, rowKey, emptyMessage, className, ...rest }: DataTableProps<T>): JSX.Element;
+
+/**
+ * Column definition for {@link DataTable}. Extends the headless {@link Table}
+ * column shape with a typed `key`, opt-in sorting, 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;
+}
+
+export declare interface DataTableProps<T> extends HTMLAttributes<HTMLDivElement> {
+    /** Full, unfiltered dataset. Sorting/filtering/pagination happen client-side. */
+    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;
+}
+
+export declare interface DataTableSort<T> {
+    key: keyof T;
+    direction: SortDirection;
+}
+
 /**
  * Thin wrapper around the native `<input type="date">` (or `datetime-local`,
  * `time`, `month`). For richer pickers, pair with `react-datepicker` directly
@@ -1027,6 +1578,22 @@ export declare interface DatePickerProps extends Omit<InputHTMLAttributes<HTMLIn
     wrapperClassName?: string;
 }
 
+/**
+ * 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> & {
@@ -1046,6 +1613,63 @@ export declare interface DecodedJWT {
  */
 export declare function decodeJWT(token: string): DecodedJWT;
 
+/**
+ * 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;
+
+/**
+ * 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[];
+
+/**
+ * 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[];
+}
+
 /**
  * Horizontal or vertical visual separator. When `label` is provided in
  * horizontal mode the divider splits and centers the label between two lines.
@@ -1215,6 +1839,23 @@ export declare interface ErrorStateProps {
     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;
 
 export declare interface EventStreamController {
@@ -1300,6 +1941,20 @@ export declare type FilterPredicate<T> = (item: T, search: string) => boolean;
 
 export declare type FlagValue = boolean | string | number | null;
 
+/**
+ * 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]],
@@ -1336,12 +1991,40 @@ export declare interface FormActionsProps extends HTMLAttributes<HTMLDivElement>
     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"`.
+ *
+ * @example
+ * formatBytes(0);       // "0 B"
+ * formatBytes(1536);    // "1.5 KB"
+ * formatBytes(1048576); // "1 MB"
+ * formatBytes(1536, 2); // "1.50 KB"
+ */
+export declare function formatBytes(bytes: number, decimals?: number): 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"`.
+ *
+ * @example
+ * formatCompactNumber(1234);            // "1.2K"
+ * formatCompactNumber(5600000);         // "5.6M"
+ * formatCompactNumber(1234, "pt-BR");   // "1,2 mil"
+ */
+export declare function formatCompactNumber(value: number, locale?: string): string;
+
 /**
  * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.
  *
@@ -1494,6 +2177,15 @@ export declare interface FormSectionProps extends Omit<HTMLAttributes<HTMLElemen
     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;
+}
+
 /**
  * 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.
@@ -1597,6 +2289,21 @@ export declare interface GridProps extends HTMLAttributes<HTMLDivElement> {
     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.
@@ -1608,6 +2315,8 @@ export declare interface GrowthBookLike {
     setRenderer?: (renderer: () => void) => void;
 }
 
+export { HashRouter }
+
 /** Inverse of `<Show>` — hides children when the condition matches. */
 export declare function Hide({ above, below, only, children }: HideProps): ReactNode;
 
@@ -1621,6 +2330,34 @@ export declare interface HideProps {
     children: ReactNode;
 }
 
+/**
+ * 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;
@@ -1669,6 +2406,32 @@ export declare interface I18nProviderProps {
     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 }
+
+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;
+}
+
 export declare interface InMemoryFlagsOptions {
     initial?: Record<string, FlagValue>;
 }
@@ -1727,17 +2490,72 @@ export declare interface InstallPushHandlerOptions {
  * 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>;
+export declare function installSkipWaitingListener(): void;
+
+export declare type InterpolationValues = Record<string, string | number>;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
 
 /**
- * Return true when the JWT's `exp` claim is in the past (or missing).
+ * Type guard asserting a value is a plain object literal.
  *
- * @param token - JWT to inspect.
- * @param leewaySeconds - Treat tokens expiring within this window as expired.
+ * 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 isJWTExpired(token: string, leewaySeconds?: number): boolean;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 
 /**
  * Convenience check for environments where the Push API is unavailable
@@ -1748,6 +2566,15 @@ export declare function isPushSupported(): boolean;
 /** True when the Web Share API is available in this environment. */
 export declare function isShareSupported(): 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;
+
 /**
  * Renders a `<kbd>` styled like a keyboard key — useful for shortcut hints.
  * Compose multiple keys by rendering siblings: `<Kbd>Ctrl</Kbd> + <Kbd>K</Kbd>`.
@@ -1760,6 +2587,19 @@ export declare interface KbdProps extends HTMLAttributes<HTMLElement> {
 
 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;
@@ -1773,6 +2613,20 @@ export declare interface KeyboardShortcut {
 
 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;
+}
+
 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;
@@ -1818,6 +2672,8 @@ export declare interface LDClientLike {
     off?: (event: string, handler: () => void) => void;
 }
 
+export { Link }
+
 export declare interface ListOptions<TItem> {
     /** Property to order by. Default: `keyPath`. */
     orderBy?: keyof TItem & string;
@@ -1858,6 +2714,72 @@ export declare interface LoggerSink {
 
 export declare type LogLevel = "debug" | "info" | "warn" | "error";
 
+/**
+ * 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[];
+}
+
 export declare type Messages = Record<string, string>;
 
 /**
@@ -1885,6 +2807,18 @@ export declare interface ModalProps {
 
 export declare type ModalSize = "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
 
+/**
+ * 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
@@ -1902,6 +2836,15 @@ export declare interface MoneyInputProps extends Omit<InputProps, "value" | "onC
     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;
+}
+
 /**
  * Top app bar. Three-slot layout (logo / nav / actions) that collapses
  * gracefully on mobile (nav slot wraps below).
@@ -1932,6 +2875,52 @@ export declare interface NavbarProps extends HTMLAttributes<HTMLElement> {
 
 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[];
+}
+
+export { NavLink }
+
 export declare interface OAuthCredential {
     /** Provider-issued ID token (JWT). */
     idToken: string;
@@ -2000,6 +2989,29 @@ export declare interface OfflineStoreConfig<TItem> {
     ownerField?: keyof TItem & 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;
+
+export { Outlet }
+
 /**
  * Page wrapper with header + (optional) toolbar + content + footer. Pairs
  * with `Container` when you want a max-width content well.
@@ -2048,6 +3060,8 @@ export declare interface PaginationProps {
     className?: string;
 }
 
+export { Params }
+
 /**
  * Validate an unknown response payload against a zod schema.
  *
@@ -2100,6 +3114,17 @@ 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>;
+
 /**
  * One-time-password style input — N independent cells, paste support, auto-
  * advance on input, backspace flows back, arrow keys navigate.
@@ -2167,6 +3192,19 @@ export declare interface PlayAudioOptions {
     onError?: (error: unknown) => void;
 }
 
+/**
+ * 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
@@ -2198,6 +3236,28 @@ export declare interface PopoverProps {
     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. Defaults to `document.body` when no `container`
+ * is provided.
+ *
+ * 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 `document.body`. */
+    container?: Element | null;
+}
+
 /**
  * Minimal subset of `posthog-js` used by the adapter. Pass either the real
  * default export (`import posthog from "posthog-js"`) or a stubbed object
@@ -2304,6 +3364,39 @@ export declare interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputEl
     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
@@ -2349,6 +3442,8 @@ export declare interface RatingStarsProps {
     className?: string;
 }
 
+export { redirect }
+
 /** Recommended refetch intervals (milliseconds). */
 export declare const REFETCH_TIME: {
     readonly REALTIME: number;
@@ -2385,6 +3480,18 @@ export declare interface RegisterServiceWorkerOptions {
     onError?: (error: unknown) => void;
 }
 
+/**
+ * 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.
@@ -2400,11 +3507,42 @@ export declare function relativeTime(input: Date | string | number, options?: {
 
 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";
+}
+
 export declare interface RequestOptions extends Omit<RequestInit, "body"> {
     body?: unknown;
     params?: Record<string, string | number | boolean | undefined | null>;
 }
 
+/**
+ * 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];
+}
+
 export declare type ResolvedTheme = "light" | "dark";
 
 declare type Resolver<T> = (values: unknown, context: unknown, options: {
@@ -2464,6 +3602,39 @@ export declare interface RetryOptions {
     signal?: AbortSignal;
 }
 
+export { Route }
+
+/**
+ * Declarative route guard built on React Router's `<Navigate>`. Renders its
+ * children when `when` is truthy, otherwise redirects. Pairs naturally with
+ * `createAuthStore` for protected areas.
+ *
+ * @example
+ * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo="/login">
+ *     <Outlet />
+ * </RouteGuard>
+ */
+export declare function RouteGuard({ when, redirectTo, replace, children }: RouteGuardProps): JSX.Element;
+
+export declare interface RouteGuardProps {
+    /**
+     * Whether access is allowed. Pass a boolean or anything truthy/falsy —
+     * typically `useAuthStore((s) => s.isAuthenticated)`.
+     */
+    when: boolean;
+    /** 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;
+}
+
+/** Router history strategy used by {@link AppRouter}. */
+export declare type RouterKind = "browser" | "hash" | "memory";
+
+export { Routes }
+
 /**
  * Apply `env(safe-area-inset-*)` padding so content avoids iOS notch /
  * Android navbar / device chrome. Wrap the outermost container of pages
@@ -2486,6 +3657,23 @@ export declare interface SafeAreaProps extends HTMLAttributes<HTMLDivElement> {
     children?: ReactNode;
 }
 
+/**
+ * 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>`.
+ */
+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;
+}
+
 /**
  * Search input with magnifier icon and a clear button. Controlled component:
  * pass `value` and `onChange`.
@@ -2688,6 +3876,14 @@ export declare interface SkeletonProps {
  */
 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>;
+
 /**
  * Convert a string into a URL-safe slug.
  *
@@ -2701,6 +3897,8 @@ export declare function skipWaiting(worker: ServiceWorker): void;
  */
 export declare function slugify(input: string): string;
 
+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.
@@ -2994,6 +4192,38 @@ export declare interface TelemetryUser {
     traits?: Record<string, unknown>;
 }
 
+/**
+ * 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: ComponentType<unknown>;
+    }>;
+    /** 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.
+     */
+    guard?: boolean | (() => boolean);
+    /** Destination used when `guard` fails (default: `"/"`). */
+    redirectTo?: string;
+    /** Match the path case-sensitively. */
+    caseSensitive?: boolean;
+}
+
 /**
  * Multi-line text input. Mirrors the {@link Input} API for label/helper/error.
  */
@@ -3054,6 +4284,23 @@ export declare interface ThemeProviderProps {
     attribute?: string;
 }
 
+/**
+ * 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
@@ -3091,6 +4338,8 @@ export declare interface TimelineProps extends HTMLAttributes<HTMLOListElement>
     connector?: boolean;
 }
 
+export { To }
+
 export declare interface ToastApi {
     show: (options: ToastOptions) => string;
     dismiss: (id: string) => void;
@@ -3126,6 +4375,61 @@ export declare interface ToastProviderProps {
 
 export declare type ToastVariant = "success" | "warning" | "error" | "info";
 
+/**
+ * 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.
+ *
+ * @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;
@@ -3133,6 +4437,23 @@ export declare interface ToggleHelpers {
     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";
+
 /**
  * Lightweight tooltip. Shows on hover and on focus (keyboard-friendly). Wraps
  * a single child element via `cloneElement`, so the trigger keeps its own ref
@@ -3165,6 +4486,40 @@ export declare interface TooltipProps {
  */
 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;
+}
+
+/**
+ * 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;
 
@@ -3523,6 +4878,8 @@ export declare interface UseKeyboardShortcutOptions {
  */
 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
@@ -3541,6 +4898,8 @@ export declare interface UseLongPressOptions {
     moveThreshold?: number;
 }
 
+export { useMatch }
+
 /**
  * Subscribe to a CSS media query and re-render on match changes.
  *
@@ -3549,6 +4908,8 @@ export declare interface UseLongPressOptions {
  */
 export declare function useMediaQuery(query: string): boolean;
 
+export { useNavigate }
+
 /**
  * Run an OAuth-callback "exchange" exactly once on mount. Designed for
  * `/callback` routes that receive provider redirects and need to swap a
@@ -3622,6 +4983,8 @@ export declare interface UsePaginationResult {
     reset: () => void;
 }
 
+export { useParams }
+
 /**
  * Poll an async factory on a fixed interval. Skips overlapping requests if a
  * prior call has not finished. Pause via `disabled` or `stopWhen`.
@@ -3699,12 +5062,16 @@ export declare interface UsePushSubscriptionResult {
  */
 export declare function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null;
 
+export { useRouteError }
+
 /**
  * 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;
 
+export { useSearchParams }
+
 /**
  * Returns a stable function reference that always invokes the latest
  * `callback` argument. Use to break dependency cycles in effects without
@@ -3901,6 +5268,301 @@ export declare interface VirtualListProps<T> {
     style?: CSSProperties;
 }
 
+/**
+ * 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_2.IntrinsicElements;
+}
+
 /**
  * Browser-side Web Push helper. Wraps `Notification.requestPermission`,
  * `pushManager.subscribe`, and the corresponding teardown. Transport is up to
@@ -3990,11 +5652,39 @@ export declare interface WebSocketMessage<T> {
 
 export declare type WebSocketStatus = "idle" | "connecting" | "open" | "closing" | "closed" | "error";
 
+export declare type WeekStart = 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>;
+
 /**
  * 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