import * as React from 'react';
import React__default, { PropsWithChildren, ReactElement, ReactNode, ChangeEvent, SVGProps, ChangeEventHandler, InputHTMLAttributes, TextareaHTMLAttributes, Component, ErrorInfo, JSX } from 'react';
import * as zustand_traditional from 'zustand/traditional';
import * as zustand from 'zustand';
import { UseBoundStore, StoreApi } from 'zustand';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as zustand_middleware from 'zustand/middleware';
import { DropzoneOptions } from 'react-dropzone';
import { LanguageFn } from 'highlight.js';

type Variant$1 = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'subtitle' | 'button';
type WeightAlias = 'regular' | 'medium' | 'semibold' | 'bold';
interface FluidSize {
    min: string;
    max: string;
    vwFrom: number;
    vwTo: number;
}

type Breakpoint = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type ThemeMode = 'light' | 'dark';
type Density = 'tight' | 'standard' | 'comfortable';
interface Theme {
    colors: Record<string, string>;
    /** Human-readable names for color tokens */
    colorNames: Record<string, string>;
    /** Returns a CSS length for the given number of spacing units */
    spacing: (units: number) => string;
    /** Base unit used by the spacing helper */
    spacingUnit: string;
    /** Returns a CSS length for border radii using a relative base */
    radius: (units: number) => string;
    /** Base unit used by the radius helper */
    radiusUnit: string;
    /** Returns a CSS length for strokes/borders using a relative base */
    stroke: (units: number) => string;
    /** Base unit used by the stroke helper */
    strokeUnit: string;
    /**
     * Motion and animation tokens: common durations, easing curves,
     * and a small set of tuned values for reusable interactions.
     */
    motion: {
        /** Canonical durations to keep motion consistent across components */
        duration: {
            /** e.g. micro feedback, tap highlights */
            xshort: string;
            /** e.g. tooltip fade, small nudge */
            short: string;
            /** e.g. color or small position transitions */
            medium: string;
            /** e.g. base UI enters/exits (snackbars, toasts) */
            base: string;
            /** e.g. larger layout shifts or content settles */
            long: string;
            /** e.g. exaggerated distances or elastic UI sweeps */
            xlong: string;
        };
        /** Named cubic-bezier curves for consistent feel */
        easing: {
            /** Crisp ease-out; good general-purpose settle */
            standard: string;
            /** Slightly punchier ease for emphasized motion */
            emphasized: string;
            /** Gentle overshoot for micro pulses */
            overshoot: string;
            /** Pass-throughs for convenience */
            linear: string;
            ease: string;
        };
        /** Default hover interaction tokens */
        hover: {
            duration: string;
            easing: string;
        };
        /** Tuned values for tab/underline-style follow animations */
        underline: {
            stretch: {
                baseMs: number;
                distanceCoef: number;
                minMs: number;
                maxMs: number;
            };
            settle: {
                baseMs: number;
                distanceCoef: number;
                minMs: number;
                maxMs: number;
            };
        };
    };
    breakpoints: Record<Breakpoint, number>;
    /** Fixed sizes per breakpoint for semantic text variants */
    typography: Record<Variant$1, Record<Breakpoint, string>>;
    /** Optional fluid sizes compiled to clamp(); falls back to breakpoint sizes */
    typographyFluid?: Partial<Record<Variant$1, FluidSize>>;
    /** Optional unitless line-height per variant */
    lineHeight?: Partial<Record<Variant$1, number>>;
    /** Optional letter-spacing per variant (px/em) */
    letterSpacing?: Partial<Record<Variant$1, string | number>>;
    /** Optional allowed weights per variant (either list or min/max range) */
    weights?: Partial<Record<Variant$1, number[] | {
        min: number;
        max: number;
    }>>;
    /** Aliases for common weights */
    weightAliases?: Partial<Record<WeightAlias, number>>;
    /**
     * Optional per-family defaults for line-height and letter-spacing.
     * Use either a base value (applies to all variants mapped to that family)
     * or a per-variant map for fine control.
     */
    typographyFamilies?: Partial<Record<'heading' | 'body' | 'mono' | 'button', {
        lineHeight?: number | Partial<Record<Variant$1, number>>;
        letterSpacing?: string | number | Partial<Record<Variant$1, string | number>>;
    }>>;
    fonts: {
        heading: string;
        body: string;
        mono: string;
        button: string;
    };
    /** Default optical sizing behavior for variable fonts */
    fontOpticalSizing?: 'auto' | 'none';
}
interface ThemeStore {
    mode: ThemeMode;
    theme: Theme;
    /** Cumulative user patches; re-applied on top of the base on every mode change */
    overlay: Partial<Theme>;
    density: Density;
    setMode: (m: ThemeMode) => void;
    toggleMode: () => void;
    setTheme: (patch: Partial<Theme>) => void;
    /** Clear all setTheme customisations and return to the built-in theme */
    resetTheme: () => void;
    setDensity: (d: Density) => void;
}
declare const useTheme: zustand_traditional.UseBoundStoreWithEqualityFn<zustand.StoreApi<ThemeStore>>;

interface Presettable {
    /** One or many style-preset names registered via `definePreset()` */
    preset?: string | string[];
}
/** Numeric values are mapped via theme.spacing(n); strings pass through. */
type Space = number | string;
/**
 * A value that can vary by breakpoint. Either a single value applied at all
 * widths, or a partial breakpoint map (`{ xs, sm, md, lg, xl }`) whose entries
 * each apply from that breakpoint's `min-width` upward (mobile-first).
 *
 * Breakpoint maps compile to CSS `@media (min-width: …)` rules **inside the
 * `styled()` template** (via `utils/responsive`) — there is no JS resolution,
 * no `<Surface>` dependency, and no first-paint reflow, so a responsive layout
 * is correct on the server's first paint. Keep breakpoint maps to enumerable
 * values; binding one to continuously-varying state (e.g. a slider) mints a
 * permanent CSS rule per value (see the engine's rule-cardinality tripwire).
 */
type Responsive<T> = T | Partial<Record<Breakpoint, T>>;
/** Common spacing props shared across layout components. */
interface SpacingProps {
    /** Inter-child spacing as units or CSS length. */
    gap?: Space;
    /** Container padding as units or CSS length. */
    pad?: Space;
    /**
     * Zeros all layout spacing (pad, gap, and spacing-margins) where supported and
     * cascades to spacing-aware descendants. Does not touch control insets,
     * structural geometry, border-radius, glyph sizes, or alignment. `compact={false}`
     * opts a subtree back out of an inherited compact.
     */
    compact?: boolean;
    /** Density override for the spacing scale; defaults from nearest Surface. */
    density?: 'tight' | 'standard' | 'comfortable';
}
/** Sx prop: inline CSS with support for CSS custom properties (e.g. --valet-*) */
type Sx = React__default.CSSProperties & {
    [key: `--${string}`]: string | number;
};
/**
 * Semantic colour intent shared by every intent-driven component
 * (Button, IconButton, Chip, Panel, AppBar). The seven named tokens map to
 * theme colours; the `(string & {})` member keeps the union open so a caller
 * can pass an arbitrary theme-token name or CSS colour while preserving
 * autocomplete on the canonical names.
 *
 * Canonical single source of truth (API-TYPES S12): the five components above
 * each declared this union verbatim — a copy-paste that drifts on edit. They
 * now alias this type instead.
 */
type Intent = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info' | (string & {});
/**
 * Unified selection vocabulary shared by collection components (Table, List,
 * Tree) — API-TYPES S11, ruling Q11(a)/R12. Before this, each collection spoke
 * a different dialect: Table used `selectable: 'single' | 'multi'` with a
 * row-array `onSelectionChange`, List used a single `selected: T | null` + a
 * `getKey` identity, and Tree used `selected: string` ids. The three now share
 * one keyed vocabulary so the same name means the same thing everywhere.
 *
 * `K` is the **selection unit** each component exposes:
 * - Table — `K = T` (the row type; identity is keyed internally by `getItemKey`).
 * - List  — `K = T` (the item type; selection is by reference, `getItemKey` standardizes reorder identity).
 * - Tree  — `K = string` (the node id).
 *
 * Components adopt the subset they support and re-document the generic in their
 * own prop types. `selected`/`defaultSelected` are always **arrays** so the
 * single- and multiple-selection shapes share one type; a single-selection
 * component simply ignores all but the last entry. The pre-S11 per-component
 * names (Table's `selectable`/`rowKey`, etc.) were removed at 1.0; only this
 * canonical vocabulary remains.
 */
interface SelectionProps<K> {
    /**
     * How many items may be selected at once.
     * - `'none'` — selection is disabled (the default for components that gate it).
     * - `'single'` — at most one item is selected.
     * - `'multiple'` — any number of items may be selected.
     *
     * Canonical replacement for the former per-component flags (e.g. Table's
     * removed `selectable`).
     */
    selectionMode?: 'none' | 'single' | 'multiple';
    /** Controlled selection as an array of selection units (`K`). */
    selected?: K[];
    /** Uncontrolled initial selection as an array of selection units (`K`). */
    defaultSelected?: K[];
    /**
     * Fired when the selection changes (user interaction only — never on mount
     * or on a derived prune that merely keeps the array in sync). Receives the
     * full next selection as an array of selection units.
     */
    onSelectionChange?: (selected: K[]) => void;
    /**
     * Stable identity for each item — a property name or a function of the item
     * and its index. Canonical, cross-component replacement for Table's `rowKey`
     * and List's `getKey`. When omitted, components fall back to reference/index
     * identity exactly as before.
     */
    getItemKey?: keyof K | ((item: K, index: number) => string | number);
}
/**
 * Base props shared by value field components (TextField, Checkbox, Select, Slider, Switch, etc.).
 * Attach these to ensure consistent behavior and documentation across fields.
 *
 * Note: `name` is optional here. Components that require a name can refine their
 * prop type with `& { name: string }` to enforce it at the component level.
 */
interface FieldBaseProps extends Presettable {
    /**
     * Field identifier used for FormControl binding and forwarded to the underlying control
     * when applicable. Components can require `name` locally if they depend on it.
     */
    name?: string;
    /** Visual label rendered by the component or its wrapper. Accepts string or node. */
    label?: React__default.ReactNode;
    /** Supplemental hint or validation content typically rendered under the control. */
    helperText?: React__default.ReactNode;
    /** Marks the field invalid; components may adjust visuals and helper text color. */
    error?: boolean;
    /** Stretches the field wrapper to occupy the full available width. */
    fullWidth?: boolean;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
}

type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type AvatarVariant = 'plain' | 'outline';
interface AvatarProps extends Omit<React__default.ImgHTMLAttributes<HTMLImageElement>, 'style'>, Presettable {
    /** Image URL override. */
    src?: string;
    /** Email used for Gravatar lookup when src missing. */
    email?: string;
    /** Display name used to derive initials for offline fallback. */
    name?: string;
    /** Size token controlling relative dimensions. */
    size?: AvatarSize;
    /** Visual style variant. */
    variant?: AvatarVariant;
    /**
     * Opt in to a third-party Gravatar lookup from `email` when no `src`
     * is given. Default `false`: src-less avatars render an offline
     * initials/placeholder fallback and make **no network request**.
     *
     * Privacy: enabling this discloses a reversible md5 of the email plus
     * the viewer's IP/UA to Automattic. Requires a non-empty `email`.
     */
    gravatar?: boolean;
    /** Gravatar default-image style (`d` param) when `gravatar` is enabled. */
    gravatarDefault?: string;
    /**
     * Force the offline fallback even when `gravatar` + `email` would
     * otherwise resolve a network avatar. Legacy escape hatch; with
     * `gravatar` defaulting to `false` the fallback is already the default.
     */
    preferFallback?: boolean;
    /** Offline fallback strategy when showing a non-network avatar. */
    fallback?: 'initials' | 'placeholder';
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Avatar: React__default.FC<AvatarProps>;

type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface IconProps extends Omit<React__default.HTMLAttributes<HTMLSpanElement>, 'style'>, Presettable {
    /** Iconify icon name, e.g. "mdi:home". */
    icon?: string;
    /**
     * Custom SVG:
     * • **string** – passed through the {@link parseSvgString} allowlist
     *   parser. Accepted forms: bare path `d`-data (`"M12 2L2 22h20z"`,
     *   wrapped in a 24×24 viewBox) or `<path>`-only markup, optionally
     *   inside one `<svg>` wrapper. The result is rendered as real React
     *   `<svg>`/`<path>` elements — never via `innerHTML`. Anything outside
     *   that grammar renders nothing and dev-warns.
     * • **ReactElement** – a full `<svg>` element you already trust.
     *
     * **BREAKING (Q6):** full-SVG strings (`<svg>…</svg>` containing anything
     * other than `<path>`, or any string with entities/comments/scripts) no
     * longer render here — they are an XSS vector through the old
     * `dangerouslySetInnerHTML` sink. For trusted full-SVG markup, pass a
     * ReactElement or use {@link IconProps.dangerouslySetSvg}.
     */
    svg?: string | ReactElement<React__default.SVGProps<SVGSVGElement>>;
    /**
     * Escape hatch for **trusted** raw SVG markup. Reproduces the pre-0.35
     * `svg` string behavior exactly: the markup is injected verbatim via
     * `dangerouslySetInnerHTML`, so it can execute scripts/event handlers and
     * load remote references. The name is the warning — only ever pass markup
     * you fully control (never model output or user input). For untrusted or
     * agent-generated markup use {@link IconProps.svg}, which is parsed.
     */
    dangerouslySetSvg?: string;
    /** Icon size token or explicit CSS size. */
    size?: IconSize | number | string;
    /** Explicit colour override; otherwise inherits `currentColor`. */
    color?: string | undefined;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Icon: React__default.FC<PropsWithChildren<IconProps>>;

type Variant = Variant$1;
interface TypographyOwnProps extends Presettable {
    variant?: Variant;
    italic?: boolean;
    weight?: number | WeightAlias;
    tracking?: number | 'tight' | 'normal' | 'loose';
    leading?: number | 'tight' | 'normal' | 'loose';
    optical?: 'auto' | number | 'none';
    fluid?: boolean;
    centered?: boolean;
    noSelect?: boolean;
    fontSize?: string;
    scale?: number;
    autoSize?: boolean;
    color?: string;
    /** Choose a theme font family */
    family?: 'heading' | 'body' | 'mono' | 'button';
    fontFamily?: string;
    /** Control whitespace handling for multi-line/code text */
    whitespace?: 'normal' | 'pre' | 'pre-wrap' | 'pre-line';
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Typography: PolymorphicComponent<"span", TypographyOwnProps>;

interface ModalProps extends Omit<React__default.ComponentProps<'div'>, 'style' | 'title'>, Presettable {
    /** Controlled visiblity */
    open?: boolean;
    /** Default for uncontrolled */
    defaultOpen?: boolean;
    /** Callback fired when the user requests to close (backdrop / ESC) */
    onClose?: () => void;
    /** Dialog semantics (default) or alertdialog semantics */
    variant?: 'dialog' | 'alert';
    /** Dialog title – used for aria-labelledby when provided */
    title?: ReactNode;
    /** Main body content */
    children?: ReactNode;
    /** Action buttons */
    actions?: ReactNode;
    /** Container padding override */
    pad?: Space;
    /** Compact removes container + internal paddings */
    compact?: boolean;
    /** Disable closing via backdrop click */
    disableBackdropClick?: boolean;
    /** Disable closing via ESC key */
    disableEscapeKeyDown?: boolean;
    /** Max width when not fullWidth */
    maxWidth?: number | string;
    /** Stretch to full viewport width minus gutter */
    fullWidth?: boolean;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
    /**
     * Override the root component-identity marker (defaults to `'Modal'`). A
     * composite that roots on a Modal passes its own name so the DOM node
     * identifies as that component — the AI-proxy hook.
     */
    'data-valet-component'?: string;
}
declare const Modal: React__default.FC<ModalProps>;

interface ProgressBarProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** 0–100. Omit for indeterminate. */
    value?: number;
    /** Secondary/buffer value for streaming. */
    buffer?: number;
    /** Height of the bar (px, rem, etc.). */
    height?: number | string | undefined;
    /** Override primary color. */
    color?: string | undefined;
    /** Inline styles (supports CSS vars). */
    sx?: Sx;
}
interface ProgressRingProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** 0–100. Omit for indeterminate. */
    value?: number;
    /** Diameter (px, rem, etc.). */
    size?: number | string | undefined;
    /** Stroke thickness (px, rem, etc.). */
    thickness?: number | string | undefined;
    /** Override primary color. */
    color?: string | undefined;
    /** Center content; if omitted, optionally show a percent label via `label`. */
    children?: React__default.ReactNode;
    /** Label inside the ring center. true shows 0–100%; function formats it; or pass a node. */
    label?: boolean | ((v: number) => React__default.ReactNode) | React__default.ReactNode;
    /** Auto-size ring to fit around child content (default true when children present and size not set). */
    fitChild?: boolean;
    /** Extra clearance around child when auto-sizing (px). */
    childClearance?: number;
    /** Inline styles (supports CSS vars). */
    sx?: Sx;
}
declare const ProgressBar: React__default.ForwardRefExoticComponent<ProgressBarProps & React__default.RefAttributes<HTMLDivElement>>;
declare const ProgressRing: React__default.ForwardRefExoticComponent<ProgressRingProps & React__default.RefAttributes<HTMLDivElement>>;

interface VideoSource {
    src: string;
    type: 'video/mp4' | 'video/webm' | string;
}
interface VideoTrack {
    src: string;
    kind: 'subtitles' | 'captions' | 'chapters';
    srclang: string;
    label: string;
    default?: boolean;
}
/** Props for the {@link Video} component. */
interface VideoProps extends Omit<React__default.ComponentProps<'div'>, 'style' | 'children' | 'onError' | 'onPlay' | 'onPause'>, Presettable {
    /** One or more video sources (MP4/WebM). */
    sources: VideoSource[];
    /** Poster image URL displayed before playback. */
    poster?: string;
    /** Caption or subtitle tracks. */
    tracks?: VideoTrack[];
    /** Display native controls. Defaults to `true`. */
    controls?: boolean;
    /** Autoplay when ready. Defaults to `true`. */
    autoPlay?: boolean;
    /** Mute audio. Defaults to `true` for autoplay compliance. */
    muted?: boolean;
    /** Loop video. */
    loop?: boolean;
    /** CSS width value, e.g. `100%` or `640px`. A bare number is treated as px. */
    width?: Space;
    /** CSS height value, e.g. `auto` or `360px`. A bare number is treated as px. */
    height?: Space;
    /** Lazy load when in viewport. */
    lazy?: boolean;
    /** Custom CSS object-fit. Defaults to `contain`. */
    objectFit?: 'contain' | 'cover';
    /** Playback callback. */
    onPlay?(): void;
    /** Pause callback. */
    onPause?(): void;
    /** Fires on each loop. */
    onLoop?(): void;
    /** Error callback. */
    onError?(e: ErrorEvent): void;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Video: React__default.FC<VideoProps>;

interface ImageProps extends Omit<React__default.ImgHTMLAttributes<HTMLImageElement>, 'width' | 'height' | 'style' | 'alt'>, Presettable {
    /** Image source URL */
    src: string;
    /** Required alt text. Use empty string for decorative images. */
    alt: string;
    /**
     * CSS width (number ⇒ px). When BOTH `width` and `height` are numeric they are
     * ALSO emitted as the native HTML width/height attributes, so the browser can
     * reserve layout space and avoid CLS. A string value (e.g. '50%', '20rem') is
     * CSS-only and does NOT set the intrinsic-size attributes.
     */
    width?: number | string;
    /** CSS height (number ⇒ px). See {@link ImageProps.width} re: native attrs. */
    height?: number | string;
    /** Object-fit value (maps to CSS object-fit) */
    fit?: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
    /** Object-position value (e.g., 'center', 'top', '50% 25%') */
    objectPosition?: string;
    /**
     * CSS aspect-ratio. A number is the literal width/height ratio — pass a real
     * ratio like `16 / 9` or `4 / 3` (NOT `16`, which is 16:1). Strings pass
     * through verbatim (e.g. '16 / 9').
     */
    aspectRatio?: number | string;
    /**
     * Corner radius. Number ⇒ `theme.radius(n)` (scales with density); string ⇒
     * verbatim CSS. Rounds the image itself — no wrapper needed. (A parent with
     * `overflow: hidden` is still the way to CLIP overflowing/child content.)
     */
    radius?: number | string;
    /**
     * Mark as a high-priority (above-the-fold / LCP) image: sets `loading='eager'`
     * and `fetchPriority='high'`. An explicit `loading`/`fetchPriority` still wins.
     * Default false (images load lazy + decode async).
     */
    priority?: boolean;
    /**
     * Opt-in node rendered if the image fails to load (onError). When unset, a
     * failed image behaves exactly like a native `<img>` — no wrapper, no state.
     * The caller sizes the fallback node.
     */
    fallback?: React__default.ReactNode;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Image: React__default.ForwardRefExoticComponent<ImageProps & React__default.RefAttributes<HTMLImageElement>>;

type DividerOrientation = 'horizontal' | 'vertical';
interface DividerProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'color' | 'style'>, Presettable, Pick<SpacingProps, 'pad' | 'compact'> {
    /** Orientation of the divider line. */
    orientation?: DividerOrientation;
    /** Explicit color; defaults to theme text colour against background. */
    lineColor?: string | undefined;
    /** Thickness of the line; number uses theme.stroke(n), string passes through. */
    thickness?: number | string;
    /** Length along the main axis; number ⇒ px, string passes through. */
    length?: number | string | undefined;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Divider: React__default.FC<DividerProps>;

/** Minimal API a GL program should implement to be driven by WebGLCanvas. */
type WebGLProgramLike = {
    /** Handle canvas resize in physical pixels and current DPR. */
    resize: (width: number, height: number, dpr: number) => void;
    /** Advance internal state by `dt` seconds at absolute time `t` seconds. */
    update: (dt: number, t: number) => void;
    /** Issue draw calls for the current frame. */
    render: () => void;
    /** Free any GL resources and event handlers. */
    dispose: () => void;
    /**
     * Optional: receive the absolute time `t` (seconds) each frame, in addition
     * to `update(dt, t)`. Convenience for programs that upload a `uTime` uniform
     * outside their physics step.
     */
    setTime?: (t: number) => void;
};
interface WebGLCanvasProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style' | 'children'>, Presettable {
    /**
     * Create a program bound to the provided WebGL2 context and canvas. Called
     * ONCE when the context is acquired; its identity is ref-latched, so an inline
     * arrow does NOT rebuild the program on parent re-render. To force a rebuild,
     * change the element `key`. Return `null` to signal a build failure (routes to
     * `onError` / `fallback`).
     */
    create: (gl: WebGL2RenderingContext, canvas: HTMLCanvasElement) => WebGLProgramLike | null;
    /** WebGL context attributes. Read ONCE at context creation (ref-latched). */
    contextAttributes?: WebGLContextAttributes;
    /** Clamp devicePixelRatio to avoid excessive fill-rate on hi-DPI screens. */
    dprMax?: number;
    /** Global time scaling applied to dt and absolute time t. */
    timeScale?: number;
    /** Optional clear color, defaults to transparent. Only sets clearColor, not clearing each frame. */
    clearColor?: readonly [number, number, number, number];
    /** If true, wrapper is absolutely positioned and fills its parent. */
    asBackground?: boolean;
    /**
     * Called if the WebGL2 context cannot be created (unsupported) or `create()`
     * returns null. The canvas otherwise dead-ends blank with no signal.
     */
    onError?: (err: unknown) => void;
    /** Rendered in place of the canvas when initialization fails (see `onError`). */
    fallback?: React__default.ReactNode;
    /** Inline styles for the wrapper (supports CSS variables via Sx). */
    sx?: Sx;
    /** Optional className for the inner canvas element. */
    canvasClassName?: string;
    /** Optional canvas style override. */
    canvasStyle?: React__default.CSSProperties;
}
/**
 * WebGLCanvas – A small, opinionated WebGL2 canvas host.
 * - Creates a WebGL2 context with provided attributes.
 * - Resizes the canvas to its parent using DPR-aware physical pixels.
 * - Drives a supplied program via requestAnimationFrame.
 * - Disposes cleanly on unmount (including an explicit context release).
 */
declare const WebGLCanvas: React__default.FC<WebGLCanvasProps>;

type PropsOf<E extends React.ElementType> = React.ComponentPropsWithRef<E>;
type PolymorphicRef<E extends React.ElementType> = React.ComponentPropsWithRef<E>['ref'];
type MergeProps<A, B> = Omit<A, keyof B> & B;
type PolymorphicProps<E extends React.ElementType, OwnProps> = MergeProps<PropsOf<E>, OwnProps & {
    as?: E;
}> & {
    ref?: PolymorphicRef<E>;
};
interface PolymorphicComponent<DefaultE extends React.ElementType, OwnProps> {
    <E extends React.ElementType = DefaultE>(props: PolymorphicProps<E, OwnProps>): React.ReactElement | null;
    displayName?: string;
}

/** Grid box-alignment keyword (CSS grid uses bare start/end, not flex-start). */
type GridAlign = 'start' | 'center' | 'end' | 'stretch';
interface GridOwnProps extends Presettable, Pick<SpacingProps, 'compact' | 'density'> {
    /** Equal-width column count → `repeat(N, minmax(0,1fr))`. Default 2. Responsive.
     *  Ignored when `minColWidth` is set. */
    columns?: Responsive<number>;
    /** Inter-cell gap as units or CSS length. Default 2 units (card-grid gutter). Responsive. */
    gap?: Responsive<Space>;
    /** Column-axis gap; overrides `gap` horizontally. Responsive. */
    gapX?: Responsive<Space>;
    /** Row-axis gap; overrides `gap` vertically. Responsive. */
    gapY?: Responsive<Space>;
    /** Container padding as units or CSS length. Default 1 unit. Responsive. */
    pad?: Responsive<Space>;
    /**
     * Auto-responsive track width: lay out as many equal columns as fit, each at
     * least this wide — `repeat(auto-{fit|fill}, minmax(min(<minColWidth>,100%),1fr))`.
     * Pure CSS, no breakpoints, no Surface. **Overrides `columns`.** A number is px.
     */
    minColWidth?: number | string;
    /** With `minColWidth`: `'fill'` (default) keeps a stable column count (empty
     *  trailing tracks); `'fit'` collapses empty tracks so the last row stretches. */
    autoFlow?: 'fit' | 'fill';
    /** Cross-axis (block) alignment of items in their cell (`align-items`). Default `stretch`. Responsive. */
    align?: Responsive<GridAlign>;
    /** Inline-axis alignment of items in their cell (`justify-items`). Default `stretch`. Responsive. */
    justifyItems?: Responsive<GridAlign>;
    /** Stretch children to fill their cell (width + height) so a grid of cards is
     *  uniform without per-card `fullWidth`. Default `true`. (Renamed from
     *  `normalizeRowHeights`.) */
    equalize?: boolean;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
    /** Override the machine-readable component marker (composites self-identify). */
    'data-valet-component'?: string;
}
type GridProps<E extends React__default.ElementType = 'div'> = PolymorphicProps<E, GridOwnProps>;
declare const Grid: PolymorphicComponent<"div", GridOwnProps>;
interface GridItemOwnProps extends Presettable {
    /** Column span — `grid-column: span N`. Responsive. */
    span?: Responsive<number>;
    /** Row span — `grid-row: span N`. Responsive. */
    rowSpan?: Responsive<number>;
    /** 1-based column line to start at — `grid-column-start`. Responsive. */
    colStart?: Responsive<number>;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
    /** Override the machine-readable component marker. */
    'data-valet-component'?: string;
}
type GridItemProps<E extends React__default.ElementType = 'div'> = PolymorphicProps<E, GridItemOwnProps>;
declare const GridItem: PolymorphicComponent<"div", GridItemOwnProps>;

type StackDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse';
type StackAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
/** Overflow/scroll behavior. `auto-y` (default) is the legacy behavior. */
type StackScroll = 'auto-y' | 'x' | 'both' | 'visible';
interface StackOwnProps extends Presettable, Pick<SpacingProps, 'compact' | 'density'> {
    /** Flex axis. Default `'column'`. Responsive. */
    direction?: Responsive<StackDirection>;
    /** Wrap children when they overflow the main axis. Default: `true` for rows,
     *  `false` for columns. Scalar (not responsive). */
    wrap?: boolean;
    /** Inter-child gap as units or CSS length. Default 1 unit. Responsive. */
    gap?: Responsive<Space>;
    /** Column-axis gap; overrides `gap` horizontally. Responsive. */
    gapX?: Responsive<Space>;
    /** Row-axis gap; overrides `gap` vertically. Responsive. */
    gapY?: Responsive<Space>;
    /** Container padding as units or CSS length. Default 1 unit. Responsive. */
    pad?: Responsive<Space>;
    /** Cross-axis item alignment (`align-items`). Defaults to the direction's
     *  natural alignment: row → `center`, column → `stretch`. Responsive. */
    align?: Responsive<StackAlign>;
    /** Main-axis distribution (`justify-content`). Unset by default. Responsive. */
    justify?: Responsive<StackJustify>;
    /** Horizontal placement of the whole stack when it is not full width
     *  (auto-margin anchor — distinct from `align`, which positions children). */
    alignX?: 'left' | 'center' | 'right';
    /** Node interleaved BETWEEN children (e.g. a `<Divider/>`). For a row stack,
     *  pass a vertically-oriented divider. */
    divider?: React__default.ReactNode;
    /** Overflow behavior. `'auto-y'` (default) keeps the legacy vertical-scroll. */
    scroll?: StackScroll;
    /** Grow factor when the stack is itself a flex child. `true` → 1. */
    grow?: boolean | number;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
    /** Override the machine-readable component marker (sugar/composites self-identify). */
    'data-valet-component'?: string;
}
type StackProps<E extends React__default.ElementType = 'div'> = PolymorphicProps<E, StackOwnProps>;
declare const Stack: PolymorphicComponent<"div", StackOwnProps>;
/** Horizontal stack (`direction='row'`; align defaults to `center`). */
declare const HStack: PolymorphicComponent<"div", Omit<StackOwnProps, "direction">>;
/** Vertical stack (`direction='column'`). */
declare const VStack: PolymorphicComponent<"div", Omit<StackOwnProps, "direction">>;
/** Centers its children on both axes (overridable `align`/`justify`). */
declare const Center: PolymorphicComponent<"div", StackOwnProps>;
/** Wrapping row with a consistent gap — tags, chips, button clusters. */
declare const Cluster: PolymorphicComponent<"div", Omit<StackOwnProps, "direction">>;
interface SpacerProps {
    /** Grow factor; how much free space this filler absorbs. Default 1. */
    grow?: number;
    className?: string;
    style?: React__default.CSSProperties;
}
/** A flexible spacer that pushes siblings apart inside a Stack (any direction). */
declare const Spacer: React__default.FC<SpacerProps>;

interface ChildMetrics {
    width: number;
    height: number;
    top: number;
    left: number;
}
interface SurfaceState {
    width: number;
    height: number;
    breakpoint: Breakpoint;
    hasScrollbar: boolean;
    element: HTMLDivElement | null;
    /**
     * Registry of child metrics keyed by registration id. The Map is
     * replaced wholesale on each batched commit, so subscribing to it
     * re-notifies for *any* child change — prefer the `cb` argument of
     * `registerChild` for per-element metrics.
     * @deprecated Kept for compatibility (do not remove — veto register);
     * slated to leave the public surface in a future major.
     */
    children: Map<string, ChildMetrics>;
    registerChild: (id: string, node: HTMLElement, cb?: (metrics: ChildMetrics) => void) => void;
    unregisterChild: (id: string) => void;
}
declare function useSurface(): SurfaceState;
declare function useSurface<U>(selector: (state: SurfaceState) => U, equality?: (a: U, b: U) => boolean): U;

interface SurfaceProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** Fixed-position full-screen surface when true (default). */
    fullscreen?: boolean;
    /** Optional density override for spacing scale */
    density?: Density;
    /**
     * Zeros all layout spacing and cascades to descendants; opt out with
     * compact={false}. Independent of the density scale.
     */
    compact?: boolean;
    /**
     * When true, block content visibility until fonts load (FOIT).
     * Defaults to false for immediate first paint using fallbacks.
     */
    blockUntilFonts?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Surface: React__default.FC<SurfaceProps>;

interface BoxOwnProps extends Presettable, Pick<SpacingProps, 'pad' | 'compact'> {
    background?: string | undefined;
    textColor?: string | undefined;
    /** Center inner content (layout inside the box) */
    centerContent?: boolean;
    /** Stretch to 100% width of container when true */
    fullWidth?: boolean;
    /** Horizontal placement of the box when not fullWidth */
    alignX?: 'left' | 'right' | 'center';
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Box: PolymorphicComponent<"div", BoxOwnProps>;

type PanelVariant = 'filled' | 'outlined';
interface PanelProps extends Omit<React__default.ComponentProps<'div'>, 'style'>, Presettable, Pick<SpacingProps, 'pad' | 'compact' | 'density'> {
    /** Visual variant: filled | outlined */
    variant?: PanelVariant;
    /** Semantic color intent; maps to theme tokens */
    intent?: Intent;
    /** Explicit color override (theme token name or CSS color) */
    color?: string | undefined;
    fullWidth?: boolean;
    /** Centre contents & propagate intent via CSS var */
    centerContent?: boolean;
    /** Horizontal placement of the panel when not fullWidth */
    alignX?: 'left' | 'right' | 'center';
    /**
     * Opt out of row height normalization (when a parent Grid enables it).
     * Defaults to true (normalize). Set to false to keep intrinsic heights.
     */
    normalizeRowHeights?: boolean;
    /**
     * Override the root component-identity marker (defaults to `'Panel'`). A
     * composite component that roots on a Panel passes its own name so the DOM
     * node identifies as that component — the "AI proxies as first-class users"
     * hook. Omit it and the Panel marks itself.
     */
    'data-valet-component'?: string;
}
/** Inline styles (with CSS var support) */
interface PanelProps {
    sx?: Sx;
}
declare const Panel: React__default.FC<PanelProps>;

type ButtonVariant = 'filled' | 'outlined' | 'plain';
type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
/**
 * Behavior-only props. Element attributes (onClick, disabled, type, …)
 * deliberately do NOT live here — they flow from `PropsOf<E>` inside
 * `PolymorphicProps`, so `<Button as='a'>` gets anchor attributes and
 * anchor-typed handlers instead of button ones.
 */
interface ButtonOwnProps extends Presettable {
    /** Semantic color intent (maps to theme tokens). */
    intent?: Intent;
    /** Visual variant: filled | outlined | plain. */
    variant?: ButtonVariant;
    /** Explicit color override (any CSS color or theme token name). */
    color?: string;
    size?: ButtonSize | number | string;
    fullWidth?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
/**
 * The runtime strips `type` when rendering an anchor (see ButtonImpl),
 * so the type level refuses it up front instead of silently dropping it.
 */
type AnchorTypeGuard$1<E extends React__default.ElementType> = E extends 'a' ? {
    type?: never;
} : unknown;
/** Fully resolved Button props for a given element type. */
type ButtonProps<E extends React__default.ElementType = 'button'> = PolymorphicProps<E, ButtonOwnProps> & AnchorTypeGuard$1<E>;
interface ButtonComponent {
    <E extends React__default.ElementType = 'button'>(props: ButtonProps<E>): React__default.ReactElement | null;
    displayName?: string;
}
declare const Button: ButtonComponent;

/**
 * Which stage of a value interaction an event represents.
 *
 * - `'input'` — a transient, in-progress value (e.g. a slider mid-drag, a
 *   keystroke before the field is committed). Fires through `onValueChange`.
 * - `'commit'` — a settled value the consumer should treat as final (e.g.
 *   blur, Enter, an option chosen). Fires through both `onValueChange` (with
 *   `phase: 'input'`) and `onValueCommit` (with `phase: 'commit'`).
 *
 * Contract: every `onValueCommit` payload carries `phase: 'commit'`. Every
 * `onValueChange` payload carries `phase: 'input'` (a commit emits the change
 * with `'input'` first, then the commit with `'commit'`).
 */
type InputPhase = 'input' | 'commit';
/**
 * The honest origin of a value change — what the *user* (or program) actually
 * did, not how the component happens to wire its handlers. This is the
 * agent-facing promise of the library: a tool reading `ChangeInfo.source`
 * learns whether a value came from typing, a click, a paste, a scroll wheel,
 * or a programmatic write.
 *
 * Vocabulary (every member is emitted by at least one component — see the
 * classification table below; none is vestigial, so the union is not narrowed):
 *
 * - `'keyboard'` — typing into a text field, Space/Enter activation of a
 *   toggle/option, and arrow/Page/Home/End navigation that changes a value.
 * - `'pointer'` — a genuine mouse/touch/pen click, tap, or drag.
 * - `'clipboard'` — paste or drag-and-drop of text into a field
 *   (`InputEvent.inputType` of `insertFromPaste*` or `insertFromDrop`).
 * - `'wheel'` — a scroll-wheel gesture that steps a value (Iterator).
 * - `'programmatic'` — a value written by code (a dispatched synthetic event
 *   with no real user input, or a commit path with no associated DOM event,
 *   e.g. TextField blur).
 *
 * ─────────────────────────────────────────────────────────────────────────
 *  CANONICAL CLASSIFICATION TABLE (ruling R10)
 *
 *  This is the contract the FIELDS migrations implement and the cross-field
 *  matrix in `events.contract.dom.test.tsx` gates uniformly. A field whose
 *  emitted `source` disagrees with this table is a FIELDS bug — the matrix
 *  flags it; this contract is not edited to match a drifting field.
 *
 *  Component     Interaction                         phase           source
 *  ───────────   ─────────────────────────────────   ─────────────   ────────────
 *  TextField     typing                              input           keyboard
 *  TextField     paste / drop                        input           clipboard
 *  TextField     Enter (commit)                      commit          keyboard
 *  TextField     blur (commit)                       commit          programmatic
 *  TextField     programmatic value + dispatch       input           programmatic
 *  Checkbox      pointer click (detail ≥ 1)          input + commit  pointer
 *  Checkbox      keyboard activation (detail 0)      input + commit  keyboard
 *  Checkbox      programmatic change (non-Mouse)     input + commit  programmatic
 *  Switch        pointer click (detail ≥ 1)          input + commit  pointer
 *  Switch        keyboard activation (detail 0)      input + commit  keyboard
 *  RadioGroup    pointer click (detail ≥ 1)          input + commit  pointer
 *  RadioGroup    keyboard activation (detail 0)      input + commit  keyboard
 *  RadioGroup    programmatic change (non-Mouse)     input + commit  programmatic
 *  Select        option pointer click                input + commit  pointer
 *  Select        option keyboard (Enter/Space)       input + commit  keyboard
 *  MetroSelect   tile pointer click                  input + commit  pointer
 *  MetroSelect   tile keyboard (Enter/Space)         input + commit  keyboard
 *  Slider        pointer drag / click                input + commit  pointer
 *  Slider        arrow / Page / Home / End keys      commit          keyboard
 *  Slider        programmatic commit (no event)      *               programmatic
 *  Iterator      +/- buttons                         commit          pointer
 *  Iterator      arrow/Page/Home/End/Enter/blur/type input + commit  keyboard
 *  Iterator      wheel step                          commit          wheel
 *  Iterator      programmatic commit (default)       *               programmatic
 *  DateSelector  day-cell click                      input + commit  pointer
 *  Tabs          tab pointer click                   input + commit  pointer
 *  Tabs          arrow-key navigation                input + commit  keyboard
 *
 *  Classification primitives (how fields derive `source` from a native event):
 *  - A synthesized `MouseEvent` with `detail === 0` is keyboard activation
 *    (Space/Enter on a focused button/checkbox/radio); `detail >= 1` is a
 *    genuine pointer press. (Checkbox/Switch/RadioGroup, and Tabs clicks.)
 *  - A text `InputEvent` whose `inputType` starts with `insertFromPaste` or is
 *    `insertFromDrop` is `'clipboard'`; any other `inputType` is `'keyboard'`.
 *    A non-`InputEvent` native event on a text control is `'programmatic'`.
 *    (TextField.)
 *  - Components with no native DOM event in the path (Select/MetroSelect/
 *    Slider/Iterator/DateSelector/Tabs) pass `source` explicitly per handler.
 * ─────────────────────────────────────────────────────────────────────────
 */
type InputSource = 'keyboard' | 'pointer' | 'programmatic' | 'clipboard' | 'wheel';
/**
 * Metadata that accompanies every canonical value event.
 *
 * @typeParam T - the component's value type.
 *
 * @property name          The field's form `name`, when bound to a FormControl.
 * @property previousValue The value before this change (for diffing/undo).
 * @property phase         {@link InputPhase} — `'input'` (transient) or `'commit'`.
 * @property source        {@link InputSource} — the honest origin of the change.
 * @property event         The originating React synthetic event, when one exists
 *                          (absent for programmatic and pointer-drag paths).
 */
interface ChangeInfo<T> {
    name?: string;
    previousValue?: T;
    phase: InputPhase;
    source: InputSource;
    event?: React.SyntheticEvent;
}
/**
 * The canonical transient-change handler. Called on every in-progress value
 * with `info.phase === 'input'`. A committing interaction fires this first
 * (phase `'input'`) and then {@link OnValueCommit} (phase `'commit'`).
 */
type OnValueChange<T> = (value: T, info: ChangeInfo<T>) => void;
/**
 * The canonical commit handler. Called when a value settles, always with
 * `info.phase === 'commit'`.
 */
type OnValueCommit<T> = (value: T, info: ChangeInfo<T>) => void;

type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface CheckboxProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'onChange' | 'value' | 'defaultValue' | 'style' | 'name'>, FieldBaseProps {
    /**
     * Field name used for FormControl binding and form submission. When `bindForm` is false,
     * `name` may be omitted and no form binding/submission occurs.
     */
    name?: string;
    /** Disable FormControl binding and omit name from submission. */
    bindForm?: boolean;
    checked?: boolean;
    defaultChecked?: boolean;
    /** Visual size; token or CSS length. */
    size?: CheckboxSize | number | string;
    /** DOM-parity change event (raw React event). */
    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
    /** Canonical value change event (fires on each mutation). */
    onValueChange?: OnValueChange<boolean>;
    /** Commit event (fires at the same moment for toggles). */
    onValueCommit?: OnValueCommit<boolean>;
    /** Mixed (indeterminate) visual state for parent selections. */
    indeterminate?: boolean;
}
declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLInputElement>>;

/**
 * Runtime state slice for any form.
 *
 * Contract (pinned by `createFormStore.test.ts`; relied on by the shared
 * field hooks in `src/hooks/useControlledState.ts`, ruling R9):
 *
 * - The store is **values-only** — no validation/errors/touched tracking.
 * - `values` holds the **exact** object passed to `createFormStore` until
 *   the first write (no defensive clone), and `reset` restores that exact
 *   initial reference.
 * - Keys are fixed at creation time. Form-bound fields (`name` inside a
 *   `FormControl`) expect their key to be **seeded in `initial`**: an
 *   unseeded key reads as `undefined`, so the field renders its
 *   `defaultValue ?? fallback` as a controlled value and dev-warns once.
 *   Fields NEVER write to the store on mount — an unseeded key stays
 *   absent from submit/reset values until the first user edit.
 */
interface FormStore<T extends Record<string, unknown>> {
    /** Current values keyed by field name. */
    values: T;
    /**
     * Imperative setter for a single field. Every call replaces `values`
     * with a fresh object — even an identity write (same value) produces a
     * new `values` reference, so subscribers always fire; identities of
     * untouched fields are preserved. `setField`/`reset` keep stable
     * function identity across writes.
     */
    setField: <K extends keyof T>(key: K, value: T[K]) => void;
    /** Resets all values to their original defaults (the exact initial reference). */
    reset: () => void;
}
/**
 * **createFormStore** – one-liner helper that returns a _typed_ Zustand hook
 * for local form state.
 *
 * ```ts
 * const useLoginForm = createFormStore({ email:'', password:'' });
 * ```
 *
 * Seed **every** key a bound field will use — `{ email: '' }`, not `{}`.
 * The store is the single reading source for form-bound fields (precedence:
 * explicit `value` prop > form binding > internal state), and because fields
 * never write on mount, keys missing from `initial` are invisible to
 * `onSubmitValues`/`reset` until the user first edits the field.
 *
 * Separate stores never share state; two stores built from one shared
 * `initial` object stay isolated (writes are copy-on-write).
 */
declare function createFormStore<T extends Record<string, unknown>>(initial: T): zustand_traditional.UseBoundStoreWithEqualityFn<zustand.StoreApi<FormStore<T>>>;

declare const useForm: <T extends Record<string, unknown> = Record<string, unknown>>() => FormStore<T>;
declare const useOptionalForm: <T extends Record<string, unknown> = Record<string, unknown>>() => FormStore<T> | null;
/** Presentation-level form configuration shared with every bound field. */
interface FormConfig {
    /** Disable every bound field in this form (e.g. while submitting). */
    disabled: boolean;
    /** Name-keyed error messages; a bound field with a matching `name` shows it. */
    errors: Record<string, React__default.ReactNode>;
    /** True while an async `onSubmitValues` is in flight. */
    isSubmitting: boolean;
}
/**
 * Read the ambient form configuration. Returns inert defaults (nothing
 * disabled, no errors, not submitting) when called outside a `<FormControl>`,
 * so bound fields can consume it unconditionally.
 */
declare function useFormConfig(): FormConfig;
interface FormControlProps<T extends Record<string, unknown>> extends Omit<React__default.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'style'>, Presettable {
    /**
     * The **Zustand hook** produced by `createFormStore(initialValues)`.
     * It’s the usual `const useForm = createFormStore(...)` function.
     */
    useStore: UseBoundStore<StoreApi<FormStore<T>>>;
    /**
     * Fires after native submit is intercepted – gives you typed values. May
     * return a Promise; while it is pending the form is `aria-busy` and every
     * bound field sees `isSubmitting` via `useFormConfig()`.
     */
    onSubmitValues?: (values: T, event: React__default.FormEvent<HTMLFormElement>) => void | Promise<unknown>;
    /** Disable every bound field in this form. */
    disabled?: boolean;
    /** Name-keyed error messages; a bound field whose `name` matches shows the error. */
    errors?: Record<string, React__default.ReactNode>;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare function FormControl<T extends Record<string, unknown>>({ useStore, onSubmitValues, disabled, errors, preset: p, className, sx, children, ...rest }: FormControlProps<T>): react_jsx_runtime.JSX.Element;

type IconButtonVariant = 'filled' | 'outlined' | 'plain';
type IconButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
/**
 * Behavior-only props. Element attributes (onClick, disabled, type, …)
 * deliberately do NOT live here — they flow from `PropsOf<E>` inside
 * `PolymorphicProps`, so `<IconButton as='a'>` gets anchor attributes
 * and anchor-typed handlers instead of button ones.
 */
interface IconButtonOwnProps extends Presettable {
    variant?: IconButtonVariant;
    size?: IconButtonSize | number | string;
    icon?: string;
    svg?: string | ReactElement<SVGProps<SVGSVGElement>>;
    intent?: Intent;
    /** Explicit color override (theme token or CSS color). */
    color?: string;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
/**
 * The runtime strips `type` when rendering an anchor (see IconButtonImpl),
 * so the type level refuses it up front instead of silently dropping it.
 */
type AnchorTypeGuard<E extends React__default.ElementType> = E extends 'a' ? {
    type?: never;
} : unknown;
/** Fully resolved IconButton props for a given element type (back-compat alias). */
type IconButtonProps<E extends React__default.ElementType = 'button'> = PolymorphicProps<E, IconButtonOwnProps> & AnchorTypeGuard<E>;
interface IconButtonComponent {
    <E extends React__default.ElementType = 'button'>(props: IconButtonProps<E>): React__default.ReactElement | null;
    displayName?: string;
}
declare const IconButton: IconButtonComponent;

type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface RadioGroupProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'style'>, FieldBaseProps {
    value?: string;
    defaultValue?: string;
    row?: boolean;
    size?: RadioSize | number | string;
    /** Disable every radio in the group (a radio's own `disabled` still wins). */
    disabled?: boolean;
    /** Gap between options as spacing units or a CSS length. */
    gap?: Space;
    /** DOM-parity change event (raw input event). */
    onChange?: (event: React__default.ChangeEvent<HTMLInputElement>) => void;
    /** Canonical value change event (fires on selection). */
    onValueChange?: OnValueChange<string>;
    /** Commit event (fires same moment for radios). */
    onValueCommit?: OnValueCommit<string>;
    children: ReactNode;
}
interface RadioProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'onChange' | 'style'>, Presettable {
    value: string;
    label?: string;
    size?: RadioSize | number | string;
    children?: ReactNode;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const RadioGroup: React__default.FC<RadioGroupProps>;
declare const Radio: React__default.ForwardRefExoticComponent<RadioProps & React__default.RefAttributes<HTMLInputElement>>;

type Primitive$1 = string | number;
type SelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface SelectProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'defaultValue' | 'children' | 'style' | 'value'>, FieldBaseProps {
    /** Controlled value (single) or array (multiple). */
    value?: Primitive$1 | Primitive$1[];
    /** Uncontrolled default value. */
    defaultValue?: Primitive$1 | Primitive$1[];
    /** Canonical value change event (fires on selection). */
    onValueChange?: OnValueChange<Primitive$1 | Primitive$1[]>;
    /** Commit event (fires on selection/confirm). */
    onValueCommit?: OnValueCommit<Primitive$1 | Primitive$1[]>;
    /** Multiple-selection mode. */
    multiple?: boolean;
    /** Placeholder when nothing selected. */
    placeholder?: string;
    /** Size token or custom measurement */
    size?: SelectSize | number | string;
    /** Explicit field width — number → px, or any CSS length. Overrides the
     *  default `width:100%`. */
    width?: number | string;
    disabled?: boolean;
    /** Option nodes (see Select.Option). */
    children: React__default.ReactNode;
}
interface OptionProps extends React__default.LiHTMLAttributes<HTMLLIElement>, Presettable {
    value: Primitive$1;
    disabled?: boolean;
    /** Inline styles (with CSS var support); merged over `style` (sx wins). */
    sx?: Sx;
}
declare const Option: React__default.FC<OptionProps>;
declare const Forward: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLButtonElement>> & {
    Option: typeof Option;
};

type Primitive = string | number;
interface MetroSelectProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'value' | 'defaultValue' | 'style'>, FieldBaseProps, Pick<SpacingProps, 'compact'> {
    value?: Primitive | Primitive[];
    defaultValue?: Primitive | Primitive[];
    /** Inter-tile spacing as units or CSS length. */
    gap?: Space;
    multiple?: boolean;
    /** Visual size of the tiles; token or explicit CSS size. */
    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number | string;
    /** Disable the entire control. */
    disabled?: boolean;
    onValueChange?: OnValueChange<Primitive | Primitive[]>;
    onValueCommit?: OnValueCommit<Primitive | Primitive[]>;
    children: React__default.ReactNode;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
interface MetroOptionProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    value: Primitive;
    icon: string | React__default.ReactElement;
    label: React__default.ReactNode;
    disabled?: boolean;
    /** Flat resting fill for this tile (theme token name or CSS colour). Enables
     *  the multi-colour Metro mosaic; omitted → a neutral tile. */
    color?: string;
    /** Render a wide 2×1 tile (spans two columns + the gutter, same height). */
    wide?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
interface MetroSelectComponent extends React__default.FC<MetroSelectProps> {
    Option: React__default.FC<MetroOptionProps>;
}
declare const MetroSelect: MetroSelectComponent;

type SliderSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SnapMode = 'none' | 'step' | 'presets';
interface SliderProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'style'>, FieldBaseProps {
    /** Controlled value. */
    value?: number;
    /** Default for uncontrolled usage. */
    defaultValue?: number;
    /** Canonical value change (pointer drag, keyboard). */
    onValueChange?: OnValueChange<number>;
    /** Commit event (pointer up, blur, or Enter/Page/Home/End key). */
    onValueCommit?: OnValueCommit<number>;
    /** Minimum allowed value. */
    min?: number;
    /** Maximum allowed value. */
    max?: number;
    /** Fixed increment when `snap="step"`; defaults to 1. */
    step?: number;
    /** Preset snap points when `snap="presets"`. */
    presets?: number[];
    /** Snap behaviour. */
    snap?: SnapMode;
    /** Number of decimal places allowed. Default 0 (integers only). */
    precision?: number;
    /** Show live numeric value above thumb. */
    showValue?: boolean;
    /** Show min/max labels beneath the track ends. */
    showMinMax?: boolean;
    /** Show tick marks (follows snap points or `ticks`). */
    showTicks?: boolean;
    /** Custom tick set (overrides derived ticks). */
    ticks?: number[];
    size?: SliderSize | number | string;
    disabled?: boolean;
}
declare const Slider: React__default.ForwardRefExoticComponent<SliderProps & React__default.RefAttributes<HTMLDivElement>>;

type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface SwitchProps extends Omit<React__default.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'style' | 'name'>, FieldBaseProps {
    /** Controlled checked state. */
    checked?: boolean;
    /** Default state for uncontrolled usage. */
    defaultChecked?: boolean;
    /** Canonical value change event (fires on each toggle). */
    onValueChange?: OnValueChange<boolean>;
    /** Commit event (same moment for toggles). */
    onValueCommit?: OnValueCommit<boolean>;
    /** Visual size; defaults to `md`. */
    size?: SwitchSize;
}
declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & React__default.RefAttributes<HTMLButtonElement>>;

type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'name' | 'style' | 'size'>;
type TextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'name' | 'style' | 'size'>;
type TextFieldSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
/** Visual variant. Only `outlined` is implemented for 1.0; `filled`/`underline`
 *  are declared for forward-compat and currently render as outlined. */
type TextFieldVariant = 'outlined' | 'filled' | 'underline';
interface TextFieldOwn {
    /** Override input font. */
    fontFamily?: string;
    /** Field name is required for TextField to bind and identify the value. */
    name: string;
    /** Visual variant (only `outlined` implemented for 1.0). Default `outlined`. */
    variant?: TextFieldVariant;
    /** Size token. Default `md`. */
    size?: TextFieldSize;
    /** Explicit field width — number → px, or any CSS length. Overrides the
     *  default `width:100%`. */
    width?: number | string;
    /** Mark the field required (visible `*`, `aria-required`, native `required`). */
    required?: boolean;
    /** Validation message shown in the role='alert' region when `error` (or a
     *  matching FormControl error). Falls back to `helperText`. */
    errorText?: React__default.ReactNode;
}
type TextFieldProps = (FieldBaseProps & TextFieldOwn & {
    /** DOM-parity change event (raw React event). */
    onChange?: ChangeEventHandler<HTMLInputElement>;
    /** Canonical value change event (fires on each input). */
    onValueChange?: OnValueChange<string>;
    /** Commit event (on Enter or blur). */
    onValueCommit?: OnValueCommit<string>;
} & InputProps & {
    as?: 'input';
}) | (FieldBaseProps & TextFieldOwn & {
    /** DOM-parity change event (raw React event). */
    onChange?: ChangeEventHandler<HTMLTextAreaElement>;
    /** Canonical value change event (fires on each input). */
    onValueChange?: OnValueChange<string>;
    /** Commit event (on blur). Enter inserts newline for textarea. */
    onValueCommit?: OnValueCommit<string>;
} & TextareaProps & {
    as: 'textarea';
});
declare const TextField: React__default.ForwardRefExoticComponent<TextFieldProps & React__default.RefAttributes<HTMLInputElement | HTMLTextAreaElement>>;

/**
 * Every internal user-facing string valet renders without a prop
 * escape hatch today, grouped by component. Values are either plain
 * strings or formatter functions for interpolated labels — both are
 * treated as replace-whole leaves by {@link mergeStrings}.
 *
 * Each default in {@link enStrings} is the verbatim literal from the
 * component source cited next to it.
 */
interface ValetStrings {
    /** Chip.tsx:241–242 — delete affordance (aria-label + title). */
    chip: {
        remove: string;
    };
    /** Drawer.tsx:338 / :393 — persistent-toggle + close buttons. */
    drawer: {
        openDrawer: string;
        closeDrawer: string;
    };
    /** Pagination.tsx:993–1206 — page-navigation labels. */
    pagination: {
        /** :993 — aria-label on the <nav> root. */
        root: string;
        /** :1017 — window-scroll « button. */
        scrollPagesLeft: string;
        /** :1206 — window-scroll » button. */
        scrollPagesRight: string;
        /** :1028/:1031 — single-step ‹ button (aria-label + title). */
        previousPage: string;
        /** :1194/:1197 — single-step › button (aria-label + title). */
        nextPage: string;
        /** :1148 — per-page-button aria-label. */
        pageLabel: (page: number, isCurrent: boolean) => string;
        /** :1150 — per-page-button title. */
        goToPage: (page: number) => string;
    };
    /** Iterator.tsx:277 / :303 — stepper buttons (verbatim lowercase). */
    iterator: {
        decrement: string;
        increment: string;
    };
    /** SpeedDial.tsx — main FAB aria-label + actions-group aria-label. */
    speedDial: {
        mainButton: string;
        /** Disclosure `role='group'` actions-container aria-label. */
        actions: string;
    };
    /** Dropzone.tsx — instructions + per-file remove + live region. */
    dropzone: {
        /** per-file remove button aria-label. */
        removeFile: (fileName: string) => string;
        /** per-file remove button title. */
        removeFileTitle: string;
        /** file-list visible remove button text (short form). */
        remove: string;
        /** instruction while a drag is active. */
        instructionsActive: string;
        /** idle instruction. */
        instructionsIdle: string;
        /** rejection live-region fallback message. */
        fileRejected: string;
        /** rejection message for files dropped past the cumulative `maxFiles` limit. */
        tooManyFiles: string;
    };
    /** LoadingBackdrop.tsx:64 — spinner aria-label. */
    loadingBackdrop: {
        loading: string;
    };
    /**
     * LLMChat.tsx:314 / :424. The adjacent 'Connected'/'Disconnected'
     * status text (:312) is key-flow UI deferred with KeyModal to Q8.
     */
    llmChat: {
        setApiKey: string;
        send: string;
    };
    /** RichChat.tsx:557 — send button aria-label. */
    richChat: {
        send: string;
    };
    /** DateSelector.tsx:371–447 — month/year navigation aria-labels. */
    dateSelector: {
        previousYear: string;
        previousMonth: string;
        nextMonth: string;
        nextYear: string;
    };
}
/** Deep-partial of a string table; formatter leaves stay whole. */
type DeepPartialStrings<T> = {
    [K in keyof T]?: T[K] extends (...args: never[]) => unknown ? T[K] : T[K] extends object ? DeepPartialStrings<T[K]> : T[K];
};
/** Partial override shape accepted by the provider / mergeStrings. */
type PartialValetStrings = DeepPartialStrings<ValetStrings>;
/**
 * Complete built-in English defaults — every value verbatim from the
 * component literal it replaces (citations on {@link ValetStrings}).
 */
declare const enStrings: ValetStrings;
/**
 * Deep-merges a partial string table over a complete base.
 *
 * • Plain-object branches merge recursively; string/function leaves
 *   replace wholesale.
 * • `undefined` values in the partial are skipped (never clobber).
 * • Returns `base` by reference when `partial` is absent; untouched
 *   branches keep their `base` reference identity.
 * • Never mutates either argument.
 */
declare function mergeStrings<T extends object>(base: T, partial?: DeepPartialStrings<T>): T;
/**
 * True when the locale's writing direction is right-to-left.
 *
 * Resolution order: `Intl.Locale` textInfo (spec `getTextInfo()`
 * method, then the legacy `textInfo` accessor) → script subtag
 * (explicit or via `maximize()`) against a static RTL-script list →
 * primary-language fallback list. Malformed tags return `false`.
 */
declare function isRtlLocale(locale: string): boolean;
type ValetDir = 'ltr' | 'rtl';
/** Context payload: resolved locale, complete string table, direction. */
interface ValetLocaleContextValue {
    locale: string;
    strings: ValetStrings;
    dir: ValetDir;
}
interface ValetLocaleProviderProps {
    /** BCP-47 tag. Default 'en-US' ('auto' is a post-1.0 opt-in). */
    locale?: string;
    /** Deep-partial overrides merged over the built-in English table. */
    strings?: PartialValetStrings;
    /** Explicit direction; derived from `locale` via isRtlLocale when omitted. */
    dir?: ValetDir;
    children?: React__default.ReactNode;
}
/**
 * Supplies `{ locale, strings, dir }` to every valet component below
 * it. Plain React context — deliberately not a zustand store.
 *
 * Overrides always resolve against the built-in English table
 * (provider > built-in); nesting providers does not chain-merge —
 * the innermost provider wins wholesale. Pass stable `strings`
 * references: the context value is memoised on
 * `[locale, strings, dir]`, so a fresh object literal per render
 * defeats the memo.
 */
declare const ValetLocaleProvider: React__default.FC<ValetLocaleProviderProps>;
/**
 * Read the active locale context. Without a provider this returns the
 * frozen default (`locale: 'en-US'`, `enStrings`, `dir: 'ltr'`) — the
 * same object on every call, safe for dependency arrays.
 */
declare function useValetLocale(): ValetLocaleContextValue;
/**
 * Resolves one component's slice of the string table following the
 * documented three-tier contract:
 *
 *   instance `labels` prop  >  provider `strings`  >  built-in English
 *
 * The provider value (`useValetLocale().strings`) already merges its
 * overrides over the built-in English table, so this hook only needs to
 * layer the instance-level `labels` prop on top of the resolved provider
 * slice. Untouched leaves keep the provider/English reference.
 *
 * @param key    the {@link ValetStrings} slice this component renders.
 * @param labels optional instance-level deep-partial override.
 *
 * @example
 *   const t = useComponentStrings('chip', labels);
 *   // t.remove === labels?.remove ?? provider.chip.remove ?? 'Remove'
 */
declare function useComponentStrings<K extends keyof ValetStrings>(key: K, labels?: DeepPartialStrings<ValetStrings[K]>): ValetStrings[K];

interface IteratorProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'style' | 'name'>, FieldBaseProps {
    value?: number;
    defaultValue?: number;
    /** Canonical value change event (fires on each mutation). */
    onValueChange?: OnValueChange<number>;
    /** Commit event (buttons, wheel, keyboard final, or blur). */
    onValueCommit?: OnValueCommit<number>;
    min?: number;
    max?: number;
    step?: number;
    /**
     * When true, committing also happens while typing for any parsable number.
     * Defaults to false to avoid interrupting intermediate states like "1." or "-".
     */
    commitOnChange?: boolean;
    /**
     * If true, coerces committed values to align to `step` from the origin (min if provided, else 0).
     */
    roundToStep?: boolean;
    /**
     * Control mouse wheel behavior: off | focus | hover (default: focus)
     *  - off: disable wheel-based stepping
     *  - focus: only step when the field has focus
     *  - hover: step while hovered (prevents page scroll while over the input)
     */
    wheelBehavior?: 'off' | 'focus' | 'hover';
    /** Control width of the numeric field (token or CSS length). */
    width?: number | string;
    /** Visual style for the −/+ stepper buttons. Defaults to `'outlined'`. */
    buttonVariant?: IconButtonVariant;
    /**
     * Instance-level overrides for this component's i18n strings. Wins over the
     * `ValetLocaleProvider` value, which in turn wins over the built-in English
     * defaults (A11Y S8 resolution contract; see `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['iterator']>;
}
declare const Iterator: React__default.ForwardRefExoticComponent<IteratorProps & React__default.RefAttributes<HTMLInputElement>>;

interface AccordionProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange'>, Presettable, Pick<SpacingProps, 'pad' | 'compact'> {
    /** Uncontrolled seed: index (or indices) expanded on first render. */
    defaultExpanded?: number | number[];
    /** Controlled expanded index (or indices). */
    expanded?: number | number[];
    multiple?: boolean;
    /** Fires with the next expanded indices whenever the user toggles a panel. */
    onExpandedChange?: (expanded: number[]) => void;
    headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
    constrainHeight?: boolean;
    unmountOnExit?: boolean;
    /** Inline styles via CSSProperties (with CSS var support) */
    sx?: Sx;
}
interface AccordionItemProps extends React__default.HTMLAttributes<HTMLDivElement>, Presettable {
    header: ReactNode;
    index?: number;
    disabled?: boolean;
    children: ReactNode;
    /** Inline styles via CSSProperties (with CSS var support) */
    sx?: Sx;
}
declare const Accordion: React__default.FC<AccordionProps> & {
    Item: React__default.FC<AccordionItemProps>;
};

type AppBarToken = 'primary' | 'secondary' | 'tertiary';
interface AppBarProps extends Omit<React__default.HTMLAttributes<HTMLElement>, 'style' | 'title'>, Presettable {
    /** Semantic color intent; maps to theme tokens */
    intent?: Intent;
    /** Explicit color override (theme token name or CSS color) */
    color?: string;
    /** Optional explicit text color override */
    textColor?: string;
    left?: React__default.ReactNode;
    right?: React__default.ReactNode;
    /** Optional brand/logo node, typically an SVG */
    logo?: React__default.ReactNode;
    /** Optional primary title to the right of the logo */
    title?: React__default.ReactNode;
    /** Spacing between logo and title */
    logoGap?: Space;
    pad?: Space;
    /** Whether the bar is fixed to the viewport (and offsets content). Defaults to true. */
    fixed?: boolean;
    /** Force portal behavior. Defaults to following `fixed` (true when fixed). */
    portal?: boolean;
    /** Optional navigation buttons; rendered inline for page-level navigation */
    navigation?: AppBarNavigationItem[];
    /** Where navigation buttons live; auto centers when both sides are populated */
    navigationAlign?: 'left' | 'center' | 'right' | 'auto';
    /** ARIA label for the navigation group */
    navigationLabel?: string;
    /** Gap between navigation buttons */
    navigationGap?: Space;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
interface AppBarNavigationItem {
    id?: string;
    label?: React__default.ReactNode;
    icon?: React__default.ReactNode;
    /** Provide when using icon-only buttons for accessible name. Falls back to label text. */
    ariaLabel?: string;
    /** Force icon-only rendering (no label). */
    iconOnly?: boolean;
    href?: string;
    target?: string;
    rel?: string;
    disabled?: boolean;
    active?: boolean;
    intent?: Intent;
    variant?: ButtonVariant;
    onClick?: React__default.MouseEventHandler<HTMLButtonElement | HTMLAnchorElement>;
}
declare const AppBar: React__default.FC<AppBarProps>;

type AIProvider = 'openai' | 'anthropic';
type KeyState = {
    apiKey: string | null;
    provider: AIProvider | null;
    model: string | null;
    cipher: string | null;
    setKey: (k: string, provider: AIProvider, pass?: string) => Promise<void>;
    setModel: (m: string) => void;
    applyPassphrase: (pass: string) => Promise<boolean>;
    clearKey: () => void;
};
declare const useAIKey: zustand_traditional.UseBoundStoreWithEqualityFn<Omit<zustand.StoreApi<KeyState>, "persist"> & {
    persist: {
        setOptions: (options: Partial<zustand_middleware.PersistOptions<KeyState, unknown>>) => void;
        clearStorage: () => void;
        rehydrate: () => Promise<void> | void;
        hasHydrated: () => boolean;
        onHydrate: (fn: (state: KeyState) => void) => () => void;
        onFinishHydration: (fn: (state: KeyState) => void) => () => void;
        getOptions: () => Partial<zustand_middleware.PersistOptions<KeyState, unknown>>;
    };
}>;
type ChatMessage$1 = {
    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
    content: string;
    name?: string;
};
/**
 * Normalized chat-completion result returned by {@link sendChat}. Both the
 * OpenAI and Anthropic branches resolve to this shape (the OpenAI completion
 * already carries `choices[].message`; the Anthropic response is mapped into
 * it), so callers read `result.choices[0].message.content` uniformly.
 */
type ChatCompletion = {
    choices: Array<{
        message: {
            role: string;
            content: string;
        };
    }>;
};
declare function sendChat(messages: ChatMessage$1[], model?: string, provider?: AIProvider, apiKey?: string, endpoint?: string): Promise<ChatCompletion>;

/**
 * Built-in model catalog for the picker, keyed by provider. This is a
 * convenience default that is kept loosely current and WILL drift from each
 * provider's real availability between releases — pass the `models` prop to
 * advertise the exact set your integration supports.
 */
declare const DEFAULT_MODELS: Record<AIProvider, string[]>;
interface ChatMessage {
    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
    content: string;
    name?: string;
    /** Show animated typing indicator */
    typing?: boolean;
    /** Apply fade animation when first rendered */
    animate?: boolean;
}
interface ChatProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onSubmit' | 'style'>, Pick<SpacingProps, 'compact'>, Presettable {
    messages: ChatMessage[];
    onSend?: (message: ChatMessage) => void;
    /** Avatar image for user messages */
    userAvatar?: string;
    /** Avatar image for system / assistant messages */
    systemAvatar?: string;
    placeholder?: string;
    disableInput?: boolean;
    constrainHeight?: boolean;
    apiKey?: string;
    provider?: AIProvider;
    model?: string;
    onModelChange?: (m: string) => void;
    /**
     * Override the model picker's options. When omitted, the built-in
     * {@link DEFAULT_MODELS} catalog for the active provider is used. Supply
     * this to advertise the exact models your integration supports — the
     * built-in defaults are a convenience and drift from provider availability.
     */
    models?: string[];
    /**
     * Instance-level overrides for this component's i18n strings (the set-API-key
     * and send button aria-labels). Wins over the `ValetLocaleProvider` value,
     * which in turn wins over the built-in English defaults (A11Y S8 resolution
     * contract; see `src/system/locale.tsx`). The Connected/Disconnected status
     * text stays with the KeyModal flow (deferred pending Q8).
     */
    labels?: DeepPartialStrings<ValetStrings['llmChat']>;
    /** Render message text non-selectable. Applies to message bubbles (sender name,
     *  user text, assistant Markdown); the composer input stays selectable.
     *  Default: selectable. */
    noSelect?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const LLMChat: React__default.FC<ChatProps>;

interface RichMessage {
    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
    content: React__default.ReactNode;
    /** Optional interactive form to collect a canned response */
    form?: React__default.ComponentType<{
        onSubmit: (value: string) => void;
    }>;
    name?: string;
    typing?: boolean;
    animate?: boolean;
}
interface RichChatProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onSubmit' | 'style'>, Pick<SpacingProps, 'compact'>, Presettable {
    messages: RichMessage[];
    /** Called when a form message collects a response; `index` is the
     *  message's position in the caller's `messages` array (system
     *  messages included), not its position in the rendered list. */
    onFormSubmit?: (value: string, index: number) => void;
    onSend?: (message: RichMessage) => void;
    userAvatar?: string;
    systemAvatar?: string;
    placeholder?: string;
    disableInput?: boolean;
    constrainHeight?: boolean;
    /** Override input font */
    fontFamily?: string;
    /**
     * Instance-level overrides for this component's i18n strings (the send button
     * aria-label). Wins over the `ValetLocaleProvider` value, which in turn wins
     * over the built-in English defaults (A11Y S8 resolution contract; see
     * `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['richChat']>;
    /** Render message text non-selectable. Applies to message bubbles (sender name,
     *  user text, assistant Markdown); the composer input stays selectable.
     *  Default: selectable. */
    noSelect?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const RichChat: React__default.FC<RichChatProps>;

/** Physical drawer sides — the only values the painting logic understands. */
type PhysicalDrawerAnchor = 'left' | 'right' | 'top' | 'bottom';
/** Logical drawer sides — resolved to physical via {@link resolveAnchor}. */
type LogicalDrawerAnchor = 'start' | 'end';
/** Public anchor prop: physical sides plus additive logical 'start'/'end'. */
type DrawerAnchorInput = PhysicalDrawerAnchor | LogicalDrawerAnchor;

/**
 * Public anchor values. The four physical sides ('left'/'right'/'top'/
 * 'bottom') are direction-invariant; the additive logical 'start'/'end'
 * (A11Y S12) resolve to left/right per the active writing direction via
 * {@link resolveAnchor} — 'start' = leading edge, 'end' = trailing edge.
 */
type DrawerAnchor = DrawerAnchorInput;
interface DrawerProps extends Presettable {
    /** Controlled visibility */
    open?: boolean;
    /** Default for uncontrolled */
    defaultOpen?: boolean;
    /**
     * Drawer side. Physical 'left'/'right'/'top'/'bottom' are
     * direction-invariant; the additive logical 'start'/'end' resolve to
     * left/right per the active writing direction (RTL-aware — 'start' is the
     * leading edge). Default 'left'.
     */
    anchor?: DrawerAnchor;
    /** Callback fired when user requests close */
    onClose?: () => void;
    /** Size (width or height depending on anchor) */
    size?: number | string;
    /** Disable closing via backdrop click */
    disableBackdropClick?: boolean;
    /** Disable closing via ESC key */
    disableEscapeKeyDown?: boolean;
    /** Drawer remains visible without backdrop */
    persistent?: boolean;
    /** Adaptive behaviour (persistent in landscape, overlay in portrait) */
    adaptive?: boolean;
    /** Icon for the portrait toggle button */
    toggleIcon?: string;
    /** Close button icon when portrait */
    closeIcon?: string;
    /** Drawer contents */
    children?: React__default.ReactNode;
    /** Class applied to the Drawer panel root */
    className?: string;
    /** Inline styles applied to the Drawer panel root */
    style?: React__default.CSSProperties;
    /** sx convenience for inline styles with CSS var support */
    sx?: Sx;
    /**
     * Accessible name for the dialog. Required (alongside `aria-labelledby`) for
     * non-persistent/overlay Drawers, which are real `role='dialog'` modals; a
     * dev warning fires when neither is provided. Ignored by persistent Drawers,
     * which are inline navigation regions, not dialogs.
     */
    'aria-label'?: string;
    /** Id of an element labelling the dialog (alternative to `aria-label`). */
    'aria-labelledby'?: string;
    /**
     * Instance-level overrides for this component's i18n strings (the portrait
     * open/close toggle-button aria-labels). Wins over the `ValetLocaleProvider`
     * value, which in turn wins over the built-in English defaults (A11Y S8
     * resolution contract; see `src/system/locale.tsx`). Distinct from the
     * dialog's accessible name, which comes from `aria-label`/`aria-labelledby`.
     */
    labels?: DeepPartialStrings<ValetStrings['drawer']>;
}
declare const Drawer: React__default.FC<DrawerProps>;

interface DateSelectorProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'style'>, Presettable {
    /**
     * Controlled value. Single-date mode: ISO YYYY-MM-DD string. Range mode: tuple [start, end].
     */
    value?: string | [string, string];
    /** Default value for uncontrolled usage (same shape as `value`). */
    defaultValue?: string | [string, string];
    /** Event trio */
    onValueChange?: OnValueChange<string | [string, string]>;
    onValueCommit?: OnValueCommit<string | [string, string]>;
    /** FormControl field name (single-date mode only). */
    name?: string;
    /** Disable the whole calendar (field-level). Merges with a FormControl-wide
     *  `disabled`; distinct from the per-DATE out-of-range disable. */
    disabled?: boolean;
    /** Mark the field invalid (field-level). Merges with a name-keyed
     *  FormControl `errors` entry; drives `aria-invalid` and the error recolour. */
    error?: boolean;
    /** Earliest selectable ISO date (YYYY-MM-DD). */
    minDate?: string;
    /** Latest selectable ISO date (YYYY-MM-DD). */
    maxDate?: string;
    /** Enable dual start/end selection mode. */
    range?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
    /** Density scale for the calendar's own spacing and visual sizing. The small
     * (formerly `compact`) visual mode is now `density='tight'`; density never
     * zeroes layout. */
    density?: 'tight' | 'standard' | 'comfortable';
    /** Layout-compact relay: zeroes inherited layout spacing and cascades to
     * descendants via context. No longer a density alias. */
    compact?: boolean;
    /**
     * BCP-47 locale for the DISPLAY of month names, weekday headers, and day
     * numbers (via native `Intl`). Defaults to `'en-US'`, preserving the prior
     * English / Sunday-start output exactly. The committed VALUE is always ISO
     * 'YYYY-MM-DD' with Latin digits regardless of locale (e.g. `'ar-EG'` shows
     * Arabic-Indic display digits while `onValueChange` still emits Latin ISO).
     */
    locale?: string;
    /**
     * First day of the calendar week as an ISO weekday number
     * (**1 = Monday … 7 = Sunday**). When omitted, the locale's own first day is
     * used (`en-US` → 7/Sunday, `de-DE` → 1/Monday), keeping the default behavior
     * Sunday-first for the `en-US` default.
     */
    firstDayOfWeek?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
    /**
     * Instance-level overrides for this component's i18n strings (the month/year
     * navigation aria-labels). Wins over the `ValetLocaleProvider` value, which
     * in turn wins over the built-in English defaults (A11Y S8 resolution
     * contract; see `src/system/locale.tsx`). Month/weekday names are Intl's
     * domain (A11Y S10), driven by `locale`, not part of this string table.
     */
    labels?: DeepPartialStrings<ValetStrings['dateSelector']>;
}
declare const DateSelector: React__default.FC<DateSelectorProps>;

interface ListProps<T> extends Omit<React__default.HTMLAttributes<HTMLUListElement>, 'children' | 'style'>, Presettable {
    data: T[];
    getTitle: (item: T) => React__default.ReactNode;
    getSubtitle?: (item: T) => React__default.ReactNode;
    striped?: boolean;
    /** If `undefined`, non-striped lists hover by default. */
    hoverable?: boolean;
    /** Allow drag-and-drop style reordering via pointer (default: true) */
    reorderable?: boolean;
    onReorder?: (items: T[]) => void;
    /**
     * How selection behaves (API-TYPES S11, Q11(a)). List supports single
     * selection: `'single'` enables it, `'none'` (default) disables it. The
     * unified cross-component selection name.
     */
    selectionMode?: 'none' | 'single';
    /**
     * Focus behavior for rows.
     * - `auto` (default): non-selectable lists keep rows out of the tab order; selectable lists use roving focus (one row has `tabIndex=0`, rest `-1`).
     * - `row`: every row is tabbable (`tabIndex=0`). Opt-in only; not recommended for long lists.
     * - `none`: rows are not in the tab order (`tabIndex=-1`), allowing programmatic focus only.
     */
    focusMode?: 'auto' | 'row' | 'none';
    /** Controlled selected item (by reference). */
    selected?: T | null;
    /** Uncontrolled initial selection. */
    defaultSelected?: T | null;
    /** Fired when selection changes. */
    onSelectionChange?: (item: T, index: number) => void;
    /**
     * Stable identity for each item — the unified cross-component name
     * (API-TYPES S11, Q11(a)). Used to key React rows and standardize reorder
     * identity. Defaults to the item's index when omitted. The cross-component
     * shape is `keyof T | ((item, index) => key)`; List narrows the function form
     * to a React.Key return.
     */
    getItemKey?: keyof T | ((item: T, index: number) => React__default.Key);
    /** Rendered when `data.length === 0`. */
    emptyPlaceholder?: React__default.ReactNode;
    /** Inline styles (with CSS var support). */
    sx?: Sx;
}
declare function List<T>({ data, getTitle, getSubtitle, striped, hoverable, reorderable, onReorder, selectionMode, focusMode, selected: selectedProp, defaultSelected, onSelectionChange, getItemKey, emptyPlaceholder, preset: p, className, sx, ...rest }: ListProps<T>): react_jsx_runtime.JSX.Element;

interface LoadingBackdropProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    fading?: boolean;
    showSpinner?: boolean;
    /**
     * Instance-level overrides for this component's i18n strings. Wins over the
     * `ValetLocaleProvider` value, which in turn wins over the built-in English
     * defaults (A11Y S8 resolution contract; see `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['loadingBackdrop']>;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const LoadingBackdrop: React__default.FC<LoadingBackdropProps>;

interface PaginationProps extends Omit<React__default.HTMLAttributes<HTMLElement>, 'onChange' | 'style'>, Presettable {
    /** Total number of pages (≥ 1). */
    count: number;
    /** Currently-selected page (1-based). */
    page?: number;
    /** Called with the **new page** (1-based) when the user navigates. */
    onPageChange?: (page: number) => void;
    /**
     * Limit how many page buttons are visible at once. When set and less than `count`,
     * pagination renders a sliding window of page numbers plus window scroll controls.
     * Does not affect the currently selected page.
     */
    visibleWindow?: number;
    /**
     * If true, forces the active page to remain visible by auto-shifting the window
     * whenever `page` changes outside the current window. Defaults to true.
     */
    autoFollowActive?: boolean;
    /**
     * Instance-level overrides for this component's i18n strings (nav root label,
     * scroll/step button labels, per-page labels). Wins over the
     * `ValetLocaleProvider` value, which in turn wins over the built-in English
     * defaults (A11Y S8 resolution contract; see `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['pagination']>;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Pagination: React__default.FC<PaginationProps>;

interface ParallaxState {
    scrollY: number;
    scrollX: number;
}
/** Read current scroll offsets (provided by <ParallaxScroll>). */
declare const useParallax: () => ParallaxState;
interface ParallaxScrollProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** Track horizontal scroll in addition to vertical. */
    trackX?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const ParallaxScroll: React__default.FC<ParallaxScrollProps>;
interface ParallaxLayerProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    speed?: number;
    axis?: 'y' | 'x';
    /** Inline styles (with CSS var support) */
    sx?: Sx;
    /**
     * Override the root component-identity marker (defaults to `'ParallaxLayer'`).
     * ParallaxBackground passes its own name so the DOM node identifies as it.
     */
    'data-valet-component'?: string;
}
declare const ParallaxLayer: React__default.FC<ParallaxLayerProps>;
type MediaType = 'image' | 'video';
interface ParallaxBackgroundProps extends Omit<ParallaxLayerProps, 'children'>, Presettable {
    /** Source for JPG / WEBP / WEBM (auto-detects type if omitted). */
    src: string;
    /** Force media type (otherwise guessed by file extension). */
    mediaType?: MediaType;
    /** Optional poster frame for video. */
    poster?: string;
    /** Video attributes */
    loop?: boolean;
    muted?: boolean;
    autoPlay?: boolean;
    preload?: 'none' | 'metadata' | 'auto';
    /** Alt text for an image background. Default `''` (decorative). */
    alt?: string;
}
declare const ParallaxBackground: React__default.FC<ParallaxBackgroundProps>;

type DismissFn = () => void;
declare const useSnackbar: () => DismissFn | null;
/**
 * Visual style. `outline` (default) paints the toast on the page background with
 * a thick primary accent outline; `filled` is a solid primary surface with
 * contrasting text and a soft elevation shadow (matches valet's `filled`
 * convention elsewhere, e.g. Button).
 */
type SnackbarVariant = 'outline' | 'filled';
interface SnackbarProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** Controlled open state – omit for uncontrolled */
    open?: boolean;
    /** Called when the snackbar has fully hidden */
    onClose?: () => void;
    /** Auto-hide after N ms – `null` disables (default = 4000 ms) */
    autoHideDuration?: number | null;
    /** Convenience message when no children supplied            */
    message?: React__default.ReactNode;
    /** Disable the internal flex stack (children render 1:1)    */
    noStack?: boolean;
    /** Visual style — `outline` (default) or solid `filled`. */
    variant?: SnackbarVariant;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Snackbar: React__default.FC<SnackbarProps>;

interface SpeedDialAction {
    icon: React__default.ReactNode;
    label: string;
    onClick: () => void;
}
interface SpeedDialProps extends React__default.HTMLAttributes<HTMLDivElement>, Presettable {
    /** Icon for the main FAB (usually a ➕). */
    icon: React__default.ReactNode;
    /** Speed-dial actions revealed when the FAB is toggled. */
    actions: SpeedDialAction[];
    /** Direction in which actions should expand. */
    direction?: 'up' | 'down' | 'left' | 'right';
    /**
     * Instance-level overrides for this component's i18n strings (the main FAB
     * and actions-group aria-labels). Wins over the `ValetLocaleProvider` value,
     * which in turn wins over the built-in English defaults (A11Y S8 resolution
     * contract; see `src/system/locale.tsx`). Per-action accessible names come
     * from each action's own `label`.
     */
    labels?: DeepPartialStrings<ValetStrings['speedDial']>;
    /** Inline styles via CSSProperties (with CSS var support) */
    sx?: Sx;
}
declare const SpeedDial: React__default.FC<SpeedDialProps>;

interface TableColumn<T> {
    header: React__default.ReactNode;
    accessor?: keyof T | ((row: T) => unknown);
    render?: (row: T, idx: number) => React__default.ReactNode;
    align?: 'left' | 'center' | 'right';
    sortable?: boolean | ((a: T, b: T) => number);
}
/** A stable per-row key: a property name or a function of the row + index. */
type RowKey<T> = keyof T | ((row: T, index: number) => string | number);
interface TableProps<T> extends Omit<React__default.TableHTMLAttributes<HTMLTableElement>, 'children' | 'style'>, Presettable, SelectionProps<T> {
    data: T[];
    columns: TableColumn<T>[];
    striped?: boolean;
    hoverable?: boolean;
    dividers?: boolean;
    initialSort?: {
        index: number;
        desc?: boolean;
    };
    onSortChange?: (index: number, desc: boolean) => void;
    /**
     * Fired only on user interaction (checkbox toggle) and when pruning drops
     * rows — the unified {@link SelectionProps.onSelectionChange}, emitting the
     * selected **rows** (Table's selection unit is `T`).
     */
    onSelectionChange?: (selected: T[]) => void;
    /**
     * Fired when a row is clicked (ignores clicks that originate from obvious interactive children
     * like buttons, inputs, or links). Receives the row object, its visible index, and the click event.
     */
    onRowClick?: (row: T, rowIndex: number, event: React__default.MouseEvent<HTMLTableRowElement>) => void;
    constrainHeight?: boolean;
    /**
     * Minimum body rows that must be visible for an internal scrollbar to be used.
     * If the constrained viewport would show fewer rows than this, height constraining is disabled
     * to avoid a tiny scroller. Default: 4.
     */
    minConstrainedRows?: number;
    /**
     * Applies only when `minConstrainedRows` disables the usual constraint. When the dataset
     * exceeds this size, pagination kicks in (via <Pagination/>) and shows this many rows
     * per page instead of using an internal scrollbar. Default: 30.
     */
    maxExpandedRows?: number;
    /**
     * If true, always paginate using `maxExpandedRows` rows per page, regardless of
     * `minConstrainedRows`/`constrainHeight`. When false (default), pagination engages
     * automatically only when `minConstrainedRows` disables constraint and the dataset
     * exceeds `maxExpandedRows`.
     */
    paginate?: boolean;
    /**
     * Controlled current page (1-based) when `paginate` is true or auto-pagination engages.
     * If omitted, the table manages its own page state.
     */
    page?: number;
    /**
     * Called when the page changes (receives the 1-based page number). Used with controlled `page`.
     */
    onPageChange?: (page: number) => void;
    /**
     * Controls the width of the visible window of page buttons when pagination renders.
     * Passed to <Pagination visibleWindow>. Optional; defaults to Pagination’s internal behavior.
     */
    paginationWindow?: number;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare function Table<T extends object>({ data, columns, striped, hoverable, dividers, selectionMode, getItemKey, selected, defaultSelected, initialSort, onSortChange, onSelectionChange, onRowClick, constrainHeight, minConstrainedRows, maxExpandedRows, paginate, page: pageProp, onPageChange, paginationWindow, preset: p, className, sx, ...rest }: TableProps<T>): react_jsx_runtime.JSX.Element;

interface DropzoneProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onDrop' | 'style'>, Presettable {
    /** Allowable file types (same as react-dropzone `accept`) */
    accept?: DropzoneOptions['accept'];
    /** Minimum height for each preview tile while loading (px or CSS length). */
    previewMinHeight?: number | string;
    /** Minimum file size in bytes (react-dropzone `minSize`) */
    minSize?: DropzoneOptions['minSize'];
    /** Maximum file size in bytes (react-dropzone `maxSize`) */
    maxSize?: DropzoneOptions['maxSize'];
    /** Display previews for accepted files */
    showPreviews?: boolean;
    /** Show file icons and names rather than thumbnails */
    showFileList?: boolean;
    /** Called whenever the file list changes */
    onFilesChange?: (files: File[]) => void;
    /** Maximum file count */
    maxFiles?: number;
    /** Allow multiple file selection */
    multiple?: boolean;
    /** Callback for when files are dropped */
    onDrop?: DropzoneOptions['onDrop'];
    /** Callback for when files are rejected (type/size/count) */
    onDropRejected?: DropzoneOptions['onDropRejected'];
    /** Stretch to fill parent width */
    fullWidth?: boolean;
    /**
     * Instance-level overrides for this component's i18n strings (instructions,
     * per-file remove affordance, rejection fallback). Wins over the
     * `ValetLocaleProvider` value, which in turn wins over the built-in English
     * defaults (A11Y S8 resolution contract; see `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['dropzone']>;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Dropzone: React__default.FC<DropzoneProps>;

interface TabsProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'onChange' | 'style'>, Presettable, Pick<SpacingProps, 'gap' | 'pad' | 'compact' | 'density'> {
    value?: string | number;
    defaultValue?: string | number;
    /** Canonical value trio (API-TYPES S4 / ruling R10): the inline lookalike
        payloads were replaced with {@link OnValueChange}/{@link OnValueCommit},
        so `info` is now the full {@link ChangeInfo} — including the honest
        `source` (tab click ⇒ `'pointer'`, arrow-key nav ⇒ `'keyboard'`). */
    onValueChange?: OnValueChange<string | number>;
    onValueCommit?: OnValueCommit<string | number>;
    orientation?: 'horizontal' | 'vertical';
    placement?: 'top' | 'bottom' | 'left' | 'right';
    /** Horizontal alignment of the tab strip (horizontal orientation). */
    alignX?: 'left' | 'right' | 'center';
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
interface TabProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement>, Presettable {
    index?: number;
    value?: string | number;
    label?: ReactNode;
    tooltip?: ReactNode;
}
interface TabPanelProps extends React__default.HTMLAttributes<HTMLDivElement>, Presettable {
    index?: number;
    value?: string | number;
    keepMounted?: boolean;
}
declare const Tabs: React__default.FC<TabsProps> & {
    Tab: React__default.FC<TabProps>;
    Panel: React__default.FC<TabPanelProps>;
};

type Placement = 'top' | 'bottom' | 'left' | 'right';
interface TooltipProps extends Omit<React__default.HTMLAttributes<HTMLSpanElement>, 'onChange' | 'title'>, Presettable {
    title: ReactNode;
    placement?: Placement;
    arrow?: boolean;
    enterDelay?: number;
    leaveDelay?: number;
    open?: boolean;
    defaultOpen?: boolean;
    disableHoverListener?: boolean;
    disableFocusListener?: boolean;
    disableTouchListener?: boolean;
    /** If true, outside pointer interactions will not close the tooltip. */
    disableOutsideClick?: boolean;
    onOpen?: () => void;
    onClose?: () => void;
    children: ReactElement;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const Tooltip: React__default.FC<TooltipProps>;

interface TreeNode<T> {
    id: string;
    data: T;
    children?: TreeNode<T>[];
    /** Disabled nodes are still navigable (arrows land on them) but never
     *  select/toggle and are announced `aria-disabled`. */
    disabled?: boolean;
}
interface TreeProps<T> extends Omit<React__default.HTMLAttributes<HTMLUListElement>, 'children' | 'style' | 'role' | 'onKeyDown'>, Presettable, Pick<SelectionProps<string>, 'selectionMode' | 'selected' | 'defaultSelected' | 'onSelectionChange'> {
    nodes: TreeNode<T>[];
    getLabel: (node: T) => React__default.ReactNode;
    /** Plain-text accessor for typeahead (since `getLabel` may return a node).
     *  Falls back to `getLabel` when it returns a string/number. */
    getTextValue?: (node: T) => string;
    /** Node ids that are expanded (canonical expansion trio, matches Accordion). */
    defaultExpanded?: string[];
    expanded?: string[];
    onExpandedChange?: (expanded: string[]) => void;
    variant?: 'chevron' | 'list' | 'files';
    /** When true, only the disclosure glyph toggles expansion (not the whole row). */
    iconToggleOnly?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare function Tree<T>({ nodes, getLabel, getTextValue, defaultExpanded, expanded: expandedProp, onExpandedChange, selectionMode, selected: selectedProp, defaultSelected, onSelectionChange, variant, iconToggleOnly, preset: p, className, sx, ...rest }: TreeProps<T>): react_jsx_runtime.JSX.Element;

interface MarkdownProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    /** Raw markdown text */
    data: string;
    /** Optional override for the code block surface (the whole code area, not just
     *  its padding ring). Defaults to a GitHub-paired surface (LIGHT_BG/DARK_BG). */
    codeBackground?: string;
    /** Render the rendered prose non-selectable (`user-select: none`, cascades to
     *  all child elements). Default: text is selectable. */
    noSelect?: boolean;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const isExternalHref: (href: string) => boolean;
declare const isSafeHref: (href?: string | null) => string | null;
declare const isSafeImageSrc: (src?: string | null) => string | null;
declare const Markdown: React__default.FC<MarkdownProps>;

interface CodeBlockProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style'>, Presettable {
    code: string;
    language?: string;
    /** Accessible name for the (scrollable, focusable) code region. */
    ariaLabel?: string;
    /** Tooltip/title for the copy button (default "Copy"). */
    copyLabel?: string;
    /** Inline styles (with CSS var support) */
    sx?: Sx;
}
declare const CodeBlock: React__default.FC<CodeBlockProps>;

type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type ChipVariant = 'filled' | 'outlined' | 'plain';
interface ChipProps extends Presettable, Omit<React__default.HTMLAttributes<HTMLDivElement>, 'style' | 'children' | 'onClick' | 'role' | 'tabIndex'> {
    label: React__default.ReactNode;
    size?: ChipSize;
    variant?: ChipVariant;
    /** Semantic color intent mapping to theme tokens. */
    intent?: Intent;
    /** Explicit color override (theme token or CSS color). */
    color?: string;
    icon?: string;
    avatar?: React__default.ReactNode;
    onDelete?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
    disabled?: boolean;
    /**
     * Instance-level overrides for this component's i18n strings. Wins over the
     * `ValetLocaleProvider` value, which in turn wins over the built-in English
     * defaults (A11Y S8 resolution contract; see `src/system/locale.tsx`).
     */
    labels?: DeepPartialStrings<ValetStrings['chip']>;
    sx?: Sx;
}
declare const Chip: React__default.FC<ChipProps>;

interface KeyModalProps {
    open: boolean;
    onClose?: () => void;
    /** Render the modal's label/instruction text non-selectable. The key/passphrase
     *  inputs stay selectable. Default: selectable. */
    noSelect?: boolean;
}
declare function KeyModal({ open, onClose, noSelect }: KeyModalProps): react_jsx_runtime.JSX.Element | null;

interface ValetErrorFallbackProps {
    /** The error the boundary caught. */
    error: Error;
    /** Clear the error and re-render children. Wire to a retry button. */
    reset: () => void;
}
interface ValetErrorBoundaryProps {
    /** The subtree to protect. */
    children: ReactNode;
    /**
     * Custom fallback. A render function receives the caught error and a
     * `reset` callback; a static node is rendered as-is. When omitted, the
     * built-in role='alert' panel shows the (enriched) error message and a
     * retry button.
     */
    fallback?: ReactNode | ((props: ValetErrorFallbackProps) => ReactNode);
    /**
     * Invoked once per caught error with the error and React's component
     * stack. Fires from componentDidCatch — exactly once per failure, not on
     * every re-render. Use it to report to your telemetry pipeline.
     */
    onError?: (error: Error, info: ErrorInfo) => void;
}
interface ValetErrorBoundaryState {
    error: Error | null;
}
/**
 * Opt-in React error boundary for valet subtrees. Catches errors thrown
 * during render/commit of its children and renders a fallback instead of
 * letting the throw propagate to the host root.
 *
 * @example
 * <ValetErrorBoundary onError={report}>
 *   <RiskyTree />
 * </ValetErrorBoundary>
 */
declare class ValetErrorBoundary extends Component<ValetErrorBoundaryProps, ValetErrorBoundaryState> {
    state: ValetErrorBoundaryState;
    static getDerivedStateFromError(error: Error): ValetErrorBoundaryState;
    componentDidCatch(error: Error, info: ErrorInfo): void;
    /** Clear the caught error so children re-mount and re-render. */
    reset: () => void;
    render(): ReactNode;
}

declare function styled<Tag extends keyof JSX.IntrinsicElements>(tag: Tag): <ExtraProps extends Record<string, unknown> = Record<never, never>>(strings: TemplateStringsArray, ...exprs: Array<string | number | false | null | undefined | ((props: ExtraProps & JSX.IntrinsicElements[Tag]) => string | number | false | null | undefined)>) => React__default.ForwardRefExoticComponent<React__default.PropsWithoutRef<ExtraProps & JSX.IntrinsicElements[Tag] & {
    className?: string;
    /**
     * Opt into per-element size tracking (PERF S9, ruling Q9(a)). When
     * truthy, this element registers with the nearest <Surface> store and
     * the surface writes `--valet-el-width`/`--valet-el-height` onto its
     * inline style via ResizeObserver. Transient: stripped before the DOM.
     * Off by default — most elements never need their own metrics, and the
     * old universal registration was unconsumed observer churn.
     */
    $trackSize?: boolean;
    /**
     * Polymorphic element override — render a different tag/component than
     * the styled base while keeping its generated class. Runtime-honored and
     * stripped before the DOM. (Higher-level components layer richer
     * `PolymorphicProps` typing on top; this is the primitive's own surface.)
     */
    as?: React__default.ElementType;
}> & React__default.RefAttributes<Tag extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[Tag] : HTMLElement>>;
declare function keyframes(strings: TemplateStringsArray, ...exprs: Array<string | number | false | null | undefined>): string;

type CSSFn = (theme: Theme) => string;
declare function definePreset(name: string, cssFn: CSSFn): void;
declare function preset(names: string | string[]): string;

interface FontState {
    loading: number;
    ready: boolean;
    /**
     * Latches true the first time a font load begins. Lets consumers (Surface's
     * never-block grace) tell "no load has ever started" (`started === false`)
     * apart from "a load is in flight" (`started === true && loading > 0`) — the
     * initial `ready: false` state is ambiguous between the two without it.
     * Never reset by finish(): a settled pipeline stays `started === true`.
     */
    started: boolean;
    start: () => void;
    finish: () => void;
}
declare const useFonts: zustand_traditional.UseBoundStoreWithEqualityFn<zustand.StoreApi<FontState>>;

interface GoogleFontOptions {
    /** Preload CSS (google) or font file (custom) */
    preload?: boolean;
    /** Google Fonts CSS display strategy */
    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
    /** Restrict glyphs to speed up delivery */
    text?: string;
    /**
     * Whether to inject remote Google Fonts resources (THEMING S7, Q13).
     *
     * **Default `false` as of 1.0** (privacy-by-default; was `true` through 0.x).
     * When `false`: no `preconnect`/`fonts.googleapis.com` links are appended and
     * Google-shaped entries (string family names or `{ family }` requests)
     * are treated as **local families** — they emit zero network requests
     * and resolve only via FontFace observation of an already-installed
     * face. Self-hosted `CustomFont` entries are unaffected. Set `true`
     * to opt back into fetching named Google families from Google's servers
     * (the privacy docs cover the three loading strategies; GDPR).
     *
     * @default false
     */
    injectRemote?: boolean;
}
interface CustomFont {
    name: string;
    src: string;
    /** Optional metrics hinting for future CLS control */
    metrics?: Partial<{
        ascent: number;
        descent: number;
        lineGap: number;
        sizeAdjust: number;
    }>;
}
type GoogleAxes = {
    /** Font weights as discrete list or min/max range */
    wght?: number[] | {
        min: number;
        max: number;
    };
    /** Include italic axis; if true, request both 0 and 1 forms */
    ital?: boolean;
    /** Optical size range or fixed value when supported by the family */
    opsz?: [number, number] | number;
};
type GoogleFontRequest = string | {
    family: string;
    provider?: 'google';
    axes?: GoogleAxes;
    subsets?: string[];
    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
    text?: string;
    preload?: boolean;
};
type Font = GoogleFontRequest | CustomFont;

type FontKeys = keyof Theme['fonts'];
/**
 * Apply a theme patch and load only the fonts the caller explicitly named.
 *
 * **Fonts are explicit-only** (THEMING S9, ruling Q14(a)). The fonts loaded are
 * exactly the `patch.fonts.*` overrides plus `extras` — nothing else. The
 * theme's built-in family defaults (Kumbh Sans / Inter / JetBrains Mono) are
 * **not** auto-loaded; a zero-config `createInitialTheme({})` injects no links,
 * starts no font load, and makes **zero network requests** — those families
 * simply fall back to whatever face the platform already has installed. To
 * load a webfont, name it (`fonts: { body: 'Inter' }`) or pass it in `extras`.
 * This is the unconditional privacy/GDPR path: it removes the request site
 * rather than reinterpreting it like `injectRemote:false` (which still treats
 * named Google families as local).
 */
declare function createInitialTheme(patch: Partial<Omit<Theme, 'fonts'> & {
    fonts?: Partial<Record<FontKeys, Font>>;
}>, extras?: Font[], options?: GoogleFontOptions): Promise<void>;
/** Options accepted by useInitialTheme (font options + THEMING S8 mode opts). */
interface UseInitialThemeOptions extends GoogleFontOptions {
    /**
     * Initial color mode. 'light'/'dark' apply directly; 'system' reads
     * prefers-color-scheme once at boot (no live `change` listener yet —
     * deferred). Omitted → valet's boot default ('dark') stands.
     */
    mode?: ThemeMode | 'system';
    /**
     * Persist real user mode changes (setMode/toggleMode) to localStorage
     * under 'valet-mode' and restore the stored choice at boot.
     * Boot precedence: stored > requested > system > fallback('dark').
     */
    persistMode?: boolean;
}
/**
 * Boot hook: apply the theme patch once at mount, resolve the initial color
 * mode (THEMING S8), and load the caller's fonts.
 *
 * **Fonts are explicit-only** (THEMING S9, ruling Q14(a)). Like
 * {@link createInitialTheme}, only `patch.fonts.*` overrides and `extras` are
 * loaded — `useInitialTheme({})` triggers **zero network**, and the theme's
 * built-in families fall back to installed system faces. Name a font (or pass
 * it in `extras`) to load a webfont.
 */
declare function useInitialTheme(patch: Partial<Omit<Theme, 'fonts'> & {
    fonts?: Partial<Record<FontKeys, Font>>;
}>, extras?: Font[], options?: UseInitialThemeOptions): void;

/**
 * Register an additional highlight.js grammar on valet's shared
 * instance — the escape hatch for languages outside the curated set.
 * Fences using `name` (or any alias the grammar declares) highlight
 * from the next render.
 *
 * ```ts
 * import rust from 'highlight.js/lib/languages/rust';
 * registerHighlightLanguage('rust', rust);
 * ```
 */
declare const registerHighlightLanguage: (name: string, lang: LanguageFn) => void;

/** Ordered z-index scale. Keys are the canonical layer names. */
declare const VALET_ZINDEX: {
    /** Floating action button (SpeedDial) — sits below the app bar. */
    readonly fab: 1050;
    /** Application bar — dims beneath a modal backdrop. */
    readonly appbar: 1100;
    /** Modal scrim/backdrop. */
    readonly modalBackdrop: 1390;
    /** Modal / Drawer panel. */
    readonly modal: 1400;
    /** Select (and future popup) dropdown menus — above modals. */
    readonly dropdown: 1450;
    /** Snackbar / toast notifications — above dropdowns. */
    readonly snackbar: 1500;
    /** Tooltips — the top of the stack. */
    readonly tooltip: 1600;
};
/** Canonical layer name (a key of {@link VALET_ZINDEX}). */
type ZIndexLayer = keyof typeof VALET_ZINDEX;
/**
 * The `--valet-zindex-<layer>` custom-property name for a layer.
 * e.g. `zIndexVarName('modalBackdrop') === '--valet-zindex-modal-backdrop'`.
 */
declare function zIndexVarName(layer: ZIndexLayer): string;
/**
 * Emit `var(--valet-zindex-<layer>, <fallback>)` for use as a CSS
 * `z-index` value. The fallback is the scale's baked-in number, so the
 * layer renders correctly with no provider while still honouring a
 * host override of the custom property.
 */
declare function zVar(layer: ZIndexLayer): string;

declare function useGoogleFonts(extras?: Font[], options?: GoogleFontOptions): void;

/**
 * Copies typography-related CSS variables from a source element (typically a
 * Surface root) onto a target root (e.g., a portal container) to ensure
 * portalled content inherits matching font stacks and text metrics.
 */
declare function inheritSurfaceFontVars(target: HTMLElement, source?: HTMLElement | null): void;

export { type AIProvider, Accordion, type AccordionItemProps, type AccordionProps, AppBar, type AppBarNavigationItem, type AppBarProps, type AppBarToken, Avatar, type AvatarProps, type AvatarSize, type AvatarVariant, Box, type BoxOwnProps, type Breakpoint, Button, type ButtonComponent, type ButtonOwnProps, type ButtonProps, type ButtonSize, type ButtonVariant, Center, type ChangeInfo, type ChatCompletion, type ChatMessage$1 as ChatMessage, Checkbox, type CheckboxProps, type CheckboxSize, Chip, type ChipProps, type ChipSize, type ChipVariant, Cluster, CodeBlock, type CodeBlockProps, type CustomFont, DEFAULT_MODELS, DateSelector, type DateSelectorProps, type DeepPartialStrings, type Density, Divider, type DividerOrientation, type DividerProps, Drawer, type DrawerAnchor, type DrawerProps, Dropzone, type DropzoneProps, type FieldBaseProps, type Font, type FormConfig, FormControl, type FormControlProps, type FormStore, Grid, type GridAlign, GridItem, type GridItemOwnProps, type GridItemProps, type GridOwnProps, type GridProps, HStack, Icon, IconButton, type IconButtonComponent, type IconButtonOwnProps, type IconButtonProps, type IconButtonSize, type IconButtonVariant, type IconProps, type IconSize, Image, type ImageProps, type InputPhase, type InputSource, type Intent, Iterator, type IteratorProps, KeyModal, LLMChat, type ChatMessage as LLMChatMessage, type ChatProps as LLMChatProps, List, type ListProps, LoadingBackdrop, type LoadingBackdropProps, Markdown, type MarkdownProps, type MetroOptionProps, MetroSelect, type MetroSelectProps, Modal, type ModalProps, type OnValueChange, type OnValueCommit, Pagination, type PaginationProps, Panel, type PanelProps, type PanelVariant, ParallaxBackground, type ParallaxBackgroundProps, ParallaxLayer, type ParallaxLayerProps, ParallaxScroll, type ParallaxScrollProps, type PartialValetStrings, type PolymorphicComponent, type PolymorphicProps, type PolymorphicRef, type Presettable, ProgressBar, type ProgressBarProps, ProgressRing, type ProgressRingProps, type PropsOf, Radio, RadioGroup, type RadioGroupProps, type RadioProps, type RadioSize, RichChat, type RichChatProps, type RichMessage, type RowKey, Forward as Select, type OptionProps as SelectOptionProps, type SelectProps, type SelectionProps, Slider, type SliderProps, Snackbar, type SnackbarProps, type SnackbarVariant, type Space, Spacer, type SpacerProps, type SpacingProps, SpeedDial, type SpeedDialAction, type SpeedDialProps, Stack, type StackAlign, type StackDirection, type StackJustify, type StackOwnProps, type StackProps, type StackScroll, Surface, type SurfaceProps, Switch, type SwitchProps, type Sx, type TabPanelProps, type TabProps, Table, type TableColumn, type TableProps, Tabs, type TabsProps, TextField, type TextFieldProps, type TextFieldSize, type TextFieldVariant, type Theme, type ThemeMode, Tooltip, type TooltipProps, Tree, type TreeNode, type TreeProps, Typography, type TypographyOwnProps, type Variant$1 as TypographyVariant, type UseInitialThemeOptions, VALET_ZINDEX, VStack, type ValetDir, ValetErrorBoundary, type ValetErrorBoundaryProps, type ValetErrorFallbackProps, type ValetLocaleContextValue, ValetLocaleProvider, type ValetLocaleProviderProps, type ValetStrings, Video, type VideoProps, type VideoSource, type VideoTrack, WebGLCanvas, type WebGLCanvasProps, type WebGLProgramLike, type WeightAlias, type ZIndexLayer, createFormStore, createInitialTheme, definePreset, enStrings, inheritSurfaceFontVars, isExternalHref, isRtlLocale, isSafeHref, isSafeImageSrc, keyframes, mergeStrings, preset, registerHighlightLanguage, sendChat, styled, useAIKey, useComponentStrings, useFonts, useForm, useFormConfig, useGoogleFonts, useInitialTheme, useOptionalForm, useParallax, useSnackbar, useSurface, useTheme, useValetLocale, zIndexVarName, zVar };