@justanarthur/modo-ui 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3926 @@
+import { JSX as JSX_1kxb } from "react";
+interface SidebarAppProps {
+	/** Start with the sidebar open; the preset starts it collapsed. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** The sidebar's layout (see Sidebar). Defaults to `'inset'`. */
+	variant?: "sidebar" | "floating" | "inset";
+	/** The edge it sits on. Defaults to `'left'`. */
+	side?: "left" | "right";
+	/** Open the collapsed sidebar while the pointer is at its edge or on the topbar's trigger (see Sidebar). Defaults to `false`. */
+	openOnHover?: boolean;
+	/** Fill the parent box instead of the viewport, as the examples do. Defaults to `false`. */
+	contained?: boolean;
+}
+type Element_12xgc = JSX_1kxb["Element"];
+/**
+* An app shell around the Sidebar, as Fluid Functionalism's playground preset
+* `sa1FQfCxH6` builds it: the inset layout, starting collapsed.
+*
+* Press the trigger in the topbar (or `[`) to bring the sidebar in. The
+* header holds a workspace switcher, a search field and a "New" row; two
+* thread sections fold from their labels and carry an "Add item" action;
+* every thread shows its status dot and, on hover, a "More options" menu;
+* the footer anchors the user row and two buttons. Pick a thread and the
+* active row melts over to it while the topbar follows.
+*
+* Every overlay grows out of what opened it: the switcher, the user menu
+* and the row menus are Dropdowns, the labels on the buttons are Tooltips,
+* a collapsed sidebar with `openOnHover` slides open from its edge, and below
+* the `md` breakpoint the sidebar is a Sheet growing out of the left edge.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function SidebarApp({ defaultOpen, variant, side, openOnHover, contained }: SidebarAppProps): Element_12xgc;
+import { VariantProps } from "class-variance-authority";
+import { HTMLAttributes } from "react";
+import { ClassProp as ClassProp_wz9o0r } from "class-variance-authority/types";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn } from "react";
+import { RefAttributes as RefAttributes_miuf56 } from "react";
+declare const badgeColors: {
+	readonly gray: "var(--badge-gray)";
+	readonly red: "var(--badge-red)";
+	readonly orange: "var(--badge-orange)";
+	readonly amber: "var(--badge-amber)";
+	readonly yellow: "var(--badge-yellow)";
+	readonly lime: "var(--badge-lime)";
+	readonly green: "var(--badge-green)";
+	readonly emerald: "var(--badge-emerald)";
+	readonly teal: "var(--badge-teal)";
+	readonly cyan: "var(--badge-cyan)";
+	readonly blue: "var(--badge-blue)";
+	readonly indigo: "var(--badge-indigo)";
+	readonly violet: "var(--badge-violet)";
+	readonly purple: "var(--badge-purple)";
+	readonly fuchsia: "var(--badge-fuchsia)";
+	readonly pink: "var(--badge-pink)";
+	readonly rose: "var(--badge-rose)";
+};
+type BadgeColor = keyof typeof badgeColors;
+declare const badgeVariants: (props?: ({
+	variant?: "dot" | "solid" | null | undefined;
+	size?: "default" | "compact" | null | undefined;
+} & ClassProp_wz9o0r) | undefined) => string;
+type BadgeSizeCanonical = "default" | "compact";
+/** Public size values: the canonical two-size scale plus the pre-sizes-system
+*  aliases, kept so existing call sites keep compiling. Aliases resolve onto
+*  the canonical ladder (sm → compact; md/lg → default). */
+type BadgeSize = BadgeSizeCanonical | "sm" | "md" | "lg";
+interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, "color">, Omit<VariantProps<typeof badgeVariants>, "size"> {
+	/** Visual style. Solid uses a tinted background; dot shows a colored indicator. Defaults to `"solid"`. */
+	variant?: "solid" | "dot";
+	/** Step on the size ladder (see Sizes). Legacy sm/md/lg values resolve as aliases (sm → compact; md/lg → default). Defaults to the surrounding SizeProvider, else `"default"`. */
+	size?: BadgeSize;
+	/** Color from the Tailwind palette: gray, red, orange, amber, yellow, lime, green, emerald, teal, cyan, blue, indigo, violet, purple, fuchsia, pink, rose. Defaults to `"gray"`. */
+	color?: BadgeColor;
+}
+/**
+* Compact label for status, category, or metadata. Supports solid and dot
+* variants with Tailwind colors.
+*
+* Solid badges tint their background with the chosen color mixed into the
+* page background (gray uses the accent token); dot badges keep a neutral
+* border and show the color as a small indicator. The badge rides the size
+* ladder — `size` pins it, otherwise it follows the surrounding SizeProvider
+* — and takes its corner radius from the shape context. Changes animate: a
+* new label or variant springs the width while the label crossfades, and a
+* new color fades in. The palette is also exported as `badgeColors`, the class
+* recipe as `badgeVariants`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Badge: ForwardRefExoticComponent_tcubfn<BadgeProps & RefAttributes_miuf56<HTMLSpanElement>>;
+import { VariantProps as VariantProps2 } from "class-variance-authority";
+import { ButtonHTMLAttributes, ReactNode as ReactNode2 } from "react";
+import { ComponentType, ReactNode } from "react";
+import { JSX as JSX_1kxb2 } from "react";
+interface IconComponentProps {
+	size?: number | string;
+	strokeWidth?: number | string;
+	className?: string;
+}
+type IconComponent = ComponentType<IconComponentProps>;
+type IconName = "chevron-right" | "chevron-down" | "x" | "copy" | "menu" | "dot" | "monitor" | "sun" | "moon" | "rectangle-horizontal" | "circle" | "square-library" | "clock" | "star" | "settings" | "plus" | "arrow-left" | "arrow-right" | "arrow-up" | "arrow-down" | "search" | "loader" | "users" | "lock" | "mail" | "bell" | "shield" | "palette" | "lightbulb" | "rocket" | "heart" | "paintbrush" | "brain" | "globe" | "user" | "image" | "link" | "check" | "rotate-ccw" | "play" | "pause" | "pipette" | "home" | "message-circle" | "inbox" | "pencil" | "scaling" | "skip-forward" | "corner-down-right" | "corner-down-left" | "panel-left" | "panel-left-dashed" | "panel-right" | "panel-right-dashed" | "chevrons-up-down" | "more-horizontal" | "more-vertical" | "calendar" | "folder" | "sliders-horizontal";
+type Element_12xgc2 = JSX_1kxb2["Element"];
+/**
+* Swap some or all icons for components from another library.
+* Names left out of `icons` keep their default (Lucide) component.
+*/
+declare function IconProvider({ children, icons }: {
+	children: ReactNode;
+	icons?: Partial<Record<IconName, IconComponent>>;
+}): Element_12xgc2;
+import { ClassProp as ClassProp_wz9o0r2 } from "class-variance-authority/types";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn2 } from "react";
+import { RefAttributes as RefAttributes_miuf562 } from "react";
+declare const buttonVariants: (props?: ({
+	variant?: "primary" | "secondary" | "tertiary" | "ghost" | null | undefined;
+	size?: "default" | "compact" | "icon" | "icon-compact" | null | undefined;
+	iconLeft?: boolean | null | undefined;
+	iconRight?: boolean | null | undefined;
+} & ClassProp_wz9o0r2) | undefined) => string;
+type ButtonSizeCanonical = "default" | "compact" | "icon" | "icon-compact";
+/** Public size values: the canonical two-size scale plus the pre-sizes-system
+*  aliases, kept so existing call sites keep compiling. Aliases resolve onto
+*  the canonical ladder (sm → compact; md/lg → default). */
+type ButtonSize = ButtonSizeCanonical | "sm" | "md" | "lg" | "icon-sm" | "icon-lg";
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, Omit<VariantProps2<typeof buttonVariants>, "size"> {
+	/** Visual style of the button. Defaults to `"primary"`. */
+	variant?: "primary" | "secondary" | "tertiary" | "ghost";
+	/** Step on the size ladder (36px default, 28px compact — see Sizes): `"default"` | `"compact"` | `"icon"` | `"icon-compact"`. Omitted, the button follows the surrounding SizeProvider. Legacy sm/md/lg values resolve as aliases (sm → compact; md/lg → default; icon-sm → icon-compact; icon-lg → icon). */
+	size?: ButtonSize;
+	/** Merge props onto the child element instead of rendering a `<button>` — the single React-element child becomes the rendered element (slot-style). Defaults to `false`. */
+	asChild?: boolean;
+	/** Folds the button into a circle around a spinner and disables it; the button keeps its box, so nothing around it moves. Defaults to `false`. */
+	loading?: boolean;
+	/** Icon displayed before the label. */
+	leadingIcon?: IconComponent;
+	/** Icon displayed after the label. */
+	trailingIcon?: IconComponent;
+	/** Forces the pressed/held visual — e.g. while a dropdown or popover the button opened is showing. Defaults to `false`. */
+	active?: boolean;
+	/** Disables the button. Defaults to `false`. */
+	disabled?: boolean;
+	/** The label. With `size="icon"` / `"icon-compact"`, the icon itself (give the button an `aria-label`). */
+	children?: ReactNode2;
+}
+/**
+* Versatile button with variants, sizes, loading state, and icon support.
+*
+* Four variants (primary, secondary, tertiary, ghost) on the two-step size
+* ladder: 36px by default, 28px compact — an explicit `size` wins, otherwise
+* the button follows the surrounding SizeProvider. The press effect shrinks
+* the fill by exactly 1px per side at any width, icons thicken their stroke
+* on hover, and `loading` folds the surface into a circle around a spinner
+* (and back when it ends) while the button keeps its box, so nothing around
+* it moves. Built on Base UI's Button; `asChild` renders your own
+* element (e.g. a link) with the button's styling instead.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Button2: ForwardRefExoticComponent_tcubfn2<ButtonProps & RefAttributes_miuf562<HTMLButtonElement>>;
+import { ForwardRefExoticComponent, HTMLAttributes as HTMLAttributes2, ReactNode as ReactNode3, RefAttributes } from "react";
+type SizeVariant = "default" | "compact";
+interface SizeClasses {
+	/** The variant these classes belong to — handy for conditionals. */
+	variant: SizeVariant;
+	/** Bounded control height — buttons, inputs, select triggers, subtle tabs —
+	*  AND list/menu rows (select options, dropdown, checkbox and radio rows).
+	*  One token by design: a popup row lines up with the trigger that opened
+	*  it because they share this height. */
+	control: string;
+	/** `control` as a number, for consumers that need raw pixels. */
+	controlHeight: number;
+	/** Tab trigger height inside a padded segmented list. Sized so
+	*  `segmentPad` + `segmentItem` adds back up to the control height —
+	*  the segmented control's outer box stays on the same ladder. */
+	segmentItem: string;
+	/** Padding of the segmented list around its tabs. */
+	segmentPad: string;
+	/** Body text inside controls. */
+	text: string;
+	/** Horizontal padding of bounded controls (select trigger, inputs). */
+	px: string;
+	/** Horizontal padding of list/menu rows, which sit inside a padded popup
+	*  or group and need less inset than a bounded control. */
+	itemPx: string;
+	/** Gap between an icon / control glyph and its label, and between
+	*  neighbouring controls in a row (toolbars, filter bars, button
+	*  clusters). Density is spacing as much as control height, so the
+	*  compact step halves it. */
+	gap: string;
+	/** Glyph size in px: leading/trailing icons inside controls, and the
+	*  checkbox square / radio circle. */
+	icon: number;
+}
+declare const sizeMap: Record<SizeVariant, SizeClasses>;
+/** One role of the type scale: px per ladder step. */
+interface TypeScaleStep {
+	default: number;
+	compact: number;
+}
+/**
+* Role-based type scale, per ladder step (px values).
+*
+* The default column is the system as shipped; the compact column steps each
+* role down one notch so dense regions read as a smaller sibling of the same
+* hierarchy, not a squeezed copy. `body`, `caption`, and `subtitle` are what
+* the sized components already render through `SizeClasses.text` and their
+* compact conditionals; `display` and `title` are the page-level roles
+* for consumers composing their own screens.
+*/
+declare const typeScale: {
+	/** Page titles. */
+	readonly display: {
+		readonly default: 28;
+		readonly compact: 24;
+	};
+	/** Section headings, dialog titles. */
+	readonly title: {
+		readonly default: 16;
+		readonly compact: 15;
+	};
+	/** Card titles, chat bubbles, emphasized rows. */
+	readonly subtitle: {
+		readonly default: 14;
+		readonly compact: 13;
+	};
+	/** Control labels and body copy — `SizeClasses.text`. */
+	readonly body: {
+		readonly default: 13;
+		readonly compact: 12;
+	};
+	/** Secondary text: descriptions, meta rows, errors, eyebrows and group
+	*  labels (the former overline role — an uppercase or muted caption). */
+	readonly caption: {
+		readonly default: 12;
+		readonly compact: 11;
+	};
+};
+type TypeScaleRole = keyof typeof typeScale;
+/** The type scale resolved for the active ladder step (px per role):
+*  explicit override > surrounding SizeProvider > "default". */
+declare function useTypeScale(override?: SizeVariant | null): Record<TypeScaleRole, number>;
+interface SizeContextValue {
+	size: SizeVariant;
+	setSize: (size: SizeVariant) => void;
+	classes: SizeClasses;
+}
+/** Resolve the active size variant: explicit prop > provider > "default". */
+declare function useSizeVariant(override?: SizeVariant | null): SizeVariant;
+/** Resolve size classes: explicit prop > provider > "default". */
+declare function useSize(override?: SizeVariant | null): SizeClasses;
+declare function useSizeContext(): SizeContextValue;
+import { JSX as JSX_1kxb3 } from "react";
+type CardOrientation = "card" | "inline";
+type CardBorder = "none" | "outlined";
+interface CardGroupProps extends Omit<HTMLAttributes2<HTMLDivElement>, "onDrag"> {
+	/** How each card lays its own content out.
+	*  "card" — stacked vertically (media/header on top). "inline" — a
+	*  horizontal row (leading media, trailing footer), like a Table row.
+	*  @default "card" */
+	orientation?: CardOrientation;
+	/** Number of grid columns. >1 enables 2-D fluid hover across rows and columns.
+	*  @default 1 */
+	columns?: number;
+	/** "none" — borderless (default), separated only by subtle dividers.
+	*  "outlined" — draws a border: one shared frame when grouped, or one per
+	*  card when `separated`. @default "none" */
+	border?: CardBorder;
+	/** Split the group into individually-shaped cards with a gap between them
+	*  (a grid of tiles) instead of one continuous divided block. @default false */
+	separated?: boolean;
+	/** Enable the magnetic fluid-hover highlight. @default true */
+	fluidHover?: boolean;
+}
+declare const CardGroup: ForwardRefExoticComponent<CardGroupProps & RefAttributes<HTMLDivElement>>;
+interface CardProps extends Omit<HTMLAttributes2<HTMLDivElement>, "onClick"> {
+	/** Compositional parts: Card.Image, Card.Media, Card.Header, Card.Content, Card.Footer. */
+	children?: ReactNode3;
+	/** Makes the whole card a clickable target (stretched button); fluid hover previews it. */
+	onClick?: () => void;
+	/** Makes the whole card a link (stretched anchor). */
+	href?: string;
+	/** Opens href in a new tab. Defaults to `false`. */
+	external?: boolean;
+	/** Accessible name for the stretched link/button when the whole card is clickable (the visible title isn't wired up automatically). */
+	label?: string;
+	/** Persistent selected fill + title emphasis, on top of fluid hover. The group drops the hairline dividers around the selected card so the fill reads clean. Defaults to `false`. */
+	selected?: boolean;
+	/** Dims and disables the card. Defaults to `false`. */
+	disabled?: boolean;
+	/** Shows a dismiss (✕) button, revealed on hover or focus by default. Defaults to `false`. */
+	dismissible?: boolean;
+	/** Keeps the dismiss control hidden until the card is hovered or holds focus. Pass false for an always-visible ✕. Defaults to `true`. */
+	dismissOnHover?: boolean;
+	/** Called when the dismiss button is pressed. */
+	onDismiss?: () => void;
+	/** Pins the card to one step of the size ladder — compact tightens type and padding. Omitted, it follows the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Injected by Card.Group — do not set by hand. */
+	index?: number;
+}
+type CardComponent = ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>> & {
+	Group: typeof CardGroup;
+	Header: typeof CardHeader;
+	Title: typeof CardTitle;
+	Description: typeof CardDescription;
+	Action: typeof CardAction;
+	Content: typeof CardContent;
+	Footer: typeof CardFooter;
+	Media: typeof CardMedia;
+	Image: typeof CardImage;
+	Eyebrow: typeof CardEyebrow;
+	Feature: typeof CardFeature;
+	Button: typeof CardButton;
+};
+/**
+* shadcn's compositional card, dressed in Fluid Functionalism. Stacked,
+* inline, or grid — borderless by default with fluid hover that previews
+* where a click will land.
+*
+* The same parts and data-slot contract as shadcn's Card, on a transparent,
+* borderless surface: a card inherits its parent's substrate and leans on
+* hairline dividers rather than a drawn frame. Card.Group owns the layout (a
+* stacked list, inline rows or a grid) and assigns every child its fluid
+* hover index; only a clickable card (`onClick` or `href`) joins the magnetic
+* highlight. A clickable card is one stretched button or link, while footer
+* actions and Card.Action stay independently clickable above it.
+*
+* Statics: Card.Group (orientation "card" | "inline", columns, border "none"
+* | "outlined", separated, fluidHover), Card.Header (title + description
+* grid, pins Card.Action top-right), Card.Title (weight-animates when the card
+* is selected), Card.Description, Card.Action, Card.Content, Card.Footer (the
+* actions row), Card.Media (an icon tile, a logo or a [logoA, logoB] pair),
+* Card.Image (full-bleed banner, or a leading image when inline),
+* Card.Eyebrow (small uppercase label), Card.Feature (icon + title +
+* description row) and Card.Button (primary | secondary | ghost | link
+* action; an anchor when given `href`).
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Card: CardComponent;
+declare const CardHeader: ForwardRefExoticComponent<HTMLAttributes2<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+declare const CardTitle: ForwardRefExoticComponent<HTMLAttributes2<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+declare const CardDescription: ForwardRefExoticComponent<HTMLAttributes2<HTMLParagraphElement> & RefAttributes<HTMLParagraphElement>>;
+declare const CardAction: ForwardRefExoticComponent<HTMLAttributes2<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+declare const CardContent: ForwardRefExoticComponent<HTMLAttributes2<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+declare const CardFooter: ForwardRefExoticComponent<HTMLAttributes2<HTMLDivElement> & RefAttributes<HTMLDivElement>>;
+type CardLogo = string | [string, string];
+interface CardMediaProps {
+	logo?: CardLogo;
+	logoAlt?: string;
+	icon?: IconComponent;
+	size?: number;
+	className?: string;
+}
+type Element_12xgc3 = JSX_1kxb3["Element"];
+declare function CardMedia({ logo, logoAlt, icon: Icon, size, className }: CardMediaProps): Element_12xgc3 | null;
+interface CardImageProps {
+	src: string;
+	alt?: string;
+	className?: string;
+}
+declare function CardImage({ src, alt, className }: CardImageProps): Element_12xgc3;
+declare const CardEyebrow: ForwardRefExoticComponent<HTMLAttributes2<HTMLSpanElement> & RefAttributes<HTMLSpanElement>>;
+interface CardFeatureProps {
+	icon?: IconComponent;
+	title: string;
+	description?: string;
+}
+declare function CardFeature({ icon: Icon, title, description }: CardFeatureProps): Element_12xgc3;
+type CardButtonVariant = "primary" | "secondary" | "ghost" | "link";
+interface CardButtonProps {
+	children: React.ReactNode3;
+	onClick?: () => void;
+	href?: string;
+	variant?: CardButtonVariant;
+	icon?: IconComponent;
+	iconPosition?: "start" | "end";
+	/** Opens the href in a new tab and appends an outward arrow glyph. */
+	external?: boolean;
+	disabled?: boolean;
+}
+declare function CardButton({ children, onClick, href, variant, icon: Icon, iconPosition, external, disabled }: CardButtonProps): Element_12xgc3;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent2, HTMLAttributes as HTMLAttributes3, ReactNode as ReactNode4, RefAttributes as RefAttributes2 } from "react";
+interface CheckboxGroupProps extends HTMLAttributes3<HTMLDivElement> {
+	/** CheckboxGroup.Item children. */
+	children: ReactNode4;
+	/** Set of checked item indices; drives the merged background across contiguous picks. Controlled — pair it with `onCheckedIndicesChange` (or per-item `onToggle`). */
+	checkedIndices?: Set<number>;
+	/** Checked indices on first render when uncontrolled (a Set or an array). Defaults to none. */
+	defaultCheckedIndices?: Set<number> | number[];
+	/** Called with the next checked set whenever an item is toggled. */
+	onCheckedIndicesChange?: (checkedIndices: Set<number>) => void;
+	/** Pins the group's rows to one step of the size ladder (default 36px, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type CheckboxGroupComponent = ForwardRefExoticComponent2<CheckboxGroupProps & RefAttributes2<HTMLDivElement>> & {
+	Item: typeof CheckboxItem;
+};
+/**
+* Checkbox group with merged backgrounds for contiguous selections.
+*
+* Each row is a `CheckboxGroup.Item` with a stable `index`. Contiguous checked
+* rows share one background: a checked row's background grows out of its
+* center and melts into its neighbours, an unchecked one pinches off and
+* shrinks away (the liquid indicators in Morph). A fluid hover highlight melts
+* from row to row, and Arrow Up/Down,
+* Home and End move focus while Space or Enter toggles. The checked label
+* animates to semibold without shifting its width. The group is uncontrolled
+* with `defaultCheckedIndices`, or controlled with `checkedIndices` plus
+* `onCheckedIndicesChange` — FF's per-item `checked` / `onToggle` still work
+* and override the group state for their row.
+*
+* Statics:
+* - `CheckboxGroup.Item` — one checkbox row: `label`, `index`, and optional
+*   `checked` / `onToggle`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const CheckboxGroup: CheckboxGroupComponent;
+interface CheckboxItemProps extends HTMLAttributes3<HTMLDivElement> {
+	/** Text label for the checkbox. */
+	label: string;
+	/** Position index within the group. */
+	index: number;
+	/** Whether this item is checked. Defaults to the group's checked set. */
+	checked?: boolean;
+	/** Called when this item is toggled (the group's `onCheckedIndicesChange` fires too). */
+	onToggle?: () => void;
+}
+declare const CheckboxItem: ForwardRefExoticComponent2<CheckboxItemProps & RefAttributes2<HTMLDivElement>>;
+import { CSSProperties, ForwardRefExoticComponent as ForwardRefExoticComponent3, HTMLAttributes as HTMLAttributes4, ReactNode as ReactNode5, RefAttributes as RefAttributes3, RefObject as RefObject2 } from "react";
+import { JSX as JSX_1kxb4 } from "react";
+type ColorFormat = "hex" | "rgb" | "hsl" | "oklch";
+type Element_12xgc4 = JSX_1kxb4["Element"];
+declare function ColorPickerPortalContainer({ value, children }: {
+	value: HTMLElement | null;
+	children: ReactNode5;
+}): Element_12xgc4;
+interface ParsedColor {
+	h: number;
+	s: number;
+	v: number;
+	a: number;
+	r: number;
+	g: number;
+	b: number;
+	hex: string;
+	rgb: string;
+	hsl: string;
+	oklch: string;
+}
+interface ColorPickerProps extends Omit<HTMLAttributes4<HTMLDivElement>, "onChange" | "defaultValue"> {
+	/** Controlled color value, in any of the supported formats. Omit it to let the picker keep its own state, seeded from `defaultValue`. */
+	value?: string;
+	/** Initial color when uncontrolled — any CSS color string, named colors included. Defaults to `"#6B97FF"`. */
+	defaultValue?: string;
+	/** Fired on every change. Receives the formatted string and a parsed color object carrying every format. */
+	onValueChange?: (value: string, parsed: ParsedColor) => void;
+	/** Controlled format selection. */
+	format?: ColorFormat;
+	/** Initial format when uncontrolled. Defaults to `"hex"`. */
+	defaultFormat?: ColorFormat;
+	/** Fired when the user switches format. */
+	onFormatChange?: (format: ColorFormat) => void;
+	/** Optional preset swatches. When omitted, the strip is hidden. */
+	swatches?: string[];
+	/** Force-hide the eyedropper button — it is hidden automatically in browsers that do not support it. Defaults to `false`. */
+	hideEyedropper?: boolean;
+	/** Controls the format dropdown's open state. When provided, the dropdown is fully controlled and ignores user toggles. */
+	formatOpen?: boolean;
+	/** Initial open state for the format dropdown (uncontrolled). Defaults to `false`. */
+	defaultFormatOpen?: boolean;
+	/** Pins trigger and popover to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, they follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Merged after the panel's surface, radius and padding classes. */
+	className?: string;
+}
+interface ColorPickerPopoverProps extends ColorPickerProps {
+	/** Optional label rendered alongside the color tile. */
+	triggerLabel?: string;
+	/** Position of the label relative to the color tile. Defaults to `"left"`. */
+	triggerLabelPosition?: "left" | "right";
+	/** Show the hex value (without alpha) next to the tile. Defaults to `true`. */
+	triggerShowValue?: boolean;
+	/** Render an X button on the trigger; pairs with `onTriggerRemove`. Defaults to `false`. */
+	triggerShowRemove?: boolean;
+	/** Fired when the X button is clicked. */
+	onTriggerRemove?: () => void;
+	/** Custom classes on the trigger button. */
+	triggerClassName?: string;
+	/** Controls the popover's open state. When provided, the popover is fully
+	*  controlled and ignores trigger clicks. */
+	open?: boolean;
+	/** Initial open state for the popover (uncontrolled). Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the open state would change (fires even when controlled). */
+	onOpenChange?: (open: boolean) => void;
+	/** Where the panel grows from (see Morph): the trigger, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject2<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+}
+interface ColorSwatchProps extends Omit<HTMLAttributes4<HTMLButtonElement>, "color"> {
+	/** The swatch color — any CSS color string. */
+	color: string;
+	/** Edge length in pixels. Defaults to `28`. */
+	size?: number;
+	/** Draws the selection ring. */
+	selected?: boolean;
+}
+declare function parseColor(input: string): {
+	r: number;
+	g: number;
+	b: number;
+	a: number;
+} | null;
+declare function buildParsed(h: number, s: number, v: number, a: number): ParsedColor;
+interface ColorTileProps {
+	color: string;
+	size?: number;
+	className?: string;
+	style?: CSSProperties;
+}
+declare function ColorTile({ color, size, className, style }: ColorTileProps): Element_12xgc4;
+declare const ColorSwatch: ForwardRefExoticComponent3<ColorSwatchProps & RefAttributes3<HTMLButtonElement>>;
+type ColorPickerComponent = ForwardRefExoticComponent3<ColorPickerProps & RefAttributes3<HTMLDivElement>> & {
+	/** `ColorPickerPopover` — the same panel behind a trigger button. */
+	Popover: typeof ColorPickerPopover;
+};
+/**
+* Color picker with HEX, RGB, HSL, and OKLCH formats, an alpha channel,
+* optional swatches, and an eyedropper. Available as an inline panel or a
+* popover.
+*
+* The value is kept internally as HSV, so hue survives a pass through pure
+* black, pure white or full grey instead of collapsing to red. Every edit —
+* the saturation square, the hue and alpha sliders, the per-channel inputs,
+* a swatch, the eyedropper — writes to that one canonical color, which is
+* re-emitted in the active format together with a parsed object carrying all
+* four. Numeric channels scrub: drag sideways to sweep a value, click to type
+* it. Alpha reads against a checkerboard, swatches accept any CSS color string
+* (named colors included), and OKLCH edits keep the hue you typed across the
+* lossy trip back through sRGB. The panel paints itself on the surface ladder
+* and re-provides its level, so the format menu elevates above it however
+* deeply the picker is nested.
+*
+* Statics:
+* - `ColorPicker.Popover` — `ColorPickerPopover`: the same panel behind a
+*   trigger button showing a color tile, an optional label and the hex value.
+*   The panel oozes out of the trigger and back through the shared morph (see
+*   Morph), with the morph options `from`, `effect`, `hideSource`, `tier`.
+*
+* Also exported: `ColorSwatch` and `ColorTile` (the swatch button and the
+* checkerboard tile), `ColorPickerPortalContainer` (portal the format menu
+* into a given element — e.g. inside a CSS-scaled ancestor), and the
+* `parseColor` / `buildParsed` color helpers.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const ColorPicker: ColorPickerComponent;
+declare const ColorPickerPopover: ForwardRefExoticComponent3<ColorPickerPopoverProps & RefAttributes3<HTMLDivElement>>;
+import { VariantProps as VariantProps3 } from "class-variance-authority";
+import { HTMLAttributes as HTMLAttributes5, InputHTMLAttributes as InputHTMLAttributes2, ReactNode as ReactNode6, RefObject as RefObject3 } from "react";
+import { ClassProp as ClassProp_wz9o0r3 } from "class-variance-authority/types";
+/**
+* The ringed box of a text field. It steps from rest to a muted fill when lit
+* (hovered, or `data-active` from a group's fluid hover) to the card fill
+* when focused. `data-invalid` keeps a destructive ring in every state and
+* tints the lit fill; `data-disabled` frames and dims it. Put it on the
+* element around the control and stamp the data attributes; Base UI parts
+* stamp `data-invalid` / `data-disabled` themselves.
+*/
+declare const fieldVariants: (props?: ({
+	variant?: "borderless" | "bordered" | null | undefined;
+} & ClassProp_wz9o0r3) | undefined) => string;
+import { JSX as JSX_1kxb5 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn3 } from "react";
+import { RefAttributes as RefAttributes_miuf563 } from "react";
+/** An object item: `value` and `label`, plus whatever the rows need. */
+interface ComboboxItemObject {
+	value: string;
+	label: string;
+	[key: string]: unknown;
+}
+type ComboboxItemData = string | ComboboxItemObject;
+type ComboboxValue<Multiple extends boolean> = Multiple extends true ? string[] : string;
+interface ComboboxProps {
+	/** `Combobox.Input` or `Combobox.Chips`, plus `Combobox.Content`. */
+	children: ReactNode6;
+	/** The options. A string is its own value and label; an object carries `value`, `label`, and whatever your rows need. */
+	items: readonly ComboboxItemData[];
+	/** Any number of picks. Values become `string[]`; use `Combobox.Chips` for the field. Defaults to `false`. */
+	multiple?: boolean;
+	/** Selected value. `""` means none; an array when `multiple`. Controlled — pair it with `onValueChange`. */
+	value?: string | string[];
+	/** Selection on first render when uncontrolled. Defaults to none. */
+	defaultValue?: string | string[];
+	/** Called with the pick, `""` when cleared, or the array when `multiple`. */
+	onValueChange?: ((value: string) => void) | ((value: string[]) => void);
+	/** Match an item against the query. Defaults to a case-insensitive "contains" on the label. */
+	filter?: (item: ComboboxItemData, query: string) => boolean;
+	/** Adds a last row that creates the trimmed query whenever no label matches it exactly. Add the item to `items` and return it to select it. */
+	onCreate?: (query: string) => ComboboxItemData | void;
+	/** The create row's label. Defaults to ``(query) => `Create “${query}”` ``. */
+	createLabel?: (query: string) => ReactNode6;
+	/** Local addition: offer the create row with no callback — the component keeps the items it makes, so nothing outside has to hold the list. Defaults to `false`. */
+	creatable?: boolean;
+	/** Multiple only. Picked items leave the list, so it reads as what is left to add. Deselect from the chips. Defaults to `false`. */
+	hideSelected?: boolean;
+	/** Disables the field and the popup. Defaults to `false`. */
+	disabled?: boolean;
+	/** Form field name; a hidden input carries the value. */
+	name?: string;
+	/** Marks the hidden form input required. */
+	required?: boolean;
+	/** Pins field and popup to one step of the size ladder (default 36px, compact 28px — see the Sizes primitive). Omitted, both follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type Element_12xgc5 = JSX_1kxb5["Element"];
+/**
+* Type to filter a list. 1 pick, or chips.
+*
+* Items are data on the root: strings, which are their own value and label,
+* or `{ value, label, … }` objects. `Combobox.List` takes a function child and
+* renders one `Combobox.Item` per match, so the filtering, the ARIA wiring
+* (the input keeps focus while the arrows move a highlight through the rows),
+* the positioning and the hidden form input stay with Base UI. On top of that
+* sit the fluid-hover highlight, the merged selection background of
+* `CheckboxGroup`, and a list that oozes out of the field and back through the
+* shared morph (see Morph), goo by default. `multiple` turns the picks into a
+* `string[]` and pairs with `Combobox.Chips`: one chip per pick, Backspace in
+* an empty field drops the last one. Uncontrolled with `defaultValue`, or
+* controlled with `value` plus `onValueChange`.
+*
+* Statics:
+* - `Combobox.Input` — the single-pick field: icon, text input, clear ✕, chevron.
+* - `Combobox.Chips` — the multiple field: one chip per pick ahead of the input.
+* - `Combobox.Content` — the popup surface, holding `Combobox.Empty` and `Combobox.List`:
+*   `side`, `align`, `sideOffset` and the morph options `from`, `effect`, `hideSource`, `tier`.
+* - `Combobox.List` — a row per match, from a `(item, index) => ReactNode` child.
+* - `Combobox.Item` — one row: `value`, optional `icon` and `disabled`.
+* - `Combobox.Empty` — what shows when nothing matches.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Combobox({ children, items, multiple, value, defaultValue, onValueChange, filter, onCreate, createLabel, creatable, hideSelected, disabled, name, required, size }: ComboboxProps): Element_12xgc5;
+interface ComboboxFieldProps extends Omit<InputHTMLAttributes2<HTMLInputElement>, "size" | "value" | "defaultValue" | "onChange">, VariantProps3<typeof fieldVariants> {
+	/** Framed at rest, or invisible until hovered or focused. Defaults to `"bordered"`. */
+	variant?: "bordered" | "borderless" | null;
+	/** Leading icon inside the field. */
+	icon?: IconComponent;
+	/** Shown while nothing is typed or selected. Defaults to `"Search…"`. */
+	placeholder?: string;
+	/** Error message under the field; tints the ring and sets `aria-invalid`. */
+	error?: string;
+	/** Render a ✕ that clears the selection and query. Its slot is always
+	*  reserved so the field never changes width. Defaults to `false`. */
+	clearable?: boolean;
+	/** Size override for the field alone. Prefer the `size` prop on <Combobox>
+	*  (or a surrounding SizeProvider) so the popup matches. */
+	size?: SizeVariant;
+}
+type ComboboxInputProps = ComboboxFieldProps;
+declare const ComboboxInput: ForwardRefExoticComponent_tcubfn3<ComboboxFieldProps & RefAttributes_miuf563<HTMLInputElement>>;
+type ComboboxChipsProps = ComboboxFieldProps;
+declare const ComboboxChips: ForwardRefExoticComponent_tcubfn3<ComboboxFieldProps & RefAttributes_miuf563<HTMLInputElement>>;
+interface ComboboxContentProps {
+	/** Classes for the popup surface — merged after the radius and max-height. */
+	className?: string;
+	/** `Combobox.Empty` and `Combobox.List`. */
+	children: ReactNode6;
+	/** Side of the field the popup prefers. Defaults to `"bottom"`. */
+	side?: "top" | "bottom" | "left" | "right";
+	/** Alignment against the field. Defaults to `"start"`. */
+	align?: "start" | "center" | "end";
+	/** Gap to the field, in px. Ignored when the list opens in place over the field (`effect="morph"` with `hideSource`). Defaults to `6`. */
+	sideOffset?: number;
+	/** Where the list grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject3<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the list. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+}
+declare const ComboboxContent: ForwardRefExoticComponent_tcubfn3<ComboboxContentProps & RefAttributes_miuf563<HTMLDivElement>>;
+interface ComboboxListProps {
+	/** Classes for the rows' container. */
+	className?: string;
+	/** Render one row per matching item: `(item, index) => <Combobox.Item …/>`. Rows get their index from the list. */
+	children: (item: ComboboxItemData, index: number) => ReactNode6;
+}
+declare const ComboboxList: ForwardRefExoticComponent_tcubfn3<ComboboxListProps & RefAttributes_miuf563<HTMLDivElement>>;
+interface ComboboxItemProps extends HTMLAttributes5<HTMLDivElement> {
+	/** Leading icon in the row. */
+	icon?: IconComponent;
+	/** The item's value — a string item itself, or an object item's `value`. */
+	value: string;
+	/** Disables the row. Defaults to `false`. */
+	disabled?: boolean;
+	/** The row label. */
+	children?: ReactNode6;
+}
+declare const ComboboxItem: ForwardRefExoticComponent_tcubfn3<ComboboxItemProps & RefAttributes_miuf563<HTMLDivElement>>;
+interface ComboboxEmptyProps extends HTMLAttributes5<HTMLDivElement> {
+	/** Shown instead of the children when `hideSelected` has emptied the
+	*  list with nothing typed: every item is a chip already. */
+	allSelected?: ReactNode6;
+	/** Shown when nothing matches the query. */
+	children?: ReactNode6;
+}
+declare const ComboboxEmpty: ForwardRefExoticComponent_tcubfn3<ComboboxEmptyProps & RefAttributes_miuf563<HTMLDivElement>>;
+import { Locale } from "date-fns";
+import { ReactNode as ReactNode7 } from "react";
+import { DayPickerProps } from "react-day-picker";
+import { JSX as JSX_1kxb6 } from "react";
+type Element_12xgc6 = JSX_1kxb6["Element"];
+/**
+* A calendar that scrolls through the months instead of paging, with month
+* and year columns to jump by.
+*
+* Months run on in one list, each under its name, with the weekday row pinned
+* above them; weekends step back to the muted text and today carries a dot. The month column
+* marks the month being read and the year column its year, so either works
+* as a scrollbar you can click: a month or a year scrolls the calendar there.
+* The picked day, month and year show a filled pill or a dot. The columns
+* stand after the days by default; `columnsSide="start"` puts them before
+* (and `extraColumnsSide` places any extra ones). When the calendar is too
+* narrow for them, they turn into strips above it. The list renders a window of months and moves it as you scroll, so the
+* range is as long as `startMonth` / `endMonth` allow (100 years back and 50
+* ahead by default).
+*
+* It is react-day-picker's DayPicker underneath: `mode` (`'single'`,
+* `'range'`), `selected` / `onSelect`, `disabled` and `hidden` matchers,
+* `modifiers`, `weekStartsOn`, `dir` and the other DayPicker props pass
+* through. Its navigation props don't apply: the calendar scrolls.
+* DatePicker and DateRangePicker put it in a field.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Calendar({ locale, size, columnsSide, extraColumns, extraColumnsSide, className,...props }: DayPickerProps & {
+	/** The locale: a react-day-picker / date-fns locale (`import { de } from 'react-day-picker/locale'`). Names months and weekdays, picks the first day of the week. Defaults to `enUS`. */
+	locale?: Locale;
+	/** Pins the calendar to one step of the size ladder (36px days, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Which side of the days the month and year columns stand on; the month column keeps next to the days. Defaults to `'end'`. */
+	columnsSide?: "start" | "end";
+	/** More columns, given the layout's orientation — the date picker's hours and minutes. */
+	extraColumns?: (orientation: "vertical" | "horizontal") => ReactNode7;
+	/** Which side of the days the extra columns stand on, outside the month and year columns when they share it. Defaults to `'end'`. */
+	extraColumnsSide?: "start" | "end";
+	/** Classes for the calendar's box. */
+	className?: string;
+}): Element_12xgc6;
+type CalendarProps = Parameters<typeof Calendar>[0];
+import { Locale as Locale3 } from "date-fns";
+import { RefObject as RefObject4 } from "react";
+import { Matcher } from "react-day-picker";
+type HourCycle = "h11" | "h12" | "h23" | "h24";
+import { JSX as JSX_1kxb7 } from "react";
+interface DatePickerProps {
+	/** The picked date (and time, with `withTime`); `null` when empty. */
+	value?: Date | null;
+	/** Initial date, for an uncontrolled picker. Defaults to `null`. */
+	defaultValue?: Date | null;
+	/** Called with the new date, or `null` when the field is cleared. */
+	onValueChange?: (value: Date | null) => void;
+	/** Adds hour and minute columns, and the time to the field. Defaults to `false`. */
+	withTime?: boolean;
+	/** The clock for the time: on `'h12'` / `'h11'` the hours read with AM/PM. Defaults to the locale's. */
+	hourCycle?: HourCycle;
+	/** Steps between the minute column's options. Defaults to `1`. */
+	minuteStep?: number;
+	/** A react-day-picker / date-fns locale (`import { de } from 'react-day-picker/locale'`): names, formats, the week's first day and what typing reads. Defaults to `enUS`. */
+	locale?: Locale3;
+	/** Shown while empty. */
+	placeholder?: string;
+	/** `true` disables the field; any other react-day-picker matcher (a date, `{ before }`, `{ dayOfWeek }`, a function…) disables the days it matches. */
+	disabled?: Matcher | Matcher[];
+	/** The first month the calendar reaches. Defaults to 100 years back. */
+	startMonth?: Date;
+	/** The last month the calendar reaches. Defaults to 50 years ahead. */
+	endMonth?: Date;
+	/** Marks the field invalid. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the field and its panel to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled panel. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the panel opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Text direction of the panel; `'rtl'` mirrors it. */
+	dir?: "ltr" | "rtl";
+	/** Which side of the days the month and year columns stand on. Defaults to `'end'`. */
+	columnsSide?: "start" | "end";
+	/** Which side of the days the hour and minute columns stand on, outside the month and year columns when they share it. Defaults to `'end'`. */
+	timeColumnsSide?: "start" | "end";
+	/** Id of the field, for a `Label`'s `htmlFor`. */
+	id?: string;
+	/** Where the panel grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject4<HTMLElement | null>;
+	/** How the panel grows (see Morph), as Combobox's list does: with the liquid goo neck, a plain morph, a slide or a fade. `'morph'` with `hideSource` opens it in place over the field. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the field. */
+	className?: string;
+}
+type Element_12xgc7 = JSX_1kxb7["Element"];
+/**
+* A date field that opens a scrolling calendar, with an optional time.
+*
+* Pressing the field opens its panel the way Combobox opens its list (goo out
+* of the field; `effect="morph"` with `hideSource` turns the field into it in
+* place): the date as text, selected and ready to type over, above a Calendar
+* whose months scroll past with month and year columns beside them. Typing
+* reads the date in the locale's own formats ("9.10.2026", "9 Oct 2026",
+* "October 9, 2026") and scrolls the calendar to it; picking a day commits it
+* and closes the panel. `withTime` adds the time beside the date and hour and
+* minute columns (the hours read with AM/PM on a 12-hour clock), and keeps the
+* panel open while you set both. `columnsSide` and `timeColumnsSide` stand
+* either set of columns before or after the days. On a phone the panel is a
+* bottom sheet, its columns turned into strips above the days.
+*
+* Localized through `locale`, a react-day-picker locale: month and weekday
+* names, the formats shown and read, the week's first day and the clock all
+* follow it, and `dir="rtl"` mirrors the panel.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function DatePicker({ value: valueProp, defaultValue, onValueChange, withTime, hourCycle, minuteStep, locale, placeholder, disabled, startMonth, endMonth, invalid, size, open: openProp, defaultOpen, onOpenChange, dir, columnsSide, timeColumnsSide, id, from, effect, hideSource, tier, className }: DatePickerProps): Element_12xgc7;
+import { Locale as Locale4 } from "date-fns";
+import { RefObject as RefObject5 } from "react";
+import { DateRange, Matcher as Matcher2 } from "react-day-picker";
+import { JSX as JSX_1kxb8 } from "react";
+interface DateRangePickerProps {
+	/** The picked range, react-day-picker's `{ from, to }`; `null` when empty. */
+	value?: DateRange | null;
+	/** Initial range, for an uncontrolled picker. Defaults to `null`. */
+	defaultValue?: DateRange | null;
+	/** Called with the new range: `{ from }` alone after the first click, `null` when cleared. */
+	onValueChange?: (value: DateRange | null) => void;
+	/** A react-day-picker / date-fns locale (`import { de } from 'react-day-picker/locale'`). Defaults to `enUS`. */
+	locale?: Locale4;
+	/** Shown while empty. */
+	placeholder?: string;
+	/** `true` disables the field; any other react-day-picker matcher disables the days it matches. */
+	disabled?: Matcher2 | Matcher2[];
+	/** The first month the calendar reaches. Defaults to 100 years back. */
+	startMonth?: Date;
+	/** The last month the calendar reaches. Defaults to 50 years ahead. */
+	endMonth?: Date;
+	/** Marks the field invalid. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the field and its panel to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled panel. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the panel opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Text direction of the panel; `'rtl'` mirrors it. */
+	dir?: "ltr" | "rtl";
+	/** Which side of the days the month and year columns stand on. Defaults to `'end'`. */
+	columnsSide?: "start" | "end";
+	/** Id of the field, for a `Label`'s `htmlFor`. */
+	id?: string;
+	/** Where the panel grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject5<HTMLElement | null>;
+	/** How the panel grows (see Morph), as Combobox's list does: with the liquid goo neck, a plain morph, a slide or a fade. `'morph'` with `hideSource` opens it in place over the field. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the field. */
+	className?: string;
+}
+type Element_12xgc8 = JSX_1kxb8["Element"];
+/**
+* A field for a span of days, picked with two clicks on a scrolling calendar.
+*
+* The first click starts the range and the days under the pointer preview it;
+* the second ends it (either way round) and closes the panel. The header
+* holds both ends as text, each read in the locale's formats as you type, and
+* the field shows the range the way the locale writes one ("9 – 15 Oct
+* 2026"). Everything else — the month and year columns, the bottom sheet on a
+* phone, the locale — works as in DatePicker.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function DateRangePicker({ value: valueProp, defaultValue, onValueChange, locale, placeholder, disabled, startMonth, endMonth, invalid, size, open: openProp, defaultOpen, onOpenChange, dir, columnsSide, id, from: growFrom, effect, hideSource, tier, className }: DateRangePickerProps): Element_12xgc8;
+import { Duration, Locale as Locale5 } from "date-fns";
+import { RefObject as RefObject6 } from "react";
+import { JSX as JSX_1kxb9 } from "react";
+interface DurationPickerProps {
+	/** The picked duration, a date-fns `Duration` (`{ hours, minutes }`); `null` when empty. */
+	value?: Duration | null;
+	/** Initial duration, for an uncontrolled picker. Defaults to `null`. */
+	defaultValue?: Duration | null;
+	/** Called with the new duration, or `null` when the field is cleared. */
+	onValueChange?: (value: Duration | null) => void;
+	/** The longest duration's hours: the hour column runs from 0 to it. Defaults to `99`. */
+	maxHours?: number;
+	/** Steps between the minute column's options. Defaults to `1`. */
+	minuteStep?: number;
+	/** A react-day-picker / date-fns locale: the field spells the duration out in it ("1 Stunde 30 Minuten"). Defaults to `enUS`. */
+	locale?: Locale5;
+	/** Shown while empty. */
+	placeholder?: string;
+	/** Disables the field. Defaults to `false`. */
+	disabled?: boolean;
+	/** Marks the field invalid. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the field and its panel to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled panel. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the panel opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Id of the field, for a `Label`'s `htmlFor`. */
+	id?: string;
+	/** Where the panel grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject6<HTMLElement | null>;
+	/** How the panel grows (see Morph), as Combobox's list does: with the liquid goo neck, a plain morph, a slide or a fade. `'morph'` with `hideSource` opens it in place over the field. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the field. */
+	className?: string;
+}
+type Element_12xgc9 = JSX_1kxb9["Element"];
+/**
+* A field for a length of time, in hours and minutes.
+*
+* The field spells the duration out in the locale ("1 hour 30 minutes"); its
+* panel has it as `H:mm` to type over, above an hour column (0 to `maxHours`)
+* and a minute column stepping by `minuteStep`. The value is a date-fns
+* `Duration`, `{ hours, minutes }`, ready for `formatDuration` or date math.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function DurationPicker({ value: valueProp, defaultValue, onValueChange, maxHours, minuteStep, locale, placeholder, disabled, invalid, size, open: openProp, defaultOpen, onOpenChange, id, from, effect, hideSource, tier, className }: DurationPickerProps): Element_12xgc9;
+import { Locale as Locale6 } from "date-fns";
+import { RefObject as RefObject7 } from "react";
+import { JSX as JSX_1kxb10 } from "react";
+interface MonthPickerProps {
+	/** The picked month as its first day; `null` when empty. */
+	value?: Date | null;
+	/** Initial month, for an uncontrolled picker. Defaults to `null`. */
+	defaultValue?: Date | null;
+	/** Called with the new month's first day, or `null` when the field is cleared. */
+	onValueChange?: (value: Date | null) => void;
+	/** A react-day-picker / date-fns locale: month names and what typing reads. Defaults to `enUS`. */
+	locale?: Locale6;
+	/** Shown while empty. */
+	placeholder?: string;
+	/** The first month that can be picked. Defaults to 100 years back. */
+	startMonth?: Date;
+	/** The last month that can be picked. Defaults to 50 years ahead. */
+	endMonth?: Date;
+	/** Disables the field. Defaults to `false`. */
+	disabled?: boolean;
+	/** Marks the field invalid. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the field and its panel to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled panel. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the panel opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Id of the field, for a `Label`'s `htmlFor`. */
+	id?: string;
+	/** Where the panel grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject7<HTMLElement | null>;
+	/** How the panel grows (see Morph), as Combobox's list does: with the liquid goo neck, a plain morph, a slide or a fade. `'morph'` with `hideSource` opens it in place over the field. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the field. */
+	className?: string;
+}
+type Element_12xgc10 = JSX_1kxb10["Element"];
+/**
+* A field for a month of a year: a billing period, a card's expiry.
+*
+* The panel has the month as text to type over ("October 2026", "10/2026"),
+* above a month column and a year column; the picked month and year carry a
+* dot. The value is the month's first day, the way react-day-picker names a
+* month.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function MonthPicker({ value: valueProp, defaultValue, onValueChange, locale, placeholder, startMonth, endMonth, disabled, invalid, size, open: openProp, defaultOpen, onOpenChange, id, from, effect, hideSource, tier, className }: MonthPickerProps): Element_12xgc10;
+import { Locale as Locale7 } from "date-fns";
+import { RefObject as RefObject8 } from "react";
+import { JSX as JSX_1kxb11 } from "react";
+interface TimePickerProps {
+	/** The picked time as `"HH:mm"` on a 24-hour clock (an `<input type="time">`'s value); `null` when empty. */
+	value?: string | null;
+	/** Initial time, for an uncontrolled picker. Defaults to `null`. */
+	defaultValue?: string | null;
+	/** Called with the new `"HH:mm"`, or `null` when the field is cleared. */
+	onValueChange?: (value: string | null) => void;
+	/** The clock shown: on `'h12'` / `'h11'` the hours read with AM/PM. Defaults to the locale's. */
+	hourCycle?: HourCycle;
+	/** Steps between the minute column's options. Defaults to `1`. */
+	minuteStep?: number;
+	/** A react-day-picker / date-fns locale: the time's format and the AM/PM names. Defaults to `enUS`. */
+	locale?: Locale7;
+	/** Shown while empty. */
+	placeholder?: string;
+	/** Disables the field. Defaults to `false`. */
+	disabled?: boolean;
+	/** Marks the field invalid. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the field and its panel to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled panel. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the panel opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Id of the field, for a `Label`'s `htmlFor`. */
+	id?: string;
+	/** Where the panel grows from (see Morph): the field, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'` (the field). */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject8<HTMLElement | null>;
+	/** How the panel grows (see Morph), as Combobox's list does: with the liquid goo neck, a plain morph, a slide or a fade. `'morph'` with `hideSource` opens it in place over the field. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the field while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the field. */
+	className?: string;
+}
+type Element_12xgc11 = JSX_1kxb11["Element"];
+/**
+* A time-of-day field with scrolling hour and minute columns.
+*
+* The panel opens with the time as text, selected and ready to type over
+* ("15:33", "3:33 PM"), above an hour column and a minute column; on a
+* 12-hour clock the hours read with AM/PM. Each column keeps its pick in the middle and
+* marks it with a dot. The value is `"HH:mm"` on a 24-hour clock whatever the
+* locale shows, the same as a native time input's.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function TimePicker({ value: valueProp, defaultValue, onValueChange, hourCycle, minuteStep, locale, placeholder, disabled, invalid, size, open: openProp, defaultOpen, onOpenChange, id, from, effect, hideSource, tier, className }: TimePickerProps): Element_12xgc11;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent4, HTMLAttributes as HTMLAttributes6, InputHTMLAttributes as InputHTMLAttributes3, LabelHTMLAttributes, ReactNode as ReactNode8, RefAttributes as RefAttributes4 } from "react";
+interface InputProps extends Omit<InputHTMLAttributes3<HTMLInputElement>, "onChange" | "value" | "defaultValue" | "size"> {
+	/** Placeholder text. */
+	placeholder?: string;
+	/** Leading icon inside the input. */
+	icon?: IconComponent;
+	/** Controlled input value. */
+	value?: string;
+	/** Initial value when uncontrolled. Defaults to `''`. */
+	defaultValue?: string;
+	/** Called when the input value changes. */
+	onChange?: (value: string) => void;
+	/** Marks the value invalid: the field turns destructive and sets `aria-invalid`. Defaults to `false`. */
+	invalid?: boolean;
+	/** Disables the input. Defaults to `false`. */
+	disabled?: boolean;
+	/** Pins the input to one step of the size ladder (default 36px, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Classes for the ringed box around the input. */
+	className?: string;
+}
+/**
+* Text input with a fluid hover ring.
+*
+* At rest the field is bare text on the page. Hover lifts it onto a muted
+* ground with a hairline ring, focus onto the card ground, and its leading
+* icon thickens. `invalid` turns it destructive. It is uncontrolled with
+* `defaultValue`, or controlled with `value` + `onChange`, and fills the width
+* of its container. Pair it with a `Label` through `htmlFor` / `id`.
+*
+* Also exported from this item:
+* - `Label` — the field label, weight-stable and inset to line up with the
+*   input's text: `htmlFor`, `invalid`, `size`.
+* - `InputGroup` — stacks labelled fields and tracks the pointer across them,
+*   so the hover glides from field to field: `size` pins every field to one
+*   step of the ladder.
+* - `InputGroup.Field` — one labelled Input in a group, wired as a Base UI
+*   `Field` (label, control and error message linked for assistive tech):
+*   `index` (its position, for the fluid hover), `label`, `labelHidden`,
+*   `error` (a message below the input; marks it invalid), plus Input's props.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Input2: ForwardRefExoticComponent4<InputProps & RefAttributes4<HTMLInputElement>>;
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+	/** Label text. */
+	children: ReactNode8;
+	/** Turns the label destructive, matching an invalid Input. Defaults to `false`. */
+	invalid?: boolean;
+	/** Pins the label to one step of the size ladder. Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+declare const Label2: ForwardRefExoticComponent4<LabelProps & RefAttributes4<HTMLLabelElement>>;
+interface InputGroupProps extends HTMLAttributes6<HTMLDivElement> {
+	/** One or more InputGroup.Field children. */
+	children: ReactNode8;
+	/** Pins the group's fields to one step of the size ladder (default 36px, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type InputGroupComponent = ForwardRefExoticComponent4<InputGroupProps & RefAttributes4<HTMLDivElement>> & {
+	Field: typeof InputField;
+};
+declare const InputGroup: InputGroupComponent;
+interface InputFieldProps extends Omit<InputProps, "invalid" | "size" | "className"> {
+	/** Label text above the input. */
+	label: string;
+	/** Keep the label for assistive tech but don't render it — for inline fields (a toolbar search) where the placeholder carries the meaning. Defaults to `false`. */
+	labelHidden?: boolean;
+	/** Position index within the group (required for fluid hover). */
+	index: number;
+	/** Error message shown below the input. */
+	error?: string;
+	className?: string;
+}
+declare const InputField: ForwardRefExoticComponent4<InputFieldProps & RefAttributes4<HTMLDivElement>>;
+import { HTMLAttributes as HTMLAttributes7 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn4 } from "react";
+import { RefAttributes as RefAttributes_miuf564 } from "react";
+type InputCopyVariant = "icon" | "button";
+type InputCopyAlign = "right" | "left";
+interface InputCopyProps extends Omit<HTMLAttributes7<HTMLDivElement>, "children"> {
+	/** The text value to display and copy to clipboard. */
+	value: string;
+	/** Optional label displayed above the input. */
+	label?: string;
+	/** Callback fired after the value is successfully copied. */
+	onCopy?: () => void;
+	/** Disables the input and copy button. Defaults to `false`. */
+	disabled?: boolean;
+	/** Icon-only with tooltip, or button with visible label. Defaults to `"icon"`. */
+	variant?: InputCopyVariant;
+	/** Position of the copy action relative to the value. Defaults to `"right"`. */
+	align?: InputCopyAlign;
+	/** Pins the field to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, it follows the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Extra classes for the wrapper around the label and the field. */
+	className?: string;
+}
+/**
+* Read-only input with a copy-to-clipboard button and animated check
+* feedback.
+*
+* The whole row is the button: click anywhere on it and the value goes to
+* the clipboard, the copy glyph's two sheets melt into a tinted disc (the
+* goo of Morph) behind a check that draws itself, and the tooltip flips to
+* "Copied" for 2 seconds; then the disc splits back into the glyph. The value is monospaced and
+* highlights on hover so it reads as one selectable token rather than a
+* text field, and the async Clipboard API falls back to an off-screen
+* textarea + `execCommand` where it is unavailable (insecure context,
+* permissions policy) — a failure animates a ✕ and says so. `variant`
+* switches between the icon-only affordance (with a tooltip) and a labelled
+* Copy button, `align` moves that action to the leading edge, and the field
+* follows the surrounding SizeProvider unless `size` pins it.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const InputCopy: ForwardRefExoticComponent_tcubfn4<InputCopyProps & RefAttributes_miuf564<HTMLDivElement>>;
+import { HTMLAttributes as HTMLAttributes8, ReactNode as ReactNode9, TextareaHTMLAttributes } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn5 } from "react";
+import { RefAttributes as RefAttributes_miuf565 } from "react";
+import { JSX as JSX_1kxb12 } from "react";
+interface FileThumbnailProps {
+	file: File;
+	/** Side length of the square thumbnail in pixels. */
+	size: number;
+	className?: string;
+}
+type Element_12xgc12 = JSX_1kxb12["Element"];
+declare function FileThumbnail({ file, size, className }: FileThumbnailProps): Element_12xgc12;
+type InputMessageStatus = "idle" | "streaming";
+interface InputMessageSlotContext {
+	/** Opens the native file picker via the hidden `<input type="file">`.
+	*  Pass `acceptOverride` (e.g. `"image/*"`) to scope the picker to a
+	*  subset of the component's accept types just for this invocation. */
+	openFilePicker: (acceptOverride?: string) => void;
+	/** Currently-attached files. */
+	files: File[];
+}
+type InputMessageSlot = ReactNode9 | ((ctx: InputMessageSlotContext) => ReactNode9);
+/** A message held in the queue while the assistant is responding. Carries the
+*  trimmed text plus a snapshot of the files attached when it was queued, so
+*  double-click-to-edit can restore both. `id` is a stable key minted on enqueue. */
+interface QueuedMessage {
+	id: string;
+	text: string;
+	files: File[];
+}
+interface InputMessageProps extends Omit<HTMLAttributes8<HTMLDivElement>, "onChange" | "defaultValue"> {
+	/** Step on the size ladder (see Sizes). Wins over the surrounding SizeProvider and propagates to the composer's rows, buttons and queued messages. */
+	size?: SizeVariant;
+	/** Controlled textarea value. Pair with `onValueChange`; omit both for an uncontrolled composer. */
+	value?: string;
+	/** Initial textarea value for an uncontrolled composer. Defaults to `""`. */
+	defaultValue?: string;
+	/** Called with the new value on every textarea change. */
+	onValueChange?: (value: string) => void;
+	/** Fires on Enter (without Shift) or send-button click, and when a queued message auto-dispatches. Receives the trimmed value, the attached files, and — for auto-dispatched queue items — `meta.queuedId`. Skipped when the value is empty and no files are attached. */
+	onSend?: (value: string, files: File[], meta?: {
+		queuedId?: string;
+	}) => void;
+	/** Placeholder shown when the value is empty. While a file is dragged over the component (and attachments are enabled) it swaps to "Drop files here to add to chat". Defaults to `"Ask me anything…"`. */
+	placeholder?: string;
+	/** Content rendered in the bottom-left action area. May be a render-fn that receives `{ openFilePicker, files }` — `openFilePicker(acceptOverride?)` opens the native file picker. */
+	leftSlot?: InputMessageSlot;
+	/** Content rendered in the bottom-right action area, before the built-in send button. Same render-fn shape as `leftSlot`. */
+	rightSlot?: InputMessageSlot;
+	/** Disables the textarea, send button, and drag-and-drop. Defaults to `false`. */
+	disabled?: boolean;
+	/** Minimum visible rows before the textarea grows. Defaults to 1. */
+	minRows?: number;
+	/** Maximum visible rows before the textarea starts to scroll. Defaults to 8. */
+	maxRows?: number;
+	/** When true, clicking anywhere on the surrounding container (outside of buttons / links / inputs) focuses the textarea. Defaults to `true`. */
+	clickToFocus?: boolean;
+	/** Accessible label for the send button. Defaults to `"Send"`. */
+	sendLabel?: string;
+	/** Controlled list of attached files. Pair with `onFilesChange` to enable drag-and-drop and the file-picker slot helper. */
+	files?: File[];
+	/** Initial attachments for an uncontrolled composer. Providing it (even as `[]`) enables attachment behavior on its own. */
+	defaultFiles?: File[];
+	/** Called when files are added (drag-drop or picker) or removed via the preview tile's × button. Duplicate drops of the same file (same name + size + lastModified) are silently de-duplicated. */
+	onFilesChange?: (files: File[]) => void;
+	/** Accepted MIME types as a comma-separated string. Used by both the file picker and the drag-and-drop filter. Defaults to `"image/png,image/jpeg,application/pdf"`. */
+	accept?: string;
+	/** Maximum number of attached files. Extra files beyond this limit are dropped. */
+	maxFiles?: number;
+	/** Side length (in pixels) of each preview tile. Images use object-cover; PDFs render the first page via pdfjs; other types fall back to a centered icon. Defaults to 80. */
+	filePreviewSize?: number;
+	/** Extra props forwarded to the underlying textarea (value, onChange, onKeyDown, disabled and placeholder are controlled by the component). */
+	textareaProps?: Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "onChange" | "onKeyDown" | "disabled" | "placeholder">;
+	/** Assistant response state. When `"streaming"`, the send button becomes a Stop control (empty draft) or a Queue action (non-empty draft). On the streaming→idle edge the next queued message auto-dispatches via `onSend`. Leave it and `defaultStatus` undefined for the send-immediately behavior. */
+	status?: InputMessageStatus;
+	/** Initial status for an uncontrolled composer — the component then owns the streaming flag, and Stop flips it to `"idle"` itself. */
+	defaultStatus?: InputMessageStatus;
+	/** Called whenever the status changes while it is uncontrolled (currently: the Stop control). */
+	onStatusChange?: (status: InputMessageStatus) => void;
+	/** Fires when the Stop control is pressed (streaming + empty draft). Halt the current response and set status to `"idle"` — that edge immediately dispatches the next queued message. */
+	onStop?: () => void;
+	/** Controlled queue of pending messages, rendered as reorderable rows above the textarea. Double-click (or Enter/F2) edits a row back into the composer; the × (or Delete) removes it; drag — or Alt+↑/↓ — reorders. Requires a status. */
+	queue?: QueuedMessage[];
+	/** Initial queue for an uncontrolled composer. Providing it (even as `[]`) enables the queue on its own, alongside `status` or `defaultStatus`. */
+	defaultQueue?: QueuedMessage[];
+	/** Called whenever the queue changes — enqueue, edit, delete, reorder, or auto-dispatch. Each QueuedMessage is `{ id, text, files }`. */
+	onQueueChange?: (queue: QueuedMessage[]) => void;
+	/** Render the built-in reorderable queue rows above the textarea. Set to false to suppress them and render the queue yourself — enqueue and auto-dispatch still run. Defaults to `true`. */
+	showQueue?: boolean;
+	/** Previously-sent messages, oldest first. With the textarea focused, ArrowUp (caret on the first line) recalls the previous message and walks backward; ArrowDown (caret on the last line) walks forward toward the in-progress draft. Editing or sending exits history mode. Defaults to `[]`. */
+	history?: string[];
+	/** Suggested prompt rendered as the placeholder (with a Tab keycap) while the draft is empty. Pressing Tab fills it into the composer — it doesn't send. Takes precedence over `placeholder`. */
+	placeholderSuggestion?: string;
+	/** Suggested prompts listed under the action bar while the draft is empty. ArrowDown moves a highlight into the list (focus stays in the textarea), ArrowUp walks back up and out, Enter or click fills the highlighted prompt. Escape drops the highlight; typing collapses the list. */
+	suggestions?: string[];
+	/** Extra classes for the composer surface. */
+	className?: string;
+}
+/**
+* Chat-style message composer with an auto-resizing textarea, flexible
+* left/right action slots, and a built-in send button on a Surface-2
+* substrate.
+*
+* The textarea grows from `minRows` to `maxRows` and then scrolls, Enter
+* sends while Shift+Enter breaks the line, and the whole panel is one
+* hairline ring that recolours in place for hover, focus and drag instead of
+* layering a second border. Attachments drop anywhere on the composer (or
+* come from `openFilePicker` in a slot) and preview as tiles — images
+* object-cover, PDFs render their first page. `suggestions` open a listbox
+* under the action bar that ↓/↑ walk without moving focus, and
+* `placeholderSuggestion` writes a ghost prompt with a Tab keycap. With a
+* `status` the send button morphs into Stop (empty draft) or Queue (draft
+* typed while streaming); queued rows reorder by drag or Alt+↑/↓, edit back
+* into the composer on double-click, and the head auto-dispatches on the
+* streaming→idle edge.
+*
+* Every controlled prop has an uncontrolled twin — `defaultValue`,
+* `defaultFiles`, `defaultQueue`, `defaultStatus` — so a composer can hold
+* its own draft, attachments and queue with no state in the caller.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const InputMessage: ForwardRefExoticComponent_tcubfn5<InputMessageProps & RefAttributes_miuf565<HTMLDivElement>>;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent5, HTMLAttributes as HTMLAttributes9, ReactNode as ReactNode10, RefAttributes as RefAttributes5 } from "react";
+interface RadioGroupProps extends Omit<HTMLAttributes9<HTMLDivElement>, "onSelect" | "defaultValue"> {
+	/** RadioGroup.Item children. */
+	children: ReactNode10;
+	/** Index of the currently selected item. Controlled — pair it with `onSelectedIndexChange` (or per-item `onSelect`). */
+	selectedIndex?: number;
+	/** Selected index on first render when uncontrolled. Defaults to no selection. */
+	defaultSelectedIndex?: number;
+	/** Called with the new index whenever an item is selected. */
+	onSelectedIndexChange?: (index: number) => void;
+	/** Selected item `value` (value mode; items then need a `value`). Controlled; wraps the group in Base UI's RadioGroup for form integration. */
+	value?: string;
+	/** Selected item `value` on first render when uncontrolled (value mode). */
+	defaultValue?: string;
+	/** Called with the selected item's `value` when it changes (value mode). */
+	onValueChange?: (value: string) => void;
+	/** Pins the group's rows to one step of the size ladder (default 36px, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type RadioGroupComponent = ForwardRefExoticComponent5<RadioGroupProps & RefAttributes5<HTMLDivElement>> & {
+	Item: typeof RadioItem;
+};
+/**
+* Radio button group with fluid hover and animated selection.
+*
+* Each row is a `RadioGroup.Item` with a stable `index`. The selected
+* background melts to the chosen row, a fluid hover highlight melts between
+* rows (the liquid indicators in Morph), the dot scales in, and the label animates to semibold without shifting
+* its width. Arrow keys, Home and End move focus and select, with a roving
+* tabindex on the selected row. Select by index — uncontrolled with
+* `defaultSelectedIndex`, controlled with `selectedIndex` +
+* `onSelectedIndexChange` — or by item `value` (`defaultValue` / `value` +
+* `onValueChange`), which also renders Base UI radios for form integration.
+* FF's per-item `selected` / `onSelect` still work and override the group for
+* their row.
+*
+* Statics:
+* - `RadioGroup.Item` — one radio row: `label`, `index`, and optional `value`,
+*   `selected`, `onSelect`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const RadioGroup: RadioGroupComponent;
+interface RadioItemProps extends HTMLAttributes9<HTMLDivElement> {
+	/** Text label for the radio item. */
+	label: string;
+	/** Position index within the group. */
+	index: number;
+	/** Whether this item is selected. Defaults to the group's selection. */
+	selected?: boolean;
+	/** Called when this item is selected (the group's change callbacks fire too). */
+	onSelect?: () => void;
+	/** Optional value forwarded to the underlying Base UI primitive for form integration. */
+	value?: string;
+}
+declare const RadioItem: ForwardRefExoticComponent5<RadioItemProps & RefAttributes5<HTMLDivElement>>;
+import { Autocomplete } from "@base-ui/react/autocomplete";
+import { HTMLAttributes as HTMLAttributes10, ReactNode as ReactNode12, RefObject as RefObject9 } from "react";
+import { ButtonHTMLAttributes as ButtonHTMLAttributes2, ReactElement as ReactElement2, ReactNode as ReactNode11 } from "react";
+interface SlotProps extends ButtonHTMLAttributes2<HTMLButtonElement> {
+	/** The element that becomes the control, e.g. a Button. */
+	render?: ReactElement2;
+	/** Compose onto the single child instead. Both spellings work in both flavors. Defaults to `false`. */
+	asChild?: boolean;
+	/** Control content when there is no render element. */
+	children?: ReactNode11;
+}
+import { JSX as JSX_1kxb13 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn6 } from "react";
+import { RefAttributes as RefAttributes_miuf566 } from "react";
+/** One command: the label the query matches, plus what the row shows and does. */
+interface CommandItem {
+	label: string;
+	icon?: IconComponent;
+	/** Shown at the end of the row; display only, nothing binds it. */
+	shortcut?: string;
+	/** More words the query matches. */
+	keywords?: string[];
+	disabled?: boolean;
+	onSelect?: () => void;
+}
+interface CommandGroup {
+	label: string;
+	items: CommandItem[];
+}
+type CommandItems = CommandItem[] | CommandGroup[];
+type CommandListRootProps = Omit<Autocomplete.Root.Props<CommandItem>, "items" | "filter" | "itemToStringValue" | "onItemHighlighted"> & {
+	items: CommandItems;
+};
+type Element_12xgc13 = JSX_1kxb13["Element"];
+/** Base UI's Autocomplete set up for command rows: it matches labels and keywords and hands its highlight to `CommandList`. */
+declare function CommandListRoot({ items,...props }: CommandListRootProps): Element_12xgc13;
+declare function CommandShortcut({ className,...props }: HTMLAttributes10<HTMLElement>): Element_12xgc13;
+interface CommandListProps {
+	onPick: (item: CommandItem) => void;
+	emptyMessage: ReactNode12;
+	className?: string;
+}
+/** The filtered rows (grouped or flat) under one fluid highlight, inside a ScrollArea. Goes inside `CommandListRoot`. */
+declare function CommandList({ onPick, emptyMessage, className }: CommandListProps): Element_12xgc13;
+interface CommandPaletteProps {
+	/** The commands, flat or in labelled groups. */
+	items: CommandItems;
+	/** The search field's placeholder. Defaults to `'Type a command or search…'`. */
+	placeholder?: string;
+	/** Shown when nothing matches the query. Defaults to `'No results found.'`. */
+	emptyMessage?: ReactNode12;
+	/** Classes for the palette's box. */
+	className?: string;
+}
+declare function CommandPalette({ items, placeholder, emptyMessage, className }: CommandPaletteProps): Element_12xgc13;
+declare const CommandTrigger: ForwardRefExoticComponent_tcubfn6<SlotProps & RefAttributes_miuf566<HTMLButtonElement>>;
+interface CommandContentProps extends CommandPaletteProps {
+	/** Accessible name of the panel. Defaults to `'Command menu'`. */
+	label?: string;
+	/** Where the panel grows from (see Morph): the pressed trigger (its center when none), the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject9<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+}
+declare const CommandContent: ForwardRefExoticComponent_tcubfn6<CommandContentProps & RefAttributes_miuf566<HTMLDivElement>>;
+interface CommandProps {
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled palette. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the palette opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** The key that toggles the palette with ⌘ (Ctrl elsewhere); `false` leaves the keyboard alone. Defaults to `'k'`. */
+	hotkey?: string | false;
+	/** The trigger and the panel: `Command.Trigger` plus a `Command.Content`. */
+	children?: ReactNode12;
+}
+/**
+* A ⌘K command menu: a search field over grouped commands, grown out of
+* whatever opened it.
+*
+* Type to filter by label and keywords; the arrows move one highlight
+* through the rows, springing between them like the fluid hover, and Enter
+* or a press runs the command and closes the panel. The first match is
+* always highlighted, so Enter has a target, and an empty result says so.
+* The panel is Dialog's: it grows out of its trigger with the goo neck
+* (see Morph) and sits near the top of the window, so it keeps its top edge
+* still as the list filters. ⌘K (Ctrl+K elsewhere) toggles it from anywhere
+* on the page and still grows it out of the trigger; with several palettes
+* on one page, one answers each press. Escape and a press outside close it.
+* Built on Base UI's Autocomplete, rendered inline: the input keeps focus
+* and screen readers follow the highlighted row.
+*
+* Commands are data: `{ label, icon, shortcut, keywords, disabled, onSelect }`,
+* flat or in `{ label, items }` groups. A `shortcut` is only shown.
+*
+* Statics:
+* - `Command.Trigger` — the control that opens it: `render={<Button/>}` or
+*   `asChild`.
+* - `Command.Content` — the panel: `items`, `placeholder`, `emptyMessage`,
+*   `label`, and the morph options `from`, `effect`, `hideSource`, `tier`.
+* - `Command.Palette` — the search field and list on their own, for a
+*   palette that lives in the page: `items`, `placeholder`, `emptyMessage`.
+* - `Command.Shortcut` — a key hint, as the rows show it, e.g. in the
+*   trigger.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Command({ open, defaultOpen, onOpenChange, hotkey, children }: CommandProps): Element_12xgc13;
+import { JSX as JSX_1kxb14 } from "react";
+interface SearchProps {
+	/** How it rests: a pill showing the placeholder (and the shortcut), or a lone search icon. Defaults to `'pill'`. */
+	variant?: "pill" | "icon";
+	/** The field's placeholder, the pill's label and the accessible name of both. Defaults to `'Search'`. */
+	placeholder?: string;
+	/** Suggestions offered below the field and filtered as you type: strings, or Command items (`{ label, icon, keywords }`). Leave out for a plain search field. */
+	items?: (string | CommandItem)[];
+	/** Controlled query. */
+	value?: string;
+	/** Initial query, for an uncontrolled field. Defaults to `''`. */
+	defaultValue?: string;
+	/** Called on every change of the query. */
+	onValueChange?: (value: string) => void;
+	/** Called with the query on Enter, and with a suggestion's label when one is picked. */
+	onSubmit?: (query: string) => void;
+	/** Controlled expanded state. */
+	expanded?: boolean;
+	/** Initial expanded state, for an uncontrolled field. Defaults to `false`. */
+	defaultExpanded?: boolean;
+	/** Called when the field expands or collapses. */
+	onExpandedChange?: (expanded: boolean) => void;
+	/** Width of the expanded field, in px. Defaults to `288`. */
+	width?: number;
+	/** The edge that stays put: the field grows from it toward the other one, over its neighbors. Defaults to `'start'`. */
+	align?: "start" | "end";
+	/** A key that expands the field from anywhere on the page outside another field, shown on the pill. */
+	shortcut?: string;
+	/** Shown in the suggestions when none matches. Defaults to `'No results found.'`. */
+	emptyMessage?: string;
+	/** How the suggestions grow out of the field (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Spring tier of the suggestions' plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Classes for the root, the box the resting button keeps in the layout. */
+	className?: string;
+}
+type Element_12xgc14 = JSX_1kxb14["Element"];
+/**
+* A search button that grows into the field in place, with suggestions that
+* ooze out below it.
+*
+* At rest it is a pill showing the placeholder, or a lone search icon. A
+* press (or its `shortcut` key) springs it to `width` and focuses the
+* field. It grows over its neighbors rather than pushing them: the resting
+* box stays in the layout, so nothing around it moves, and `align="end"`
+* grows it leftward, for a toolbar's far end. The search icon never moves.
+* Typing opens the suggestions, which melt out of the field through the
+* goo neck (see Morph) once it has finished growing; the arrows move one
+* fluid highlight through them, and Enter or a press picks one. Escape
+* closes the suggestions, then clears the query, then collapses the field
+* and hands focus back to the button; leaving an empty field collapses it
+* too. The field lifts 2 surface levels while open, the same level as its
+* suggestions, so the two read as one liquid.
+*
+* With `items` the field is a combobox over a listbox of suggestions,
+* built on Base UI's Autocomplete (filtering by label and keywords, the
+* input keeps focus while the highlight moves); without, it is a plain
+* search box. Either way it sits in a `<search>` landmark around a form,
+* and Enter reports the query to `onSubmit`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Search2({ variant, placeholder, items, value, defaultValue, onValueChange, onSubmit, expanded, defaultExpanded, onExpandedChange, width, align, shortcut, emptyMessage, effect, tier, className }: SearchProps): Element_12xgc14;
+import { VariantProps as VariantProps4 } from "class-variance-authority";
+import { HTMLAttributes as HTMLAttributes11, ReactNode as ReactNode13 } from "react";
+import { JSX as JSX_1kxb15 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn7 } from "react";
+import { RefAttributes as RefAttributes_miuf567 } from "react";
+import { ClassProp as ClassProp_wz9o0r4 } from "class-variance-authority/types";
+interface SelectProps {
+	/** `Select.Trigger` and `Select.Content`. */
+	children: ReactNode13;
+	/** Controlled selected value. Pair with `onValueChange`. */
+	value?: string;
+	/** Uncontrolled default value — the select then keeps the selection itself. */
+	defaultValue?: string;
+	/** Called when the selected value changes. */
+	onValueChange?: (value: string) => void;
+	/** Disables the entire select. Defaults to `false`. */
+	disabled?: boolean;
+	/** Name for form submission (renders a hidden native input). */
+	name?: string;
+	/** Marks the select as required in forms. Defaults to `false`. */
+	required?: boolean;
+	/** Pins trigger and popup to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, both follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type Element_12xgc15 = JSX_1kxb15["Element"];
+/**
+* An animated select menu: fluid hover on the rows, a popup that oozes out of
+* its trigger, and a checkmark that draws itself as the selection lands.
+*
+* Built on Base UI's Select — positioning and collision flipping, dismissal,
+* typeahead, combobox ARIA and the hidden form input all come from the
+* primitive. This layer adds the magnetic hover background, the selected
+* background that springs from the old row to the picked one, a keyboard
+* focus ring that only appears once you actually use the keyboard, and the
+* popup's open and close through the shared morph (see Morph), goo by
+* default. A pick holds the popup open for 300ms so that acknowledgment is
+* seen; Escape and outside presses close at once. Uncontrolled through
+* `defaultValue`, controlled through `value` + `onValueChange`.
+*
+* Statics: Select.Trigger (variant, icon, placeholder, error),
+* Select.Content (the popup: the morph options from, effect, hideSource,
+* tier), Select.Item (index, value, icon, disabled), Select.Group,
+* Select.Label and Select.Separator.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Select({ children, value, defaultValue, onValueChange, disabled, name, required, size }: SelectProps): Element_12xgc15;
+declare const triggerVariants: (props?: ({
+	variant?: "borderless" | "bordered" | null | undefined;
+} & ClassProp_wz9o0r4) | undefined) => string;
+interface SelectTriggerProps extends Omit<HTMLAttributes11<HTMLButtonElement>, "children">, VariantProps4<typeof triggerVariants> {
+	/** Visual style of the trigger. Defaults to `"bordered"`. */
+	variant?: "bordered" | "borderless";
+	/** Optional icon displayed before the value. */
+	icon?: IconComponent;
+	/** Text shown when no value is selected. Defaults to `"Select…"`. */
+	placeholder?: string;
+	/** Error message shown below the trigger; also tints the border and sets `aria-invalid`. */
+	error?: string;
+	/** Size override for the trigger alone. Prefer the `size` prop on `<Select>` (or a surrounding SizeProvider) so the popup matches. */
+	size?: SizeVariant;
+	/** Extra classes for the trigger button. */
+	className?: string;
+}
+declare const SelectTrigger: ForwardRefExoticComponent_tcubfn7<SelectTriggerProps & RefAttributes_miuf567<HTMLButtonElement>>;
+interface SelectContentProps {
+	/** Where the menu grows from (see Morph): the trigger, the pointer, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | React.RefObject<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the menu. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Additional classes for the menu container. */
+	className?: string;
+	/** `Select.Item`, `Select.Group`, `Select.Label`, `Select.Separator`. */
+	children: ReactNode13;
+}
+declare const SelectContent: ForwardRefExoticComponent_tcubfn7<SelectContentProps & RefAttributes_miuf567<HTMLDivElement>>;
+interface SelectItemProps extends HTMLAttributes11<HTMLDivElement> {
+	/** Optional icon displayed before the label. */
+	icon?: IconComponent;
+	/** Position index within the content — what fluid hover measures rows by. */
+	index: number;
+	/** Unique value for this option. */
+	value: string;
+	/** Disables this individual item. Defaults to `false`. */
+	disabled?: boolean;
+	/** The row label. A string label is also what the trigger shows for this value. */
+	children?: ReactNode13;
+}
+declare const SelectItem: ForwardRefExoticComponent_tcubfn7<SelectItemProps & RefAttributes_miuf567<HTMLDivElement>>;
+declare function SelectGroup({ children, className,...props }: HTMLAttributes11<HTMLDivElement>): Element_12xgc15;
+declare const SelectLabel: ForwardRefExoticComponent_tcubfn7<HTMLAttributes11<HTMLDivElement> & RefAttributes_miuf567<HTMLDivElement>>;
+declare const SelectSeparator: ForwardRefExoticComponent_tcubfn7<HTMLAttributes11<HTMLDivElement> & RefAttributes_miuf567<HTMLDivElement>>;
+import { CSSProperties as CSSProperties2, HTMLAttributes as HTMLAttributes12 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn8 } from "react";
+import { RefAttributes as RefAttributes_miuf568 } from "react";
+type SliderValue = number | [number, number];
+type ValuePosition = "left" | "right" | "top" | "bottom" | "tooltip";
+/** Props of the compact engine — the feature-rich design (ranges, discrete
+*  step lists, value display) that renders the ladder's compact step. The
+*  public <Slider> accepts these plus `variant` and `size`. */
+interface SliderEngineProps extends Omit<HTMLAttributes12<HTMLDivElement>, "onChange" | "defaultValue"> {
+	value: SliderValue;
+	onChange: (value: SliderValue) => void;
+	min?: number;
+	max?: number;
+	step?: number;
+	/**
+	* Discrete list of allowed values, e.g. [0.1, 0.5, 0.7, 1.1, 1.3].
+	*
+	* When set, the thumb snaps only to these values (positioned proportionally
+	* along the track) and arrow keys walk the list. `min`/`max` derive from the
+	* list's extremes and `step` is ignored.
+	*/
+	steps?: number[];
+	showSteps?: boolean;
+	showValue?: boolean;
+	valuePosition?: ValuePosition;
+	formatValue?: (v: number) => string;
+	label?: string;
+	disabled?: boolean;
+	trackClassName?: string;
+	trackStyle?: CSSProperties2;
+	fillClassName?: string;
+	fillStyle?: CSSProperties2;
+	hideFill?: boolean;
+	thumbColor?: string;
+	thumbBorderColor?: string;
+}
+interface SliderComfortableProps extends Omit<HTMLAttributes12<HTMLDivElement>, "onChange" | "defaultValue" | "onDrag" | "onDragStart" | "onDragEnd" | "onDragOver" | "onAnimationStart"> {
+	value: number;
+	onChange: (value: number) => void;
+	min?: number;
+	max?: number;
+	step?: number;
+	variant?: "pips" | "scrubber";
+	label?: string;
+	formatValue?: (v: number) => string;
+	disabled?: boolean;
+}
+interface SliderProps extends Omit<SliderEngineProps, "value" | "onChange"> {
+	/** Step on the size ladder (see Sizes). Default renders the pip/scrubber design; compact renders the dense design. Defaults to the surrounding SizeProvider, else `"default"`. */
+	size?: SizeVariant;
+	/** Default-step layout. "pips" shows discrete dot indicators; "scrubber" drags anywhere in the row for a continuous value. Ignored when the compact design renders. Defaults to `"pips"`. */
+	variant?: "pips" | "scrubber";
+	/** Current value (controlled). Pass an array to enable range mode with two thumbs. Omit it to let the slider keep its own state, seeded from `defaultValue`. */
+	value?: SliderValue;
+	/** Initial value when uncontrolled. An array starts the slider in range mode. Defaults to the lowest of `steps`, else `min`, else `0`. */
+	defaultValue?: SliderValue;
+	/** Called when the value changes via drag, click, or keyboard. */
+	onChange?: (value: SliderValue) => void;
+	/** Minimum value. Defaults to `0`. */
+	min?: number;
+	/** Maximum value. Defaults to `100`. */
+	max?: number;
+	/** Step increment. Thumb snaps to the nearest step during drag. Defaults to `1`. */
+	step?: number;
+	/** Discrete list of allowed values, e.g. 0.1, 0.5, 0.7, 1.1, 1.3. The thumb snaps only to these values and arrow keys walk the list; min/max derive from the list's extremes and step is ignored. */
+	steps?: number[];
+	/** Render dot indicators at each step position on the track. Defaults to `false`. */
+	showSteps?: boolean;
+	/** Whether to display the current value label. Defaults to `true`. */
+	showValue?: boolean;
+	/** Position of the value label. "tooltip" shows above the thumb during interaction. Defaults to `"left"`. */
+	valuePosition?: ValuePosition;
+	/** Custom formatter for the value label. Defaults to `String`. */
+	formatValue?: (v: number) => string;
+	/** Accessible label for the slider, also shown as prefix in the value display. */
+	label?: string;
+	/** Disables all interaction. Defaults to `false`. */
+	disabled?: boolean;
+}
+/**
+* One slider, two ladder steps: the default step's pip/scrubber design, and
+* the compact step's dense design with track fill, range mode, and value
+* display.
+*
+* One component: the default step renders the pip/scrubber design, the
+* compact step the dense one. Compact-only props (an array value, steps,
+* showSteps, showValue, valuePosition, track styling) always render the
+* compact design so no capability is lost. Either design snaps to the step
+* grid while dragging, previews the value you are about to pick as a filled
+* bar plus a tooltip, and carries an invisible Base UI slider underneath for
+* the ARIA roles and arrow-key navigation. In the dense design the value
+* label is click-to-edit.
+*
+* Works controlled (`value` + `onChange`, exactly as upstream) or
+* uncontrolled (`defaultValue`, with `onChange` reporting each change).
+* Track styling props are inherited from the compact engine:
+* `trackClassName`, `trackStyle`, `fillClassName`, `fillStyle`, `hideFill`,
+* `thumbColor` and `thumbBorderColor` — each one also forces the dense
+* design.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Slider: ForwardRefExoticComponent_tcubfn8<SliderProps & RefAttributes_miuf568<HTMLDivElement>>;
+/** @deprecated The comfortable design is now the ladder's default step —
+*  render <Slider> (optionally with `variant`) instead. */
+declare const SliderComfortable: ForwardRefExoticComponent_tcubfn8<SliderComfortableProps & RefAttributes_miuf568<HTMLDivElement>>;
+import { Transition } from "motion/react";
+import { HTMLAttributes as HTMLAttributes13 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn9 } from "react";
+import { RefAttributes as RefAttributes_miuf569 } from "react";
+interface SwitchProps extends HTMLAttributes13<HTMLDivElement> {
+	/** Text label displayed next to the switch. */
+	label: string;
+	/** Whether the switch is on (controlled). Omit it to let the switch keep its own state, seeded from `defaultChecked`. */
+	checked?: boolean;
+	/** Whether the switch starts on when uncontrolled. Defaults to `false`. */
+	defaultChecked?: boolean;
+	/** Called when the switch is toggled. */
+	onToggle?: () => void;
+	/** Called with the new state whenever the switch is toggled, controlled or not. */
+	onCheckedChange?: (checked: boolean) => void;
+	/** Disables the switch. Defaults to `false`. */
+	disabled?: boolean;
+	/** Transition for the thumb's slide and hover/press stretch. Defaults to the `spring.moderate` motion token. */
+	thumbTransition?: Transition;
+	/** Pins the switch to one step of the size ladder (see Sizes). Defaults to the surrounding SizeProvider, else `"default"`. */
+	size?: SizeVariant;
+}
+/**
+* Toggle switch with animated thumb and label.
+*
+* The whole row — track and label — is the hit target: click anywhere to
+* toggle, or grab the thumb and drag it across the midpoint. The thumb
+* stretches into a pill on hover, squashes on press and melts across the
+* track like a drop when it toggles (see Morph), springing with the motion
+* tokens; a Base UI switch underneath carries the role, keyboard
+* toggling (Space/Enter) and focus ring. The label brightens when the switch
+* is on.
+*
+* Works controlled (`checked` + `onToggle`, exactly as upstream) or
+* uncontrolled (`defaultChecked`, with `onCheckedChange` reporting each
+* change). `size` pins it to one step of the size ladder; otherwise it
+* follows the surrounding SizeProvider.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Switch: ForwardRefExoticComponent_tcubfn9<SwitchProps & RefAttributes_miuf569<HTMLDivElement>>;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent6, HTMLAttributes as HTMLAttributes14, ReactNode as ReactNode14, RefAttributes as RefAttributes6 } from "react";
+type AccordionGroupSingleProps = {
+	/** Whether one or multiple items can be expanded. Defaults to `"single"`. */
+	type?: "single";
+	/** Controlled expanded value. */
+	value?: string;
+	/** Initially expanded item value — uncontrolled. */
+	defaultValue?: string;
+	/** Callback when expanded state changes. */
+	onValueChange?: (value: string) => void;
+	/** Allow collapsing all items when type is single. Defaults to `true`. */
+	collapsible?: boolean;
+};
+type AccordionGroupMultipleProps = {
+	/** Whether one or multiple items can be expanded. */
+	type: "multiple";
+	/** Controlled expanded values. */
+	value?: string[];
+	/** Initially expanded item values — uncontrolled. */
+	defaultValue?: string[];
+	/** Callback when expanded state changes. */
+	onValueChange?: (value: string[]) => void;
+};
+type AccordionGroupProps = HTMLAttributes14<HTMLDivElement> & {
+	children: ReactNode14;
+	/** Pins the group's rows to one step of the size ladder (default 36px,
+	*  compact 28px — see /docs/sizes). Omitted, they follow the surrounding
+	*  SizeProvider. */
+	size?: SizeVariant;
+	/** What an open item tints. "item" paints the row and its panel as one
+	*  block, and holds while it stays open. "trigger" scopes the fill to the
+	*  row and shows it on hover only, leaving the panel on the page's own
+	*  surface — the way a sidebar row highlights without colouring its
+	*  sub-tree. @default "item" */
+	highlight?: "trigger" | "item";
+} & (AccordionGroupSingleProps | AccordionGroupMultipleProps);
+declare const AccordionGroup: ForwardRefExoticComponent6<AccordionGroupProps & RefAttributes6<HTMLDivElement>>;
+interface AccordionProps extends HTMLAttributes14<HTMLDivElement> {
+	/** The accordion's items (`Accordion.Item`). */
+	children: ReactNode14;
+	/** Whether one or multiple items can be expanded. Defaults to `"single"`. */
+	type?: "single" | "multiple";
+	/** Allow collapsing all items when type is single. Defaults to `true` (Base UI's single mode is always collapsible). */
+	collapsible?: boolean;
+	/** Initially expanded item value(s) — uncontrolled. A string for `type="single"`, an array for `type="multiple"`. */
+	defaultValue?: string | string[];
+	/** Controlled expanded value(s). Pair with `onValueChange`. */
+	value?: string | string[];
+	/** Callback when expanded state changes. Receives a string in single mode, an array in multiple mode. */
+	onValueChange?: ((value: string) => void) | ((value: string[]) => void);
+	/** What an open item tints: `item` holds a block across the row and its panel, `trigger` scopes it to the row and shows it on hover. Same prop on `Accordion.Group` and on a standalone `Accordion.Item`. Defaults to `"item"`. */
+	highlight?: "trigger" | "item";
+	/** Pins the accordion's rows to one step of the size ladder (default 36px, compact 28px). Omitted, they follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type AccordionComponent = ForwardRefExoticComponent6<AccordionProps & RefAttributes6<HTMLDivElement>> & {
+	Group: typeof AccordionGroup;
+	Item: typeof AccordionItem;
+	Trigger: typeof AccordionTrigger;
+	Content: typeof AccordionContent;
+};
+/**
+* Collapsible sections with animated expand/collapse and fluid hover in
+* grouped mode.
+*
+* Accordion is the standalone form: every row carries its own hover fill.
+* Accordion.Group takes the same props and adds one magnetic highlight that
+* glides between rows, so give each item inside it an `index`. Built on Base
+* UI Accordion (WAI-ARIA wiring, keyboard navigation, focus management).
+* Uncontrolled through `defaultValue`, controlled through `value` +
+* `onValueChange`.
+*
+* The panel grows out of its row (see Morph): a shape drips from where the
+* row was pressed (its middle, from the keyboard), widens into the whole
+* item, and the content is revealed by a clip from the same shape. Under the
+* default `highlight="item"` that shape is the open tint, melted into the
+* row through a liquid goo neck; closing folds it back into the row. The
+* rows below ride the shape's bottom edge, so nothing jumps.
+*
+* Statics: Accordion.Group (the grouped root: type, collapsible,
+* defaultValue, value, onValueChange, highlight, size), Accordion.Item (value,
+* index, disabled), Accordion.Trigger (the row that toggles its item) and
+* Accordion.Content (the collapsible panel: `effect` — `'goo'` or a plain
+* `'morph'` — and the spring `tier`, `'slow'` or `'moderate'`).
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Accordion: AccordionComponent;
+interface AccordionItemProps extends HTMLAttributes14<HTMLDivElement> {
+	/** Unique identifier for this item. */
+	value: string;
+	/** Position index for fluid hover. Required inside `Accordion.Group`, omit for standalone. */
+	index?: number;
+	/** Whether this item is disabled. Defaults to `false`. */
+	disabled?: boolean;
+	/** Standalone equivalent of the group's prop: what an open item tints. Ignored inside a group, which decides for all its rows. Defaults to the standalone root's `highlight`, else `"item"`. */
+	highlight?: "trigger" | "item";
+	/** The item's `Accordion.Trigger` and `Accordion.Content`. */
+	children: ReactNode14;
+}
+declare const AccordionItem: ForwardRefExoticComponent6<AccordionItemProps & RefAttributes6<HTMLDivElement>>;
+interface AccordionTriggerProps extends HTMLAttributes14<HTMLButtonElement> {
+	/** Trigger label content. */
+	children: ReactNode14;
+}
+declare const AccordionTrigger: ForwardRefExoticComponent6<AccordionTriggerProps & RefAttributes6<HTMLButtonElement>>;
+interface AccordionContentProps extends HTMLAttributes14<HTMLDivElement> {
+	/** Collapsible content. */
+	children: ReactNode14;
+	/** How the panel grows out of its row (see Morph): `goo` melts the open tint out of the row through a liquid neck, `morph` grows it without one. Defaults to `'goo'`. */
+	effect?: "goo" | "morph";
+	/** Spring tier the panel opens on; it closes on the tier's faster exit tween. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+}
+declare const AccordionContent: ForwardRefExoticComponent6<AccordionContentProps & RefAttributes6<HTMLDivElement>>;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent7, HTMLAttributes as HTMLAttributes17, ReactNode as ReactNode16, RefAttributes as RefAttributes7 } from "react";
+import { HTMLAttributes as HTMLAttributes15, MutableRefObject, ReactElement as ReactElement3 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn10 } from "react";
+import { RefAttributes as RefAttributes_miuf5610 } from "react";
+declare const SIDEBAR_COOKIE_NAME = "sidebar_state";
+declare const SIDEBAR_COOKIE_MAX_AGE: number;
+declare const SIDEBAR_WIDTH = "16rem";
+declare const SIDEBAR_WIDTH_MOBILE = "18rem";
+/** Bare-key toggle defaults: "[" for a left sidebar, "]" for a right one.
+*  Bare (no ⌘/Ctrl) so the browser's history shortcuts stay untouched. */
+declare const SIDEBAR_KEYBOARD_SHORTCUT = "[";
+declare const SIDEBAR_KEYBOARD_SHORTCUT_RIGHT = "]";
+/** Drag-resize clamp for the built-in rail handle (px). */
+declare const SIDEBAR_MIN_WIDTH = 160;
+declare const SIDEBAR_MAX_WIDTH = 360;
+type SidebarSide = "left" | "right";
+type SidebarVariant = "sidebar" | "floating" | "inset";
+type SidebarCollapsible = "offcanvas" | "none";
+interface SidebarContextValue {
+	/** What shows: expanded while kept open or open on hover. */
+	state: "expanded" | "collapsed";
+	/** Kept open. */
+	open: boolean;
+	setOpen: (open: boolean | ((prev: boolean) => boolean)) => void;
+	openMobile: boolean;
+	setOpenMobile: React.Dispatch<React.SetStateAction<boolean>>;
+	isMobile: boolean;
+	toggleSidebar: () => void;
+	/** Live rail width — the rail's drag-resize updates it. */
+	width: string;
+	setWidth: (width: string) => void;
+	widthMobile: string;
+	mobileBreakpoint: number;
+	/** Which edge the rendered Sidebar sits on (registered by <Sidebar/>). */
+	side: SidebarSide;
+	/** Internal: <Sidebar/> reports its side so the provider can resolve the
+	*  default shortcut and the rail can mirror. */
+	registerSide: (side: SidebarSide) => void;
+	/** The resolved toggle key ("[" / "]" / custom / null when disabled). */
+	shortcut: string | null;
+	/** The collapsed sidebar opens on hover (see the provider's prop). */
+	openOnHover: boolean;
+	/** True while the collapsed sidebar is open on hover. */
+	hoverOpen: boolean;
+	setHoverOpen: React.Dispatch<React.SetStateAction<boolean>>;
+	/** Internal: the shell and the triggers register their nodes; the hover
+	*  zone is measured off them. */
+	shellRef: MutableRefObject<HTMLElement | null>;
+	registerTrigger: (node: HTMLElement) => () => void;
+	/** Internal: true while the rail is being drag-resized (disables the
+	*  width spring so the panel tracks the pointer 1:1). */
+	isResizing: boolean;
+	setIsResizing: React.Dispatch<React.SetStateAction<boolean>>;
+}
+declare function useSidebar(): SidebarContextValue;
+interface SidebarProviderProps extends HTMLAttributes15<HTMLDivElement> {
+	defaultOpen?: boolean;
+	open?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	/** Persist the desktop open state to the `sidebar_state` cookie so a server
+	*  layout can read it back into `defaultOpen`. Mobile state never persists. */
+	persist?: boolean;
+	/** Bare-key toggle shortcut. Defaults to "[" for a left sidebar and "]"
+	*  for a right one; `null` disables it. */
+	shortcut?: string | null;
+	/** Viewport width (px) below which the sidebar renders as a drawer. */
+	mobileBreakpoint?: number;
+	/** While collapsed, open the sidebar when the pointer reaches its edge or
+	*  the trigger beside it, and close it a beat after the pointer leaves.
+	*  `open` then says whether it is kept open, and the trigger switches
+	*  between the two. Hovering never writes the cookie. @default false */
+	openOnHover?: boolean;
+	width?: string;
+	widthMobile?: string;
+}
+declare const SidebarProvider: ForwardRefExoticComponent_tcubfn10<SidebarProviderProps & RefAttributes_miuf5610<HTMLDivElement>>;
+type SidebarTriggerProps = ButtonProps;
+/** Ghost icon button calling toggleSidebar(). The icon mirrors the
+*  sidebar's side, and its tooltip names the action with the toggle
+*  keystroke by default. With `openOnHover` it switches between open and on
+*  hover (a dashed glyph), and the hover zone reaches its far side when it
+*  sits beside the sidebar's edge. */
+declare const SidebarTrigger: ForwardRefExoticComponent_tcubfn10<ButtonProps & RefAttributes_miuf5610<HTMLButtonElement>>;
+interface SidebarRailProps extends HTMLAttributes15<HTMLButtonElement> {
+	/** Pin the tooltip open/closed; `undefined` leaves it on hover. */
+	tooltipOpen?: boolean;
+}
+/** The grab strip on the sidebar's inner edge, rendered by default inside
+*  the desktop shell: drag it to resize (clamped), click it to collapse, and
+*  its tooltip explains both with the toggle keystroke. Hovering it
+*  brightens the edge border. */
+declare const SidebarRail: ForwardRefExoticComponent_tcubfn10<SidebarRailProps & RefAttributes_miuf5610<HTMLButtonElement>>;
+type SidebarInsetProps = HTMLAttributes15<HTMLElement>;
+declare const SidebarInset: ForwardRefExoticComponent_tcubfn10<SidebarInsetProps & RefAttributes_miuf5610<HTMLElement>>;
+type SidebarInputProps = React.InputHTMLAttributes<HTMLInputElement>;
+declare const SidebarInput: ForwardRefExoticComponent_tcubfn10<SidebarInputProps & RefAttributes_miuf5610<HTMLInputElement>>;
+type SidebarSectionProps = HTMLAttributes15<HTMLDivElement>;
+declare const SidebarHeader: ForwardRefExoticComponent_tcubfn10<SidebarSectionProps & RefAttributes_miuf5610<HTMLDivElement>>;
+declare const SidebarFooter: ForwardRefExoticComponent_tcubfn10<SidebarSectionProps & RefAttributes_miuf5610<HTMLDivElement>>;
+declare const SidebarSeparator: ForwardRefExoticComponent_tcubfn10<SidebarSectionProps & RefAttributes_miuf5610<HTMLDivElement>>;
+interface SidebarGroupProps extends SidebarSectionProps {
+	/** Makes the group's SidebarGroupLabel a toggle that collapses everything
+	*  rendered after it — a group-level accordion. Uncontrolled by default;
+	*  pass `open`/`onOpenChange` to control it. */
+	collapsible?: boolean;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+}
+declare const SidebarGroup: ForwardRefExoticComponent_tcubfn10<SidebarGroupProps & RefAttributes_miuf5610<HTMLDivElement>>;
+interface SidebarGroupLabelProps extends HTMLAttributes15<HTMLDivElement> {
+	render?: ReactElement3;
+	asChild?: boolean;
+}
+declare const SidebarGroupLabel: ForwardRefExoticComponent_tcubfn10<SidebarGroupLabelProps & RefAttributes_miuf5610<HTMLDivElement>>;
+interface SidebarGroupActionProps extends HTMLAttributes15<HTMLButtonElement> {
+	render?: ReactElement3;
+	asChild?: boolean;
+}
+declare const SidebarGroupAction: ForwardRefExoticComponent_tcubfn10<SidebarGroupActionProps & RefAttributes_miuf5610<HTMLButtonElement>>;
+/** Header action cluster: 1–3 SidebarGroupActions laid out in a row over the
+*  group label's right edge. Use instead of a lone SidebarGroupAction when a
+*  section needs several controls. */
+type SidebarGroupActionsProps = HTMLAttributes15<HTMLDivElement>;
+declare const SidebarGroupActions: ForwardRefExoticComponent_tcubfn10<SidebarGroupActionsProps & RefAttributes_miuf5610<HTMLDivElement>>;
+declare const SidebarGroupContent: ForwardRefExoticComponent_tcubfn10<SidebarSectionProps & RefAttributes_miuf5610<HTMLDivElement>>;
+import { VariantProps as VariantProps5 } from "class-variance-authority";
+import { AnchorHTMLAttributes, ButtonHTMLAttributes as ButtonHTMLAttributes3, HTMLAttributes as HTMLAttributes16, LiHTMLAttributes, ReactElement as ReactElement4 } from "react";
+import { Context as Context_rri5bl2 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn11 } from "react";
+import { RefAttributes as RefAttributes_miuf5611 } from "react";
+import { ClassProp as ClassProp_wz9o0r5 } from "class-variance-authority/types";
+/** The selection a `Sidebar` holds for buttons that carry a `value`. */
+interface SidebarSelectionValue {
+	value: string | undefined;
+	select: (value: string) => void;
+}
+declare const SidebarSelection: Context_rri5bl2<SidebarSelectionValue | null>;
+interface SidebarMenuProps extends HTMLAttributes16<HTMLUListElement> {
+	/** Pins the menu's rows to one step of the size ladder. Omitted, they
+	*  follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Draw the traveling keyboard focus ring. Off, keyboard focus moves the
+	*  hover background only. @default true */
+	focusRing?: boolean;
+}
+declare const SidebarMenu: ForwardRefExoticComponent_tcubfn11<SidebarMenuProps & RefAttributes_miuf5611<HTMLUListElement>>;
+interface SidebarMenuItemProps extends LiHTMLAttributes<HTMLLIElement> {
+	/** The row folds a `SidebarMenuSub` under it: its button toggles the sub-menu and shows a chevron. */
+	collapsible?: boolean;
+	/** Controlled open state of a collapsible row's sub-menu. */
+	open?: boolean;
+	/** Initial open state of a collapsible row's sub-menu. */
+	defaultOpen?: boolean;
+	/** Called when a collapsible row opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+}
+declare const SidebarMenuItem: ForwardRefExoticComponent_tcubfn11<SidebarMenuItemProps & RefAttributes_miuf5611<HTMLLIElement>>;
+type SidebarMenuSubItemProps = LiHTMLAttributes<HTMLLIElement>;
+declare const SidebarMenuSubItem: ForwardRefExoticComponent_tcubfn11<SidebarMenuSubItemProps & RefAttributes_miuf5611<HTMLLIElement>>;
+declare const sidebarMenuButtonVariants: (props?: ({
+	variant?: "default" | "outline" | null | undefined;
+} & ClassProp_wz9o0r5) | undefined) => string;
+interface SidebarMenuButtonProps extends ButtonHTMLAttributes3<HTMLButtonElement>, VariantProps5<typeof sidebarMenuButtonVariants> {
+	isActive?: boolean;
+	size?: "default" | "sm" | "lg";
+	icon?: IconComponent;
+	/** Semantic thread state for status-dot navigation. Drives the dot
+	*  visuals (`active`/`unread` → filled, `idle` → ring), stamps
+	*  `data-status` on the button, appends visually-hidden "unread" text for
+	*  screen readers, and `"active"` implies `isActive`. */
+	status?: "active" | "unread" | "idle";
+	/** Visual-only dot in the icon column — the escape hatch when the
+	*  semantic `status` vocabulary doesn't fit. Overrides the dot derived
+	*  from `status`. Ignored when `icon` is set. */
+	dot?: "filled" | "ring";
+	/** Selection key: the row is active while the surrounding `Sidebar`'s
+	*  `value` matches it, and pressing it selects it. With a `value`,
+	*  `status="active"` no longer implies the active row. */
+	value?: string;
+	render?: ReactElement4;
+	asChild?: boolean;
+}
+declare const SidebarMenuButton: ForwardRefExoticComponent_tcubfn11<SidebarMenuButtonProps & RefAttributes_miuf5611<HTMLButtonElement>>;
+interface SidebarMenuActionProps extends ButtonHTMLAttributes3<HTMLButtonElement> {
+	showOnHover?: boolean;
+	render?: ReactElement4;
+	asChild?: boolean;
+}
+declare const SidebarMenuAction: ForwardRefExoticComponent_tcubfn11<SidebarMenuActionProps & RefAttributes_miuf5611<HTMLButtonElement>>;
+interface SidebarMenuActionsProps extends HTMLAttributes16<HTMLDivElement> {
+	/** Hide the cluster until the row is hovered or focused. */
+	showOnHover?: boolean;
+}
+/** Row-level cluster for more than one SidebarMenuAction. It owns the
+*  positioning and publishes the whole count to the row, so the button
+*  reserves the exact gutter the cluster occupies. */
+declare const SidebarMenuActions: ForwardRefExoticComponent_tcubfn11<SidebarMenuActionsProps & RefAttributes_miuf5611<HTMLDivElement>>;
+type SidebarMenuBadgeProps = HTMLAttributes16<HTMLDivElement>;
+declare const SidebarMenuBadge: ForwardRefExoticComponent_tcubfn11<SidebarMenuBadgeProps & RefAttributes_miuf5611<HTMLDivElement>>;
+interface SidebarMenuSkeletonProps extends HTMLAttributes16<HTMLDivElement> {
+	showIcon?: boolean;
+}
+declare const SidebarMenuSkeleton: ForwardRefExoticComponent_tcubfn11<SidebarMenuSkeletonProps & RefAttributes_miuf5611<HTMLDivElement>>;
+interface SidebarMenuSubProps extends HTMLAttributes16<HTMLUListElement> {
+	/** Built-in measured-height collapse. Omitted, the sub-menu follows its
+	*  `collapsible` row's state, or stays visible without one. */
+	open?: boolean;
+}
+declare const SidebarMenuSub: ForwardRefExoticComponent_tcubfn11<SidebarMenuSubProps & RefAttributes_miuf5611<HTMLUListElement>>;
+interface SidebarMenuSubButtonProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+	isActive?: boolean;
+	size?: "sm" | "md";
+	icon?: IconComponent;
+	/** Selection key, as on `SidebarMenuButton`. Without an `href` the row renders a button. */
+	value?: string;
+	render?: ReactElement4;
+	asChild?: boolean;
+}
+declare const SidebarMenuSubButton: ForwardRefExoticComponent_tcubfn11<SidebarMenuSubButtonProps & RefAttributes_miuf5611<HTMLAnchorElement>>;
+interface SidebarProps extends Omit<HTMLAttributes17<HTMLDivElement>, "defaultValue" | "onDrag" | "onDragStart" | "onDragEnd" | "onAnimationStart" | "onAnimationEnd" | "onAnimationIteration"> {
+	/** The edge it sits on; the shortcut key and the rail mirror it. Defaults to `'left'`. */
+	side?: "left" | "right";
+	/** `'sidebar'` sits flush with an inner border, `'floating'` lifts it onto its own card one surface level up, `'inset'` makes the main region the card. Defaults to `'sidebar'`. */
+	variant?: "sidebar" | "floating" | "inset";
+	/** `'offcanvas'` collapses it away (rail, trigger, shortcut, open on hover, mobile drawer); `'none'` pins it open, with no rail or drawer — for a sidebar inside a dialog. Defaults to `'offcanvas'`. */
+	collapsible?: "offcanvas" | "none";
+	/** The `sidebar` variant's inner-edge border. Defaults to `true`. */
+	bordered?: boolean;
+	/** Render the built-in resize/collapse rail on the inner edge. Defaults to `true`. */
+	rail?: boolean;
+	/** Pin the rail's tooltip open (`true`) or closed (`false`); left out, it shows on hover. Dragging always hides it. */
+	railTooltipOpen?: boolean;
+	/** Controlled selection: the menu button or sub-button whose `value` matches is the active row. */
+	value?: string;
+	/** Initial selection, for an uncontrolled sidebar. */
+	defaultValue?: string;
+	/** Called with the `value` of the row that was pressed. */
+	onValueChange?: (value: string) => void;
+	/** Extra classes for the sidebar column (`h-full` pins it to a bounded frame). */
+	className?: string;
+	/** The sidebar's parts: `Sidebar.Header`, `Sidebar.Content`, `Sidebar.Footer`. */
+	children?: ReactNode16;
+}
+type SidebarComponent = ForwardRefExoticComponent7<SidebarProps & RefAttributes7<HTMLDivElement>> & {
+	Provider: typeof SidebarProvider;
+	Trigger: typeof SidebarTrigger;
+	Rail: typeof SidebarRail;
+	Inset: typeof SidebarInset;
+	Input: typeof SidebarInput;
+	Header: typeof SidebarHeader;
+	Content: typeof SidebarContent;
+	Footer: typeof SidebarFooter;
+	Separator: typeof SidebarSeparator;
+	Group: typeof SidebarGroup;
+	GroupLabel: typeof SidebarGroupLabel;
+	GroupAction: typeof SidebarGroupAction;
+	GroupActions: typeof SidebarGroupActions;
+	GroupContent: typeof SidebarGroupContent;
+	Menu: typeof SidebarMenu;
+	MenuItem: typeof SidebarMenuItem;
+	MenuButton: typeof SidebarMenuButton;
+	MenuAction: typeof SidebarMenuAction;
+	MenuActions: typeof SidebarMenuActions;
+	MenuBadge: typeof SidebarMenuBadge;
+	MenuSkeleton: typeof SidebarMenuSkeleton;
+	MenuSub: typeof SidebarMenuSub;
+	MenuSubItem: typeof SidebarMenuSubItem;
+	MenuSubButton: typeof SidebarMenuSubButton;
+};
+/**
+* A sidebar built from composable parts. Drag its edge to resize, collapse it
+* away, and on mobile it becomes a drawer.
+*
+* Everything that moves here moves in the morph style (see Morph). The
+* active row and the hover highlight are liquid: a new selection melts
+* across from the old one, and the highlight drips from row to row, into a
+* row's sub-menu too. On mobile it is a `Sheet` growing out of its edge
+* that you swipe away. The menus in the header, the footer and on each row
+* are Dropdowns, and the tooltips are Tooltips, so they grow out of their
+* triggers too.
+*
+* Wrap the page in `Sidebar.Provider`, then put the `Sidebar` and a
+* `Sidebar.Inset` (the main region) inside it. The provider holds the open
+* state (`open` / `defaultOpen` / `onOpenChange`, kept in the `sidebar_state`
+* cookie unless `persist={false}`), the `width` and `widthMobile`, the
+* `mobileBreakpoint` under which it becomes a drawer, `openOnHover` (below)
+* and the bare `shortcut` key (`[` for a left sidebar,
+* `]` for a right one; `null` turns it off). It fills the viewport; pass
+* `className="h-full min-h-0"` to fill a bounded frame instead.
+*
+* Drag the rail on the inner edge to resize the sidebar (160–360px); throw
+* it at the edge to collapse, or click it. There is no icon-only rail on
+* purpose: a collapsed sidebar opens whole on hover instead.
+*
+* With `openOnHover`, collapsing leaves the sidebar on hover: it opens, in
+* flow, while the pointer is between its edge and the far side of a
+* `Sidebar.Trigger` beside it (or a thin strip at the edge), and closes a
+* beat after the pointer leaves. `open` is then whether it is kept open: the
+* trigger switches between the two and draws a dashed glyph while on hover,
+* and the rail collapses or resizes the hover without keeping it open.
+*
+* ## Rows
+*
+* - Two levels: `Sidebar.MenuButton` rows, each folding a
+*   `Sidebar.MenuSub` of `Sidebar.MenuSubButton` rows. A
+*   `Sidebar.MenuItem collapsible` toggles its sub-menu from its own button
+*   and draws the chevron.
+* - Give a button a `value` and the sidebar's `value` / `defaultValue` picks
+*   the active row; pressing a row selects it. `isActive` still forces a row
+*   active.
+* - `icon` puts a glyph in the leading slot; `status` (`'active'`,
+*   `'unread'`, `'idle'`) a thread's dot instead.
+* - `Sidebar.MenuBadge` keeps the rightmost slot; up to three
+*   `Sidebar.MenuAction`s (in a `Sidebar.MenuActions` cluster) sit beside
+*   it, `showOnHover` so the label keeps the room at rest.
+* - The rows share one fluid hover, one keyboard roving focus (arrows,
+*   Home, End) and one focus ring across both levels.
+*
+* ## Sections
+*
+* `Sidebar.Group` with a `Sidebar.GroupLabel` is a section; `collapsible`
+* makes the label fold everything under it. `Sidebar.GroupActions` holds
+* its `Sidebar.GroupAction` buttons over the label's right edge.
+*
+* Statics:
+* - `Sidebar.Provider`, `Sidebar.Inset`, `Sidebar.Trigger` (the ghost icon
+*   button with the shortcut in its tooltip), `Sidebar.Rail`.
+* - `Sidebar.Header`, `Sidebar.Content` (the scrolling region),
+*   `Sidebar.Footer`, `Sidebar.Separator`, `Sidebar.Input`.
+* - `Sidebar.Group`, `Sidebar.GroupLabel`, `Sidebar.GroupAction`,
+*   `Sidebar.GroupActions`, `Sidebar.GroupContent`.
+* - `Sidebar.Menu`, `Sidebar.MenuItem`, `Sidebar.MenuButton`,
+*   `Sidebar.MenuAction`, `Sidebar.MenuActions`, `Sidebar.MenuBadge`,
+*   `Sidebar.MenuSkeleton`, `Sidebar.MenuSub`, `Sidebar.MenuSubItem`,
+*   `Sidebar.MenuSubButton`.
+* - `useSidebar()` (named export) reads the provider's state.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Sidebar: SidebarComponent;
+interface SidebarContentProps extends HTMLAttributes17<HTMLDivElement> {
+	viewportClassName?: string;
+}
+declare const SidebarContent: ForwardRefExoticComponent7<SidebarContentProps & RefAttributes7<HTMLDivElement>>;
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { ComponentPropsWithoutRef, ForwardRefExoticComponent as ForwardRefExoticComponent8, ReactNode as ReactNode17, RefAttributes as RefAttributes8 } from "react";
+import { TabsListProps as TabsListProps_6iqhkk } from "@base-ui/react";
+interface TabsProps extends Omit<ComponentPropsWithoutRef<typeof TabsPrimitive.Root>, "onValueChange" | "value" | "defaultValue" | "onSelect"> {
+	/** Controlled active tab value. Takes precedence over selectedIndex. */
+	value?: string;
+	/** Called when the active tab changes. */
+	onValueChange?: (value: string) => void;
+	/** Index-based controlled alternative. */
+	selectedIndex?: number;
+	/** Called with the new index when the active tab changes. */
+	onSelect?: (index: number) => void;
+	/** Default active tab for uncontrolled usage. Defaults to the first tab. */
+	defaultValue?: string;
+	/** Index-based uncontrolled alternative: the tab active on first render. Ignored when `defaultValue` is set. */
+	defaultSelectedIndex?: number;
+	/** Pins the segmented control to one step of the size ladder (default 36px outer, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Tabs.List and Tabs.Panel children. */
+	children?: ReactNode17;
+}
+type TabsComponent = ForwardRefExoticComponent8<TabsProps & RefAttributes8<HTMLDivElement>> & {
+	List: typeof TabsList;
+	Item: typeof TabItem;
+	Panel: typeof TabPanel;
+};
+/**
+* Segmented control tabs with sliding active indicator, fluid hover, and
+* spring animations.
+*
+* Built on Base UI Tabs: `Tabs` owns the selection, `Tabs.List` draws the
+* segmented track with an elevated indicator that melts toward the active tab
+* like a drop (lifted three surface levels above whatever it sits on; see the
+* liquid indicators in Morph) and a translucent hover pill that drips out of
+* it, and `Tabs.Panel` shows the content of the active tab. Arrow keys
+* move and activate. Select by value — `defaultValue` uncontrolled, `value` +
+* `onValueChange` controlled — or by index with `defaultSelectedIndex` /
+* `selectedIndex` + `onSelect`.
+*
+* Statics:
+* - `Tabs.List` — the segmented track holding the tabs.
+* - `Tabs.Item` — one tab: `value`, `label`, optional `icon`.
+* - `Tabs.Panel` — content shown while the tab with the same `value` is active.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Tabs: TabsComponent;
+type TabsListProps = ComponentPropsWithoutRef<typeof TabsPrimitive.List>;
+declare const TabsList: ForwardRefExoticComponent8<Omit<Omit<TabsListProps_6iqhkk, "ref"> & RefAttributes8<HTMLDivElement>, "ref"> & RefAttributes8<HTMLDivElement>>;
+interface TabItemProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.Tab> {
+	value: string;
+	icon?: IconComponent;
+	label: string;
+	/** @internal Auto-assigned by TabsList. */
+	_index?: number;
+}
+declare const TabItem: ForwardRefExoticComponent8<TabItemProps & RefAttributes8<HTMLButtonElement>>;
+interface TabPanelProps extends ComponentPropsWithoutRef<typeof TabsPrimitive.Panel> {
+	value: string;
+}
+declare const TabPanel: ForwardRefExoticComponent8<TabPanelProps & RefAttributes8<HTMLDivElement>>;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent9, HTMLAttributes as HTMLAttributes18, ReactNode as ReactNode18, RefAttributes as RefAttributes9 } from "react";
+interface TabsSubtleProps extends Omit<HTMLAttributes18<HTMLDivElement>, "onSelect"> {
+	/** TabsSubtle.Item children, and optionally the TabsSubtle.Panel children they select. */
+	children: ReactNode18;
+	/** Index of the currently selected tab. Controlled — pair it with `onSelect`. */
+	selectedIndex?: number;
+	/** Selected tab on first render when uncontrolled. Defaults to `0`. */
+	defaultSelectedIndex?: number;
+	/** Called when a tab is selected. */
+	onSelect?: (index: number) => void;
+	/** Prefix for ARIA IDs linking tabs to panels. Defaults to a generated one when panels are nested inside. */
+	idPrefix?: string;
+	/** When true, only the selected tab shows its text label. Requires icons on tabs. Defaults to `false`. */
+	activeLabel?: boolean;
+	/** Pins the tabs to one step of the size ladder (default 36px, compact 28px). Defaults to the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type TabsSubtleComponent = ForwardRefExoticComponent9<TabsSubtleProps & RefAttributes9<HTMLDivElement>> & {
+	Item: typeof TabsSubtleItem;
+	Panel: typeof TabsSubtlePanel;
+};
+/**
+* Tab navigation with smooth pill animations.
+*
+* A borderless tab strip: the selected pill melts from tab to tab like a drop
+* (the liquid indicators in Morph), a lighter hover pill previews the next one, and the active label animates to semibold
+* without shifting. With `activeLabel`, tabs collapse to their icon and the
+* selected one expands its label to a measured width. Base UI owns
+* `role="tablist"`, the roving tabindex and Arrow/Home/End navigation
+* (manual activation — arrows move, Enter or Space selects). Uncontrolled with
+* `defaultSelectedIndex`, or controlled with `selectedIndex` + `onSelect`.
+*
+* The root element is the tab list itself, so nested `TabsSubtle.Panel`
+* children are lifted out and rendered as its siblings, wired to the tabs
+* through a generated id prefix; panels rendered outside still take
+* `selectedIndex` and `idPrefix` as props.
+*
+* Statics:
+* - `TabsSubtle.Item` — one tab: `index`, `label`, optional `icon`.
+* - `TabsSubtle.Panel` — content for the tab with the same `index`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const TabsSubtle: TabsSubtleComponent;
+interface TabsSubtleItemProps extends HTMLAttributes18<HTMLButtonElement> {
+	/** Icon displayed in the tab. */
+	icon?: IconComponent;
+	/** Text label for the tab. */
+	label: string;
+	/** Position index within the tab list. */
+	index: number;
+}
+declare const TabsSubtleItem: ForwardRefExoticComponent9<TabsSubtleItemProps & RefAttributes9<HTMLButtonElement>>;
+interface TabsSubtlePanelProps extends HTMLAttributes18<HTMLDivElement> {
+	/** Index of this panel; rendered only when it matches the selected tab. */
+	index: number;
+	/** Currently selected tab index. Defaults to the enclosing TabsSubtle's selection. */
+	selectedIndex?: number;
+	/** Must match the TabsSubtle idPrefix. Defaults to the enclosing TabsSubtle's prefix. */
+	idPrefix?: string;
+	/** Panel content, only rendered when selected. */
+	children: ReactNode18;
+}
+declare const TabsSubtlePanel: ForwardRefExoticComponent9<TabsSubtlePanelProps & RefAttributes9<HTMLDivElement>>;
+import { HTMLAttributes as HTMLAttributes19, ReactNode as ReactNode19, RefObject as RefObject11 } from "react";
+/** What opened the overlay: the pressed trigger and the press point. */
+interface MorphOrigin {
+	trigger?: HTMLElement;
+	point?: {
+		x: number;
+		y: number;
+	};
+}
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn12 } from "react";
+import { RefAttributes as RefAttributes_miuf5612 } from "react";
+import { JSX as JSX_1kxb16 } from "react";
+type DialogSlotProps = SlotProps;
+/** The open state and origin `DialogState` provides, for content built on another Base UI popup (Sheet). */
+declare const useDialogState: () => {
+	open: boolean;
+	origin: RefObject11<MorphOrigin>;
+};
+declare const DialogTrigger: ForwardRefExoticComponent_tcubfn12<SlotProps & RefAttributes_miuf5612<HTMLButtonElement>>;
+declare const DialogClose: ForwardRefExoticComponent_tcubfn12<SlotProps & RefAttributes_miuf5612<HTMLButtonElement>>;
+interface DialogContentProps extends HTMLAttributes19<HTMLDivElement> {
+	/** Width: 400, 540, or 880. Compact regions narrow each by 1 notch: 360,
+	*  480, 800. `xl` is the canvas for composed layouts — a sidebar beside a
+	*  panel — which usually pair it with `className="p-0"` and a fixed
+	*  height. Defaults to `"sm"`. */
+	size?: "sm" | "lg" | "xl";
+	/** Portal target. When set, the overlay and panel render inside this element
+	*  (positioned `absolute`) instead of covering the viewport (`fixed`). Pair
+	*  with a `position: relative; overflow: hidden` container — and usually
+	*  `<Dialog modal={false}>` — to scope a dialog to a bounded region, e.g. a
+	*  docs preview. Defaults to the document body / full-viewport behaviour. */
+	container?: HTMLElement | null;
+	/** The ✕ in the top-right corner. Drop it when the content has its own
+	*  way out, e.g. a command menu that closes on Escape and on a pick.
+	*  Defaults to `true`. */
+	showCloseButton?: boolean;
+	/** Where the panel sits: centered, or anchored 12dvh from the top so a
+	*  panel whose height follows its content (a command menu) keeps its top
+	*  edge still. Defaults to `"center"`. */
+	position?: "center" | "top";
+	/** Where the panel grows from (see Morph): the pressed trigger (its center when none), the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject11<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+	/** Dialog content. Everything inside reads the dialog's surface level as its substrate. */
+	children?: ReactNode19;
+}
+declare const DialogContent: ForwardRefExoticComponent_tcubfn12<DialogContentProps & RefAttributes_miuf5612<HTMLDivElement>>;
+type Element_12xgc16 = JSX_1kxb16["Element"];
+declare function DialogHeader({ className,...props }: HTMLAttributes19<HTMLDivElement>): Element_12xgc16;
+declare function DialogFooter({ className,...props }: HTMLAttributes19<HTMLDivElement>): Element_12xgc16;
+declare const DialogTitle: ForwardRefExoticComponent_tcubfn12<HTMLAttributes19<HTMLHeadingElement> & RefAttributes_miuf5612<HTMLHeadingElement>>;
+declare const DialogDescription: ForwardRefExoticComponent_tcubfn12<HTMLAttributes19<HTMLParagraphElement> & RefAttributes_miuf5612<HTMLParagraphElement>>;
+interface DialogStateProps {
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	children: (root: {
+		open: boolean;
+		onOpenChange: (next: boolean, details: {
+			trigger?: Element;
+			event?: Event;
+		}) => void;
+	}) => ReactNode19;
+}
+/**
+* A dialog's open state, held here (not in Base UI's Root) because the morph
+* reads it, and the open event tells it which trigger was pressed. Also
+* scopes `Morph.Part` pairs. AlertDialog shares it.
+*/
+declare function DialogState({ open, defaultOpen, onOpenChange, children }: DialogStateProps): Element_12xgc16;
+interface DialogProps {
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled dialog. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the dialog opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Traps focus and locks page scroll while open. Defaults to `true`. */
+	modal?: boolean;
+	/** The trigger and the content — `Dialog.Trigger` plus a `Dialog.Content`. */
+	children?: ReactNode19;
+}
+/**
+* 3 widths, grown out of whatever opened them.
+*
+* The panel lifts 4 surface levels off whatever substrate it opens on and
+* re-provides that level, so a dropdown or select inside it keeps climbing
+* the ladder instead of melting into the dialog. Width comes from
+* `Dialog.Content`'s `size` — 400, 540 or 880, each one notch narrower in
+* compact regions. The panel grows out of its trigger through the shared
+* morph (see Morph): goo by default on `spring.goo`, or from the press
+* point, its own center, a viewport edge or any element, and the backdrop
+* fades with it. `Morph.Part` pairs an element in the trigger with its twin
+* in the panel, so a card's image or title flies into the dialog.
+* `position="top"` anchors the panel 12dvh down so a content-sized panel (a
+* command menu) keeps its top edge still. Built on Base UI's Dialog: open
+* state is controlled with `open` / `onOpenChange` or left to `defaultOpen`.
+*
+* Statics:
+* - `Dialog.Trigger` — the control that opens it. `render={<Button/>}` or
+*   Radix-style `asChild` with a single child both work.
+* - `Dialog.Content` — the panel: `size`, `position`, `showCloseButton`,
+*   `container`, and the morph options `from`, `effect`, `hideSource`,
+*   `tier`.
+* - `Dialog.Header` / `Dialog.Footer` — the stacked title block, and the
+*   right-aligned action row.
+* - `Dialog.Title` / `Dialog.Description` — the labelled heading and its
+*   supporting line, wired to the panel for screen readers.
+* - `Dialog.Close` — dismisses it; same `render` / `asChild` shape as the
+*   trigger. `Dialog.Content` renders its own ✕ unless
+*   `showCloseButton={false}`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Dialog({ children, open, defaultOpen, onOpenChange, modal }: DialogProps): Element_12xgc16;
+import { ReactNode as ReactNode20 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn13 } from "react";
+import { RefAttributes as RefAttributes_miuf5613 } from "react";
+import { JSX as JSX_1kxb17 } from "react";
+declare const AlertDialogContent: ForwardRefExoticComponent_tcubfn13<DialogContentProps & RefAttributes_miuf5613<HTMLDivElement>>;
+interface AlertDialogProps {
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled alert dialog. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the dialog opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** The trigger and the content — `AlertDialog.Trigger` plus an `AlertDialog.Content`. */
+	children?: ReactNode20;
+}
+type Element_12xgc17 = JSX_1kxb17["Element"];
+/**
+* A dialog that asks before something happens and waits for an answer.
+*
+* It is always modal, and a press outside does not close it: only its own
+* actions (and Escape) do, so a destructive step is never confirmed or
+* skipped by accident. Screen readers announce it as an alert. Everything
+* else is Dialog's: the panel grows out of its trigger with the goo neck by
+* default (see Morph), takes the same `size`, `position` and morph options,
+* and lifts 4 surface levels. Unlike Dialog it has no ✕ unless
+* `showCloseButton` asks for one.
+*
+* Statics: the same parts as Dialog — `AlertDialog.Trigger`,
+* `AlertDialog.Content`, `AlertDialog.Header`, `AlertDialog.Footer`,
+* `AlertDialog.Title`, `AlertDialog.Description` and `AlertDialog.Close`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function AlertDialog({ children, open, defaultOpen, onOpenChange }: AlertDialogProps): Element_12xgc17;
+import { ReactNode as ReactNode22, RefObject as RefObject12 } from "react";
+import { HTMLAttributes as HTMLAttributes20, ReactElement as ReactElement5, ReactNode as ReactNode21 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn14 } from "react";
+import { RefAttributes as RefAttributes_miuf5614 } from "react";
+/** What MenuItem hands to the popup's primitive wrapper. `element` is the
+*  styled row div (visuals + fluid hover registration, no children); `children`
+*  is the row content (icon, label, check). The dropdown wraps them in its
+*  own Item / RadioItem primitive, so MenuItem itself stays primitive-free. */
+interface MenuItemRenderOptions {
+	/** Radio-style option (boolean `checked` on MenuItem) vs plain action item. */
+	radio: boolean;
+	/** Checkbox-style option: a boolean `checked` inside a multiple-selection
+	*  dropdown (`checkedIndices`). Takes precedence over `radio`. */
+	checkbox: boolean;
+	/** The item's checked state (radio and checkbox items). */
+	checked?: boolean;
+	/** The item's index — doubles as the radio value. */
+	value: number;
+	disabled?: boolean;
+	label: string;
+	closeOnClick: boolean;
+	/** The row's activation. It goes on the primitive, not on `element`: Base
+	*  UI's Enter/Space activation calls the primitive's own `onClick` prop and
+	*  never sees a handler on the render element. */
+	onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+	element: ReactElement5;
+	children: ReactNode21;
+}
+interface DropdownContextValue {
+	registerItem: (index: number, element: HTMLElement | null) => void;
+	activeIndex: number | null;
+	checkedIndex?: number;
+	/** Multiple selection (`checkedIndices` on the dropdown): rows are
+	*  checkbox items and activating one keeps the menu open by default. */
+	multiple?: boolean;
+	checkedIndices?: number[];
+	/** True when items render inside a Menu popup (DropdownContent), where the
+	*  primitive's Item / RadioItem own roles, roving highlight, typeahead,
+	*  and activation. MenuItem switches its rendering accordingly. */
+	inMenu?: boolean;
+	/** Popup-only: wraps a MenuItem's styled div in the dropdown's menu-item
+	*  primitive. Absent in the inline Dropdown panel, where MenuItem renders
+	*  its own ARIA menuitem div. */
+	renderMenuItem?: (opts: MenuItemRenderOptions) => ReactElement5;
+	/** Local addition. The panel owns its selection (`defaultCheckedIndex` /
+	*  `defaultCheckedIndices`), so a row with no `checked` prop takes its
+	*  checked state from `checkedIndex` / `checkedIndices` and toggles the
+	*  panel on activation. */
+	selfManaged?: boolean;
+	/** Local addition. Toggles the row at an AUTHORED index (see
+	*  `sourceIndex`). Present with `selfManaged`. */
+	toggleIndex?: (sourceIndex: number) => void;
+}
+declare function useDropdown(): DropdownContextValue;
+/** Null-safe context read for callers that render outside a provider. */
+declare function useDropdownMaybe(): DropdownContextValue | null;
+interface MenuItemProps extends HTMLAttributes20<HTMLDivElement> {
+	/** Optional leading icon. When omitted, the row renders text-only with no
+	*  reserved icon column. */
+	icon?: IconComponent;
+	label: string;
+	index: number;
+	/** When a boolean, the item is a radio-style option (role="menuitemradio"
+	*  with aria-checked). When undefined, it is a plain action item
+	*  (role="menuitem"), unless the panel owns the selection — then the row
+	*  reads its checked state off the panel and toggles it on activation. */
+	checked?: boolean;
+	onSelect?: () => void;
+	disabled?: boolean;
+	/** Popup-only (inside DropdownContent): whether activating the item closes
+	*  the menu. Ignored in the inline Dropdown panel. @default true */
+	closeOnClick?: boolean;
+	/** Internal: the row's authored index, stamped by a filtering panel that
+	*  re-indexed the visible rows. Selection is keyed on it. */
+	sourceIndex?: number;
+}
+declare const MenuItem2: ForwardRefExoticComponent_tcubfn14<MenuItemProps & RefAttributes_miuf5614<HTMLDivElement>>;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn15 } from "react";
+import { RefAttributes as RefAttributes_miuf5615 } from "react";
+import { JSX as JSX_1kxb18 } from "react";
+interface ContextMenuItemProps extends MenuItemProps {
+	/** Keyboard shortcut shown at the row's end, e.g. `⌘C`. */
+	shortcut?: string;
+}
+declare const ContextMenuItem: ForwardRefExoticComponent_tcubfn15<ContextMenuItemProps & RefAttributes_miuf5615<HTMLDivElement>>;
+interface ContextMenuContentProps {
+	/** Where the menu grows from (see Morph): the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'pointer'`. */
+	from?: "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject12<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the `from` element while open, so it reads as turning into the menu. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+	/** Portal target. Defaults to the document body. */
+	container?: HTMLElement | null;
+	/** Extra classes for the menu surface — it is 14rem wide by default. */
+	className?: string;
+	/** `ContextMenu.Item` rows, plus `ContextMenu.Label` and `ContextMenu.Separator`. */
+	children?: ReactNode22;
+}
+declare const ContextMenuContent: ForwardRefExoticComponent_tcubfn15<ContextMenuContentProps & RefAttributes_miuf5615<HTMLDivElement>>;
+interface ContextMenuProps {
+	/** Controlled open state. Pair with `onOpenChange`. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled menu. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the menu opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Turns the trigger area back into a plain one: no menu on right click or long press. Defaults to `false`. */
+	disabled?: boolean;
+	/** Pins the rows to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, they follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** The area and the menu — `ContextMenu.Trigger` plus a `ContextMenu.Content`. */
+	children?: ReactNode22;
+}
+type Element_12xgc18 = JSX_1kxb18["Element"];
+/**
+* A menu that grows out of the pointer on right click, or on a long press on
+* touch: the surface swells from the exact point you pressed into the menu.
+*
+* The morph comes from the shared engine (see Morph): from the press point
+* by default, or from its own center, a viewport edge or any element, with
+* the goo, a plain morph, a slide or a fade. The rows are Dropdown's — the
+* fluid hover background gliding between them, icons that firm up under it,
+* dimmed disabled rows the pointer skips — plus a keyboard shortcut at the
+* end of a row. The menu lifts 2 surface levels off its substrate. Built on
+* Base UI's ContextMenu: it opens at the pointer and flips or shifts to stay
+* on screen, arrow keys and typeahead move between rows, and picking a row,
+* Escape or an outside press closes it.
+*
+* Statics:
+* - `ContextMenu.Trigger` — the area that opens it (a `div`).
+* - `ContextMenu.Content` — the menu: the morph options `from`, `effect`,
+*   `hideSource`, `tier`.
+* - `ContextMenu.Item` — a row: `index`, `label`, `icon`, `shortcut`,
+*   `onSelect`, `disabled`.
+* - `ContextMenu.Label` / `ContextMenu.Separator` — a caption over a run of
+*   rows and a rule between runs (Dropdown's).
+*
+* @example {@include ./examples.mdx}
+*/
+declare function ContextMenu({ open, defaultOpen, onOpenChange, disabled, size, children }: ContextMenuProps): Element_12xgc18;
+import { MenuTriggerProps } from "@base-ui/react/menu";
+import { Menu as Menu2 } from "@base-ui/react/menu";
+import { ComponentProps, ForwardRefExoticComponent as ForwardRefExoticComponent10, HTMLAttributes as HTMLAttributes22, ReactNode as ReactNode23, RefAttributes as RefAttributes10, RefObject as RefObject14 } from "react";
+import { HTMLAttributes as HTMLAttributes21, InputHTMLAttributes as InputHTMLAttributes4 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn16 } from "react";
+import { RefAttributes as RefAttributes_miuf5616 } from "react";
+interface DropdownSearchProps extends Omit<InputHTMLAttributes4<HTMLInputElement>, "value" | "onChange" | "size" | "defaultValue"> {
+	/** The query. Filter the MenuItems you render against it. Optional under `filter`, where the panel holds the query. */
+	value?: string;
+	/** Called on every keystroke, and with `""` on close (see `clearOnClose`). Optional under `filter`. */
+	onValueChange?: (value: string) => void;
+	/** Local addition. Let the surrounding panel hold the query and filter its own `Dropdown.Item` rows by `label`, re-indexing the survivors and showing `Dropdown.Empty` when none match. Defaults to `false`. */
+	filter?: boolean;
+	/** Placeholder text. Defaults to `"Search…"`. */
+	placeholder?: string;
+	/** Reset the query to "" when the popup closes (the field unmounts with
+	*  it), so the menu reopens unfiltered. @default true */
+	clearOnClose?: boolean;
+	/** Take focus when the popup opens. @default true */
+	autoFocus?: boolean;
+}
+declare const DropdownSearch: ForwardRefExoticComponent_tcubfn16<DropdownSearchProps & RefAttributes_miuf5616<HTMLInputElement>>;
+declare const DropdownEmpty: ForwardRefExoticComponent_tcubfn16<HTMLAttributes21<HTMLDivElement> & RefAttributes_miuf5616<HTMLDivElement>>;
+import { JSX as JSX_1kxb19 } from "react";
+interface DropdownProps extends HTMLAttributes22<HTMLDivElement> {
+	/** `Dropdown.Item` rows, plus `Dropdown.Label` and `Dropdown.Separator`. */
+	children: ReactNode23;
+	/** The checked row: drives the animated selected background and the rows' radio semantics. */
+	checkedIndex?: number;
+	/** Uncontrolled twin of `checkedIndex`: the panel owns the selection, so rows need no `checked` or `onSelect` of their own. */
+	defaultCheckedIndex?: number;
+	/** Called with the newly checked row, or `undefined` when nothing is checked. */
+	onCheckedIndexChange?: (index: number | undefined) => void;
+	/** Multiple selection: the checked rows. Rows become checkbox items and contiguous runs share one merged background (see CheckboxGroup). */
+	checkedIndices?: number[];
+	/** Uncontrolled twin of `checkedIndices`: the panel toggles rows itself. */
+	defaultCheckedIndices?: number[];
+	/** Called with every checked row after a toggle. */
+	onCheckedIndicesChange?: (indices: number[]) => void;
+	/** Pins the panel's rows to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, they follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+	/** Extra classes for the panel surface — it is 18rem wide by default. */
+	className?: string;
+}
+type DropdownComponent = ForwardRefExoticComponent10<DropdownProps & RefAttributes10<HTMLDivElement>> & {
+	Menu2: typeof DropdownMenu;
+	Trigger: typeof DropdownTrigger;
+	Content: typeof DropdownContent;
+	Item: typeof MenuItem2;
+	Label: typeof DropdownLabel;
+	Separator: typeof DropdownSeparator;
+	Search: typeof DropdownSearch;
+	Empty: typeof DropdownEmpty;
+};
+/**
+* A menu in two forms: an inline panel that sits in the page, or a popup on
+* any trigger you like.
+*
+* `Dropdown` is the inline panel — an elevated surface with the fluid hover
+* background gliding between rows, a selected background that springs to the
+* picked one, contiguous picks merging into a single block in multiple mode,
+* and an animated focus ring. `Dropdown.Menu` + `Dropdown.Trigger` +
+* `Dropdown.Content` is the same panel as a popup on Base UI's Menu, which
+* brings the positioning, dismissal, roving highlight, typeahead and
+* close-on-select; the popup oozes out of its trigger and back through the
+* shared morph (see Morph), goo by default. Both take `checkedIndex` / `checkedIndices` to be driven
+* from outside, or `defaultCheckedIndex` / `defaultCheckedIndices` to run
+* themselves — and a `Dropdown.Search` marked `filter` makes the panel own
+* the query too, keeping only the rows whose `label` matches and showing
+* `Dropdown.Empty` when none do.
+*
+* Statics: Dropdown.Menu (the popup root: open, defaultOpen, onOpenChange,
+* disabled), Dropdown.Trigger (render), Dropdown.Content (the popup panel:
+* side, align, sideOffset and the morph options from, effect, hideSource, tier),
+* Dropdown.Item (a row: index, label, icon, checked, onSelect, disabled),
+* Dropdown.Label, Dropdown.Separator, Dropdown.Search and Dropdown.Empty.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Dropdown: DropdownComponent;
+interface DropdownMenuProps {
+	/** `Dropdown.Trigger` and `Dropdown.Content`. */
+	children: ReactNode23;
+	/** Controlled open state. Pair with `onOpenChange`. */
+	open?: boolean;
+	/** Initial open state — uncontrolled. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the menu opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Disables the menu. Defaults to `false`. */
+	disabled?: boolean;
+	/** Pins trigger-side content and the portalled popup rows to one step of the size ladder (default 36px, compact 28px — see Sizes). Omitted, they follow the surrounding SizeProvider. */
+	size?: SizeVariant;
+}
+type Element_12xgc19 = JSX_1kxb19["Element"];
+declare function DropdownMenu({ children, open: openProp, defaultOpen, onOpenChange, disabled, size }: DropdownMenuProps): Element_12xgc19;
+type DropdownTriggerProps = MenuTriggerProps;
+declare const DropdownTrigger: Menu2.Trigger;
+type MenuPositionerProps = ComponentProps<typeof Menu2.Positioner>;
+interface DropdownContentProps {
+	/** `Dropdown.Item` rows, plus `Dropdown.Label`, `Dropdown.Separator`, `Dropdown.Search`, `Dropdown.Empty`. */
+	children: ReactNode23;
+	/** Extra classes for the popup surface. */
+	className?: string;
+	/** Index of the checked item. Drives the animated selected background and
+	*  the radio-group value announced to assistive tech. */
+	checkedIndex?: number;
+	/** Uncontrolled twin of `checkedIndex`: the popup owns the selection, so rows need no `checked` or `onSelect` of their own. */
+	defaultCheckedIndex?: number;
+	/** Called with the newly checked row, or `undefined` when nothing is checked. */
+	onCheckedIndexChange?: (index: number | undefined) => void;
+	/** Multiple selection: the checked rows. Rows become checkbox items that
+	*  keep the menu open when toggled, and contiguous runs share one merged
+	*  background (see CheckboxGroup). */
+	checkedIndices?: number[];
+	/** Uncontrolled twin of `checkedIndices`: the popup toggles rows itself. */
+	defaultCheckedIndices?: number[];
+	/** Called with every checked row after a toggle. */
+	onCheckedIndicesChange?: (indices: number[]) => void;
+	/** Side of the trigger the popup prefers. Defaults to `"bottom"`. */
+	side?: MenuPositionerProps["side"];
+	/** Alignment against the trigger. Defaults to `"start"`. */
+	align?: MenuPositionerProps["align"];
+	/** Gap to the trigger, in px. Ignored when the menu opens in place over its trigger (`effect="morph"` with `hideSource`). Defaults to `6`. */
+	sideOffset?: number;
+	/** Where the menu grows from (see Morph): the trigger, the pointer, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject14<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the menu. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+}
+declare const DropdownContent: ForwardRefExoticComponent10<DropdownContentProps & RefAttributes10<HTMLDivElement>>;
+declare const DropdownLabel: ForwardRefExoticComponent10<HTMLAttributes22<HTMLDivElement> & RefAttributes10<HTMLDivElement>>;
+declare const DropdownSeparator: ForwardRefExoticComponent10<HTMLAttributes22<HTMLDivElement> & RefAttributes10<HTMLDivElement>>;
+import { HTMLAttributes as HTMLAttributes23, ReactNode as ReactNode24, RefObject as RefObject15 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn17 } from "react";
+import { RefAttributes as RefAttributes_miuf5617 } from "react";
+import { JSX as JSX_1kxb20 } from "react";
+interface PopoverTriggerProps extends SlotProps {
+	/** Open on hover as well as on press (a tap still toggles it on touch). Defaults to `false`. */
+	openOnHover?: boolean;
+	/** Hover delay before opening, in ms. Needs `openOnHover`. Defaults to `300`. */
+	delay?: number;
+	/** Delay before closing once the pointer leaves, in ms. Needs `openOnHover`. Defaults to `0`. */
+	closeDelay?: number;
+}
+declare const PopoverTrigger: ForwardRefExoticComponent_tcubfn17<PopoverTriggerProps & RefAttributes_miuf5617<HTMLButtonElement>>;
+declare const PopoverClose: ForwardRefExoticComponent_tcubfn17<SlotProps & RefAttributes_miuf5617<HTMLButtonElement>>;
+interface PopoverContentProps extends HTMLAttributes23<HTMLDivElement> {
+	/** Side of the trigger the panel opens on; it flips when there is no room. Defaults to `'bottom'`. */
+	side?: "top" | "right" | "bottom" | "left";
+	/** Alignment along that side. Defaults to `'center'`, or `'start'` when the panel opens in place (`effect="morph"` with `hideSource`). */
+	align?: "start" | "center" | "end";
+	/** Gap between trigger and panel in px — the length of the goo neck. Ignored when the panel opens in place over its trigger (`effect="morph"` with `hideSource`). Defaults to `12`. */
+	sideOffset?: number;
+	/** Where the panel grows from (see Morph): the pressed trigger, the press point, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject15<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+	/** Portal target. Defaults to the document body. */
+	container?: HTMLElement | null;
+	/** Classes for the panel's content box: padding, width, layout. */
+	className?: string;
+	/** The panel's content. Everything inside reads the popover's surface level as its substrate. */
+	children?: ReactNode24;
+}
+declare const PopoverContent: ForwardRefExoticComponent_tcubfn17<PopoverContentProps & RefAttributes_miuf5617<HTMLDivElement>>;
+declare const PopoverTitle: ForwardRefExoticComponent_tcubfn17<HTMLAttributes23<HTMLHeadingElement> & RefAttributes_miuf5617<HTMLHeadingElement>>;
+declare const PopoverDescription: ForwardRefExoticComponent_tcubfn17<HTMLAttributes23<HTMLParagraphElement> & RefAttributes_miuf5617<HTMLParagraphElement>>;
+interface PopoverProps {
+	/** Controlled open state. Pair with `onOpenChange`. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled popover. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the popover opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** Trap focus and block page interaction while open. Defaults to `false`. */
+	modal?: boolean;
+	/** The trigger and the panel — `Popover.Trigger` plus a `Popover.Content`. */
+	children?: ReactNode24;
+}
+type Element_12xgc20 = JSX_1kxb20["Element"];
+/**
+* A panel that oozes out of its trigger: the surface melts out of the button
+* through a liquid neck, then lets go and settles beside it.
+*
+* The morph comes from the shared engine (see Morph), so the panel can grow
+* from the trigger (the default), the press point, its own center, a viewport
+* edge or any element, with the goo neck, a plain morph, a slide or a fade.
+* It closes back into wherever it came from. The panel lifts 2 surface levels
+* off its substrate and re-provides that level. Built on Base UI's Popover:
+* it opens on press, or on hover too with `openOnHover`; it flips to the
+* other side when there is no room; Escape and an outside press close it.
+*
+* Statics:
+* - `Popover.Trigger` — the control that opens it: `render={<Button/>}` or
+*   `asChild`; `openOnHover`, `delay`, `closeDelay`.
+* - `Popover.Content` — the panel: `side`, `align` (the trigger's `start`,
+*   `center` or `end`), `sideOffset` and the morph options `from`,
+*   `effect`, `hideSource`, `tier`.
+* - `Popover.Title` / `Popover.Description` — its labelled heading and
+*   supporting line, wired for screen readers.
+* - `Popover.Close` — closes it; same `render` / `asChild` shape.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Popover2({ open, defaultOpen, onOpenChange, modal, children }: PopoverProps): Element_12xgc20;
+import { AnchorHTMLAttributes as AnchorHTMLAttributes2, HTMLAttributes as HTMLAttributes24, ReactElement as ReactElement6, ReactNode as ReactNode25, RefObject as RefObject16 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn18 } from "react";
+import { RefAttributes as RefAttributes_miuf5618 } from "react";
+import { JSX as JSX_1kxb21 } from "react";
+interface PreviewCardTriggerProps extends AnchorHTMLAttributes2<HTMLAnchorElement> {
+	/** Hover delay before the card opens, in ms. Defaults to `600`. */
+	delay?: number;
+	/** Delay before the card closes once the pointer leaves, in ms. Defaults to `300`. */
+	closeDelay?: number;
+	/** The element that becomes the trigger instead of the default link, e.g. an avatar; it brings its own styling. */
+	render?: ReactElement6;
+	/** Extra classes for the link. */
+	className?: string;
+	/** The link's content. */
+	children?: ReactNode25;
+}
+declare const PreviewCardTrigger: ForwardRefExoticComponent_tcubfn18<PreviewCardTriggerProps & RefAttributes_miuf5618<HTMLAnchorElement>>;
+interface PreviewCardContentProps extends HTMLAttributes24<HTMLDivElement> {
+	/** Side of the link the card opens on; it flips when there is no room. Defaults to `'bottom'`. */
+	side?: "top" | "right" | "bottom" | "left";
+	/** Alignment along that side. Defaults to `'center'`, or `'start'` when the card opens in place (`effect="morph"` with `hideSource`). */
+	align?: "start" | "center" | "end";
+	/** Gap between link and card in px — the length of the goo neck. Ignored when the card opens in place over its link (`effect="morph"` with `hideSource`). Defaults to `12`. */
+	sideOffset?: number;
+	/** Where the card grows from (see Morph): the hovered link, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "center" | "top" | "right" | "bottom" | "left" | RefObject16<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the link while open, so it reads as turning into the card. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+	/** Portal target. Defaults to the document body. */
+	container?: HTMLElement | null;
+	/** Classes for the card's content box: padding, width, layout. */
+	className?: string;
+	/** The card's content. Everything inside reads the card's surface level as its substrate. */
+	children?: ReactNode25;
+}
+declare const PreviewCardContent: ForwardRefExoticComponent_tcubfn18<PreviewCardContentProps & RefAttributes_miuf5618<HTMLDivElement>>;
+interface PreviewCardProps {
+	/** Controlled open state. Pair with `onOpenChange`. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled card. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the card opens or closes. */
+	onOpenChange?: (open: boolean) => void;
+	/** The link and the card — `PreviewCard.Trigger` plus a `PreviewCard.Content`. */
+	children?: ReactNode25;
+}
+type Element_12xgc21 = JSX_1kxb21["Element"];
+/**
+* A card that oozes out of a link on hover: a preview of what is behind it,
+* melting out of the link through a liquid neck.
+*
+* The morph comes from the shared engine (see Morph), so the card can grow
+* from the link (the default), its own center, a viewport edge or any
+* element, with the goo neck, a plain morph, a slide or a fade, and closes
+* back into wherever it came from. The card lifts 2 surface levels off its
+* substrate and re-provides that level. Built on Base UI's PreviewCard: it
+* opens after a hover or focus delay, stays open while the pointer travels
+* into it, flips to the other side when there is no room, and closes on
+* leave, Escape or an outside press. The card is a visual extra that touch
+* and screen-reader users never get, so the link must make sense on its own.
+*
+* Statics:
+* - `PreviewCard.Trigger` — the link: `href`, `delay`, `closeDelay`, or
+*   `render` for another element.
+* - `PreviewCard.Content` — the card: `side`, `align`, `sideOffset` and the
+*   morph options `from`, `effect`, `hideSource`, `tier`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function PreviewCard({ open, defaultOpen, onOpenChange, children }: PreviewCardProps): Element_12xgc21;
+import { HTMLAttributes as HTMLAttributes25, ReactNode as ReactNode26, RefObject as RefObject17 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn19 } from "react";
+import { RefAttributes as RefAttributes_miuf5619 } from "react";
+import { JSX as JSX_1kxb22 } from "react";
+type SheetSide = "top" | "right" | "bottom" | "left";
+interface SheetContentProps extends HTMLAttributes25<HTMLDivElement> {
+	/** Where the sheet grows from (see Morph): its own edge, the pressed trigger, the press point, its center, another edge, or a ref to any element. Defaults to the sheet's `side`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject17<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Hide the trigger while open, so it reads as turning into the sheet. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+	/** Portal target. Defaults to the document body. */
+	container?: HTMLElement | null;
+	/** Classes for the sheet's content box: padding, layout. */
+	className?: string;
+	/** The sheet's content. Everything inside reads the sheet's surface level as its substrate. */
+	children?: ReactNode26;
+}
+declare const SheetContent: ForwardRefExoticComponent_tcubfn19<SheetContentProps & RefAttributes_miuf5619<HTMLDivElement>>;
+declare const SheetIndent: ForwardRefExoticComponent_tcubfn19<HTMLAttributes25<HTMLDivElement> & RefAttributes_miuf5619<HTMLDivElement>>;
+interface SheetProps {
+	/** Controlled open state. */
+	open?: boolean;
+	/** Initial open state, for an uncontrolled sheet. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called when the sheet opens or closes, including by a swipe. */
+	onOpenChange?: (open: boolean) => void;
+	/** The edge the sheet is attached to; a swipe back toward it dismisses it. Defaults to `'bottom'`. */
+	side?: "top" | "right" | "bottom" | "left";
+	/** Snap points for a top or bottom sheet: fractions of the viewport height (0–1), pixels, or `px` / `rem` strings. */
+	snapPoints?: (number | string)[];
+	/** The snap point an uncontrolled sheet opens at. Defaults to the first one. */
+	defaultSnapPoint?: number | string;
+	/** Traps focus and locks page scroll while open. Defaults to `true`. */
+	modal?: boolean;
+	/** The trigger and the content — `Sheet.Trigger` plus a `Sheet.Content`. */
+	children?: ReactNode26;
+}
+type Element_12xgc22 = JSX_1kxb22["Element"];
+/**
+* A panel attached to an edge of the window, swiped away to dismiss.
+*
+* The sheet grows out of its own edge with the goo neck by default (see
+* Morph), or from its trigger, the press point or any element, and closes
+* back the same way. Base UI's Drawer does the rest: a swipe back toward the
+* edge dismisses it (it slides on off the edge from where the finger let
+* go), top and bottom sheets can rest at `snapPoints`, and
+* focus and scroll are held while it is open. It floats a spacing step off
+* its edge and lifts 4 surface levels off its substrate, like a dialog; top
+* and bottom sheets show a handle.
+*
+* Statics:
+* - `Sheet.Trigger`, `Sheet.Header`, `Sheet.Footer`, `Sheet.Title`,
+*   `Sheet.Description`, `Sheet.Close` — Dialog's parts, which work the same
+*   here.
+* - `Sheet.Content` — the panel, with the morph options `from`, `effect`,
+*   `hideSource`, `tier`.
+* - `Sheet.Provider` / `Sheet.Indent` — wrap the page in an `Indent` under a
+*   `Provider` and it eases back while any sheet inside is open.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Sheet({ children, open, defaultOpen, onOpenChange, side, snapPoints, defaultSnapPoint, modal }: SheetProps): Element_12xgc22;
+import { ReactNode as ReactNode27 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn20 } from "react";
+import { RefAttributes as RefAttributes_miuf5620 } from "react";
+import { JSX as JSX_1kxb23 } from "react";
+type ToastType = "success" | "loading" | "error" | "warning" | "info" | "action";
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastOptions {
+	title?: string;
+	description?: string;
+	type?: ToastType;
+	/** Ms before it leaves; 0 keeps it until dismissed. */
+	timeout?: number;
+	action?: {
+		label: string;
+		onClick?: () => void;
+	};
+}
+/** Shows toasts from inside a `Toast`: `show`, the per-state shortcuts, `promise` and `close`. */
+declare function useToast(): {
+	show: (o: ToastOptions) => string;
+	success: (o: ToastOptions) => string;
+	error: (o: ToastOptions) => string;
+	warning: (o: ToastOptions) => string;
+	info: (o: ToastOptions) => string;
+	promise: <T>(promise: Promise<T>, o: {
+		loading: ToastOptions;
+		success: ToastOptions;
+		error: ToastOptions;
+	}) => Promise<T>;
+	close: (toastId?: string) => void;
+};
+interface ToastTriggerProps extends Omit<SlotProps, "type"> {
+	/** The toast's title, in the pill. */
+	title?: string;
+	/** Text for the body the pill melts into. */
+	description?: string;
+	/** State: sets the icon and its color. Defaults to `'info'`. */
+	type?: "success" | "loading" | "error" | "warning" | "info" | "action";
+	/** Ms before it leaves; 0 keeps it until dismissed. Defaults to the `Toast`'s `timeout`. */
+	timeout?: number;
+	/** A button in the body. */
+	action?: {
+		label: string;
+		onClick?: () => void;
+	};
+	/** Runs a task: the toast shows `title` while it is pending, then `success` or `error`. */
+	promise?: () => Promise<unknown>;
+	/** The toast once `promise` resolves. */
+	success?: {
+		title?: string;
+		description?: string;
+	};
+	/** The toast if `promise` rejects. */
+	error?: {
+		title?: string;
+		description?: string;
+	};
+}
+declare const ToastTrigger: ForwardRefExoticComponent_tcubfn20<ToastTriggerProps & RefAttributes_miuf5620<HTMLButtonElement>>;
+interface ToastProps {
+	/** Where toasts stack; the pill sits on that side and the body opens away from the edge. Defaults to `'top-right'`. */
+	position?: "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+	/** How many toasts show at once; older ones wait. Defaults to `3`. */
+	limit?: number;
+	/** Ms a toast stays; hovering pauses it. Defaults to `6000`. */
+	timeout?: number;
+	/** The part of the app that can show toasts, with `Toast.Trigger`s or `useToast()`. */
+	children?: ReactNode27;
+}
+type Element_12xgc23 = JSX_1kxb23["Element"];
+/**
+* Gooey toasts: a pill with the state's icon and title that melts into a body
+* with the details.
+*
+* Each toast lands as a pill one control tall; when it has a description or
+* an action, the pill melts into a body a beat later through the shared goo
+* filter (see Morph), and folds back before it leaves, or stays open while
+* hovered. Six states (`success`, `loading`, `error`, `warning`, `info`,
+* `action`) set the icon and its status color; a promise toast spins as
+* `loading` and crossfades into its result. Built on Base UI's Toast:
+* timers pause on hover, a swipe toward the edge dismisses, and screen
+* readers hear every toast.
+*
+* `Toast` wraps the part of the app that shows toasts and renders them at
+* its `position`. Show one with `Toast.Trigger`, or call `useToast()`
+* inside it: `show`, `success`, `error`, `warning`, `info`, `promise` and
+* `close`.
+*
+* Statics:
+* - `Toast.Trigger` — a control that shows a toast when pressed:
+*   `render={<Button/>}` or `asChild`, with the toast's `title`,
+*   `description`, `type`, `timeout`, `action`, or a `promise` with its
+*   `success` / `error` toasts.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Toast({ position, limit, timeout, children }: ToastProps): Element_12xgc23;
+import { ReactNode as ReactNode28, RefObject as RefObject18 } from "react";
+import { JSX as JSX_1kxb24 } from "react";
+type Element_12xgc24 = JSX_1kxb24["Element"];
+declare function TooltipPortalContainer({ value, children }: {
+	value: HTMLElement | null;
+	children: ReactNode28;
+}): Element_12xgc24;
+interface TooltipProviderProps {
+	children: ReactNode28;
+	/** Hover delay before tooltips open, in ms. Defaults to 200. */
+	delayDuration?: number;
+	/** After a tooltip closes, adjacent tooltips opened within this window
+	*  skip the hover delay, in ms. Defaults to 300. */
+	skipDelayDuration?: number;
+}
+/** Groups descendant Tooltips so that once one opens, moving to an adjacent
+*  trigger shows its tooltip instantly instead of re-waiting the full delay.
+*  Wrap once at the app (or section) level; bare Tooltips still work without
+*  it via a per-instance fallback. */
+declare function TooltipProvider({ children, delayDuration, skipDelayDuration }: TooltipProviderProps): Element_12xgc24;
+type TooltipSide = "top" | "right" | "bottom" | "left";
+interface TooltipProps {
+	/** The content displayed inside the tooltip. */
+	content: ReactNode28;
+	/** The trigger element. Must accept a ref. */
+	children: React.ReactElement;
+	/** Preferred side of the trigger to render the tooltip on. Defaults to `"top"`. */
+	side?: TooltipSide;
+	/** Distance in pixels between the tooltip and the trigger. Defaults to 8. */
+	sideOffset?: number;
+	/** Hover delay before this tooltip opens, in ms. Defaults to 200, or to the
+	*  ambient TooltipProvider's delayDuration when one is present. */
+	delayDuration?: number;
+	/** Additional classes applied to the tooltip content container. */
+	className?: string;
+	/** Extra classes for the portalled positioner element — pass a z utility
+	*  here to lift the whole tooltip above other fixed layers (default z-50). */
+	contentClassName?: string;
+	/** When true, forces the tooltip open. When false, forces it closed. When undefined, uses default hover/focus behavior. */
+	forceOpen?: boolean;
+	/** Follow the cursor along one axis while hovering the trigger — for tall
+	*  or wide triggers (the Sidebar rail) where a centered tooltip sits far
+	*  from the pointer. The other axis stays anchored by `side`. */
+	followCursor?: "x" | "y";
+	/** Called when the tooltip's internal open state changes (before forceOpen is applied). */
+	onOpenChange?: (open: boolean) => void;
+	/** Where the label grows from (see Morph): the trigger, the pointer, its own center, a viewport edge, or a ref to any element. Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left" | RefObject18<HTMLElement | null>;
+	/** How it grows (see Morph): with the liquid goo neck, a plain morph, a slide or a fade. `followCursor` tooltips always fade. Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Spring tier of a plain morph, slide or fade; goo runs on its own `spring.goo`. Defaults to `'moderate'`. */
+	tier?: "moderate" | "slow";
+}
+/**
+* Floating tooltip with spring-based animations, configurable placement, and
+* rich content support.
+*
+* The trigger is whatever element you pass as the single child — it only has
+* to accept a ref. The label is portalled and grows out of its trigger
+* through the shared morph (see Morph), with the goo neck by default on
+* `spring.goo`, and flips when it would collide with the viewport edge.
+* `followCursor` tracks the pointer along one axis for tall or wide triggers,
+* while the other stays anchored by `side`. Built on Base UI's Tooltip.
+*
+* Statics:
+* - `Tooltip.Provider` — `TooltipProvider`: groups tooltips so moving from
+*   one trigger to an adjacent one skips the hover delay, and the morph: the
+*   next label shows in place.
+* - `Tooltip.PortalContainer` — `TooltipPortalContainer`: portal every
+*   descendant tooltip into a given element instead of the body.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Tooltip({ content, children, side, sideOffset, delayDuration, className, contentClassName, forceOpen, onOpenChange: onOpenChangeProp, followCursor, from, effect, tier }: TooltipProps): Element_12xgc24;
+import { ForwardRefExoticComponent as ForwardRefExoticComponent11, HTMLAttributes as HTMLAttributes26, ReactNode as ReactNode29, RefAttributes as RefAttributes11, TdHTMLAttributes, ThHTMLAttributes } from "react";
+interface TableProps extends HTMLAttributes26<HTMLTableElement> {
+	/** `Table.Header` and `Table.Body` children. */
+	children: ReactNode29;
+	/** Pins the table's rows to one step of the size ladder (default 36px, compact 28px — see Sizes). Defaults to the surrounding SizeProvider, else `"default"`. */
+	size?: SizeVariant;
+}
+/** The root plus its compound parts, typed so `<Table.Row>` type-checks. */
+type TableComponent = ForwardRefExoticComponent11<TableProps & RefAttributes11<HTMLTableElement>> & {
+	Header: typeof TableHeader;
+	Body: typeof TableBody;
+	Row: typeof TableRow;
+	Head: typeof TableHead;
+	Cell: typeof TableCell;
+};
+/**
+* Data table with row hover effects and semantic markup.
+*
+* A plain `<table>` whose body rows share one fluid hover highlight: the
+* background glides from row to row under the pointer, the row borders next
+* to the lit row fade out so it reads as one pill, and the lit row's cells
+* brighten from muted to foreground. Header cells render semibold, body
+* cells regular, with the weight change width-compensated. `size` pins every
+* row to one step of the size ladder; otherwise the table follows the
+* surrounding SizeProvider.
+*
+* Parts: `Table.Header` (`<thead>`), `Table.Body` (`<tbody>`), `Table.Row`
+* (`<tr>` — give body rows an `index`, starting at 0, so they join the hover
+* highlight; omit it on header rows), `Table.Head` (`<th>`) and `Table.Cell`
+* (`<td>`). Each forwards its ref and native attributes.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Table: TableComponent;
+declare const TableHeader: ForwardRefExoticComponent11<HTMLAttributes26<HTMLTableSectionElement> & RefAttributes11<HTMLTableSectionElement>>;
+declare const TableBody: ForwardRefExoticComponent11<HTMLAttributes26<HTMLTableSectionElement> & RefAttributes11<HTMLTableSectionElement>>;
+interface TableRowProps extends HTMLAttributes26<HTMLTableRowElement> {
+	index?: number;
+}
+declare const TableRow: ForwardRefExoticComponent11<TableRowProps & RefAttributes11<HTMLTableRowElement>>;
+declare const TableHead: ForwardRefExoticComponent11<ThHTMLAttributes<HTMLTableCellElement> & RefAttributes11<HTMLTableCellElement>>;
+declare const TableCell: ForwardRefExoticComponent11<TdHTMLAttributes<HTMLTableCellElement> & RefAttributes11<HTMLTableCellElement>>;
+import { HTMLAttributes as HTMLAttributes27 } from "react";
+import { ForwardRefExoticComponent as ForwardRefExoticComponent_tcubfn21 } from "react";
+import { RefAttributes as RefAttributes_miuf5621 } from "react";
+interface ThinkingIndicatorProps extends HTMLAttributes27<HTMLDivElement> {
+	/** The look: `shimmer` morphs a circle⇄infinity glyph beside a shimmering label (Fluid Functionalism's), `goo` melts three dots into one blob and splits them again beside a plain label. Defaults to `"shimmer"`. */
+	variant?: "shimmer" | "goo";
+	/** Show the glyph (or, for `goo`, the dots) before the label. Set to `false` for a text-only indicator (e.g. inline before a streamed reply). Defaults to `true`. */
+	showIcon?: boolean;
+	/** Step on the size ladder. Wins over the surrounding SizeProvider. Defaults to the provider's step, else `"default"`. */
+	size?: SizeVariant;
+}
+/**
+* Animated status indicator with morphing SVG and cycling text — the
+* assistant's working state.
+*
+* A glyph that morphs circle to infinity and back sits next to a shimmering
+* label that cycles Thinking, Moonwalking, Planning, Refining, each word
+* swapped on a spring. The row reserves the width of the longest word, so
+* nothing around it shifts while the words change. One static "Thinking…" is
+* announced to screen readers instead of a re-announcement every four
+* seconds, and reduced motion drops both the morph and the cycling for a
+* still glyph and label.
+*
+* `variant="goo"` swaps the glyph for three dots that melt into one blob and
+* split again through the goo filter (see Morph), beside a plain label;
+* reduced motion holds them split.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const ThinkingIndicator: ForwardRefExoticComponent_tcubfn21<ThinkingIndicatorProps & RefAttributes_miuf5621<HTMLDivElement>>;
+import { JSX as JSX_1kxb25 } from "react";
+type Element_12xgc25 = JSX_1kxb25["Element"];
+/**
+* Source code in the theme's syntax colors, one surface step above whatever
+* it sits on.
+*
+* sugar-high tokenizes; each token type takes a `--syntax-*` token from
+* tokens/colors.css, so code follows light and dark like everything else.
+* Long lines scroll sideways under a fading edge instead of wrapping. It is
+* also the docs chrome's Code slot: every example's source and every fenced
+* block on these pages renders through it.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Code({ children, language, className }: {
+	/** The source to show; surrounding blank lines are trimmed. */
+	children: string;
+	/** Fence name, alias or extension (`tsx`, `css`, `sh`, …). Unknown names render as plain text. Defaults to `'tsx'`. */
+	language?: string;
+	/** Extra classes for the frame. */
+	className?: string;
+}): Element_12xgc25;
+import { ReactNode as ReactNode30 } from "react";
+interface CraftProps {
+	/** The naive version: the same interface with the detail missing. */
+	bad: ReactNode30;
+	/** The system's version, with the detail in place. */
+	good: ReactNode30;
+	/** What goes wrong on the bad side, in one line. */
+	badNote?: string;
+	/** What the good side does instead, in one line. */
+	goodNote?: string;
+	/** Classes for the root grid. */
+	className?: string;
+}
+import { ForwardRefExoticComponent as ForwardRefExoticComponent12, HTMLAttributes as HTMLAttributes28, ReactNode as ReactNode31, RefAttributes as RefAttributes12 } from "react";
+import { Transition as Transition2 } from "motion/react";
+import { Dispatch as Dispatch2, MutableRefObject as MutableRefObject2, RefObject as RefObject19, SetStateAction as SetStateAction2 } from "react";
+interface ItemRect {
+	top: number;
+	height: number;
+	left: number;
+	width: number;
+}
+interface UseFluidHoverOptions {
+	/**
+	* Which direction to resolve the nearest item along.
+	*   "y"  — vertical lists (default): closest by top/height
+	*   "x"  — horizontal strips: closest by left/width
+	*   "xy" — 2-D grids: closest card across both rows AND columns,
+	*          measured by Euclidean distance to each item's center
+	*/
+	axis?: "x" | "y" | "xy";
+	/**
+	* Makes an item invisible to hit-testing without unregistering it — for
+	* rows that stay mounted while clipped away (a collapsed sub-tree).
+	* Unregistering would invalidate every measurement; a skipped item keeps
+	* the set stable. Consulted per mouse move, so keep it cheap.
+	*/
+	isItemDisabled?: (element: HTMLElement) => boolean;
+	/**
+	* Whether a click that lands between items (a gap, the padding, past the
+	* last row) is routed to the highlighted item, so what is lit is what a
+	* click hits. On by default: in a menu or a list the highlight is a
+	* promise about the click. Pass `false` where empty space should stay
+	* inert (rows with destructive actions, generous whitespace), or
+	* `{ maxDistance }` to route only clicks within that many pixels of the
+	* highlighted item's edge.
+	*/
+	gapClick?: boolean | {
+		maxDistance?: number;
+	};
+}
+interface UseFluidHoverReturn {
+	activeIndex: number | null;
+	setActiveIndex: Dispatch2<SetStateAction2<number | null>>;
+	itemRects: ItemRect[];
+	/**
+	* True once every registered item has been measured and no remeasure is
+	* pending, i.e. `itemRects` describes the current item set. Gate absolutely
+	* positioned overlays on it: an overlay that mounts against a rect a later
+	* pass still corrects animates from the wrong place to the right one, which
+	* reads as the highlight sliding in from another row.
+	*/
+	isMeasured: boolean;
+	sessionRef: MutableRefObject2<number>;
+	handlers: {
+		onMouseMove: (e: React.MouseEvent) => void;
+		onMouseEnter: () => void;
+		onMouseLeave: () => void;
+		/**
+		* Routes a click that lands between items (a gap, the padding, past the
+		* last row) to the highlighted item, so the highlight and the click agree:
+		* what is lit is what a click hits. A click inside an item is left to the
+		* item. Disabled items (`isItemDisabled`) are never activated.
+		*/
+		onClick: (e: React.MouseEvent) => void;
+	};
+	registerItem: (index: number, element: HTMLElement | null) => void;
+	/**
+	* Invalidates the published rects and runs the hook's coalesced measurement
+	* pass again, holding `isMeasured` false until it settles. Reach for it when
+	* the rects may be wrong and showing an overlay against them would misplace
+	* it: a popup that stays mounted between opens keeps its items registered,
+	* so nothing else would notice that its rects were taken while it was
+	* hidden. Registration, item resize, and container resize already trigger
+	* a pass; do not call this on `children` changes.
+	*/
+	remeasure: () => void;
+	/**
+	* Re-reads the rects synchronously, keeping `isMeasured` as it is. Only for
+	* layout that moves the rows under a visible overlay frame by frame (the
+	* accordion re-measures inside its height animation). Everything else
+	* wants `remeasure`, or nothing.
+	*/
+	measureItems: () => void;
+}
+declare function useFluidHover<T extends HTMLElement>(containerRef: RefObject19<T | null>, options?: UseFluidHoverOptions): UseFluidHoverReturn;
+/**
+* Registers an item's element with its list for as long as it is mounted.
+* The one way rows join a list: pass the hook's `registerItem` (or the copy
+* a context hands down), the row's index, and its ref. Either may be
+* missing for a row rendered outside a list (a standalone card, an accordion
+* item that is not grouped); then nothing is registered.
+*/
+declare function useRegisterFluidHoverItem(registerItem: ((index: number, element: HTMLElement | null) => void) | undefined, index: number | undefined, ref: RefObject19<HTMLElement | null>): void;
+import { JSX as JSX_1kxb27 } from "react";
+/** What the highlight reads off the hook: the highlighted index, the
+*  measured rects, whether they are current, and the pointer session. */
+type FluidHoverSource = Pick<UseFluidHoverReturn, "activeIndex" | "itemRects" | "isMeasured" | "sessionRef">;
+interface HighlightFromHook {
+	/** The hook's return value. The highlight sits on
+	*  `itemRects[activeIndex]` once `isMeasured`, and re-keys on the session. */
+	hover: FluidHoverSource;
+	/** Keep the list's state but show nothing (a closed popup, hover switched
+	*  off). Runs the exit fade. */
+	hidden?: boolean;
+	rect?: never;
+	session?: never;
+}
+interface HighlightFromRect {
+	/** For lists that resolve their own rect (the sidebar's unified scope):
+	*  the rect to sit on, in the container's coordinate space. `null` hides
+	*  the highlight (it fades out on `spring.fast.exit`). */
+	rect: ItemRect | null;
+	/** `sessionRef.current` from `useFluidHover`. It increments when the
+	*  cursor enters the container, which re-keys the highlight so it fades in
+	*  at `from ?? rect` instead of sliding over from wherever it was last. */
+	session: number;
+	hover?: never;
+	hidden?: never;
+}
+type FluidHoverHighlightProps = (HighlightFromHook | HighlightFromRect) & {
+	/** Where a fresh session fades in from. A dropdown passes its checked row,
+	*  a nav menu its active route. Defaults to the rect itself. */
+	from?: ItemRect | null;
+	/** Radius, z-index, anything else. Merged onto
+	*  `absolute bg-hover pointer-events-none`. */
+	className?: string;
+	/** The positional spring. Defaults to `spring.fast`. Pass `false` to snap
+	*  to the new rect with no travel (a layout reflow that moved the rows
+	*  underneath, not a hover change). The opacity fade is always 0.08s. */
+	transition?: Transition2 | false;
+};
+type Element_12xgc27 = JSX_1kxb27["Element"];
+declare function FluidHoverHighlight(props: FluidHoverHighlightProps): Element_12xgc27;
+type FluidHoverAxis = "x" | "y" | "xy";
+interface FluidHoverItemProps extends HTMLAttributes28<HTMLButtonElement> {
+	/** Position in the list. Assigned automatically to direct children of `FluidHover`; pass it by hand for rows rendered inside a wrapper of your own. */
+	index?: number;
+	/** Skips the row: never lit, never the target of a gap click. It stays registered, so its neighbours keep their indices. Defaults to `false`. */
+	disabled?: boolean;
+	/** The row's content — a label, or an icon plus text, or (on `xy`) a title over a description. */
+	children?: ReactNode31;
+	/** Classes for the row, merged over the per-axis defaults. */
+	className?: string;
+}
+/**
+* One row of a fluid hover list: a real button, focusable and activatable from
+* the keyboard, announced by its label. It registers itself with the
+* surrounding `FluidHover` for as long as it is mounted; outside one it is
+* just a button.
+*/
+declare const FluidHoverItem: ForwardRefExoticComponent12<FluidHoverItemProps & RefAttributes12<HTMLButtonElement>>;
+interface FluidHoverProps extends HTMLAttributes28<HTMLDivElement> {
+	/** Which way the list runs: `'y'` for lists, `'x'` for strips, `'xy'` for grids. Defaults to `'y'`, or `'xy'` when `columns` is above 1. */
+	axis?: FluidHoverAxis;
+	/** Grid columns. Above 1 the container becomes a grid and resolves the nearest item across rows and columns. Defaults to `1`, or `2` when `axis` is `'xy'`. */
+	columns?: number;
+	/** Shorthand rows: one `FluidHover.Item` per string, indexed in order. Omit it and pass `FluidHover.Item` children instead. */
+	items?: string[];
+	/** Renders the content of a shorthand row. Defaults to the string itself. */
+	renderItem?: (item: string, index: number) => ReactNode31;
+	/** Rows to skip: never lit, never the target of a gap click. They stay registered, so their neighbours keep their indices. */
+	disabledIndices?: number[];
+	/** Whether a click that lands between rows goes to the lit one, so what is lit is what a click hits. `false` leaves empty space inert; `{ maxDistance }` routes only clicks within that many pixels of the lit row. Defaults to `true`. */
+	gapClick?: boolean | {
+		maxDistance?: number;
+	};
+	/** Classes for the highlight itself — radius and z-index. Merged over `absolute bg-hover` and the shape system's radius. */
+	highlightClassName?: string;
+	/** Classes for the list container. Padding here is part of the list: a click in it still lands on the lit row. */
+	className?: string;
+	/** `FluidHover.Item` rows, when `items` is not enough. Direct Item children are indexed in order. */
+	children?: ReactNode31;
+}
+type FluidHoverComponent = ForwardRefExoticComponent12<FluidHoverProps & RefAttributes12<HTMLDivElement>> & {
+	Item: typeof FluidHoverItem;
+};
+/**
+* Hover that never blinks and always follows your cursor to the nearest item.
+*
+* One rule, no dead zones: an item the pointer is inside wins, and otherwise
+* the item whose center is nearest does — so a cursor in a gap, in the
+* padding, or past the last row still lands on something, and a click there
+* lands on what is lit (`gapClick`). One list is one FluidHover: it owns the
+* container's mouse handlers, hands every row its index, and draws the single
+* highlight that melts between the measured rectangles, stretching toward the
+* next row and letting go (the liquid indicators in Morph).
+*
+* Three axes, one feel. `y` is for lists — menus, tables, radio rows — and
+* measures the vertical center; `x` is for strips — tabs, segmented controls —
+* and measures the horizontal one; `xy` is for card grids, where the nearest
+* card is the shortest straight line to a center across both rows and columns.
+* Pass `columns` and the container becomes that grid and picks `xy` on its own.
+*
+* Split a list at the divider. Rows that are alternatives to each other share
+* one list — children ride with their parent — and the highlight never crosses
+* into a different kind of thing: that is a second FluidHover. A disabled row
+* is skipped rather than unregistered (`disabledIndices`, or `disabled` on the
+* row), so the rows around it keep their indices and their measurements.
+*
+* It costs 1 transform and 1 loop per move: the pick is one pass
+* over cached rectangles per animation frame, with no DOM reads per row, and
+* the highlight travels on a transform. While it melts, a shrinking blob and
+* the goo filter join it, and both are gone once it settles, so a resting
+* highlight is filtered by nothing. Reduced motion is honoured on its own,
+* read straight off the OS media query with no MotionConfig wrapper needed:
+* the highlight still fades in on the nearest row, it just stops travelling
+* between rows.
+*
+* Use it when everything in the list can be clicked (a menu, a list, tabs, a
+* grid of links), when the items sit close together, and when they stay where
+* they are while you look at them. Skip it when a wrong click would hurt, when
+* only some of the cards can be clicked, when there is a lot of empty space
+* around the items, or when rows change place as you scroll.
+*
+* Statics: FluidHover.Item — one row, rendered as a real button (focusable,
+* activatable from the keyboard, announced by its label); the hook only lights
+* it, it never moves focus.
+*
+* For a list this container cannot express, the machinery is re-exported
+* unchanged. `useFluidHover(containerRef, { axis, isItemDisabled, gapClick })`
+* returns `{ handlers, registerItem, activeIndex, setActiveIndex, itemRects,
+* isMeasured, remeasure, sessionRef }`: spread `handlers` on the container,
+* give each row `useRegisterFluidHoverItem(registerItem, index, ref)`, light a
+* row yourself with `setActiveIndex` for keyboard focus, and call `remeasure`
+* when the rects may be stale (a popup opening on rows that never unmounted).
+* `FluidHoverHighlight` then draws the fill: `hover` is the hook's return
+* value, `hidden` keeps the state but shows nothing, `from` is where a fresh
+* entry fades in (a dropdown passes its checked row), `className` carries
+* radius and z-index, and `transition` is the travel — `false` snaps into
+* place after a reflow instead of sliding.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const FluidHover: FluidHoverComponent;
+import { ReactNode as ReactNode33 } from "react";
+import { ReactNode as ReactNode32 } from "react";
+import { JSX as JSX_1kxb28 } from "react";
+interface MorphPartProps {
+	/** Pairs the part in the trigger with its twin in the overlay; unique within one overlay. */
+	id: string;
+	/** Classes for the part's box. */
+	className?: string;
+	/** The part's content: an image, a title. */
+	children?: ReactNode32;
+}
+type Element_12xgc28 = JSX_1kxb28["Element"];
+declare function MorphPart({ id, className, children }: MorphPartProps): Element_12xgc28;
+import { JSX as JSX_1kxb29 } from "react";
+interface MorphProps {
+	/** Where the panel grows from: the pressed `'trigger'`, the press `'pointer'` (a circle; keyboard opens use the trigger's center), the panel's own `'center'`, or a viewport edge (`'top'`, `'right'`, `'bottom'`, `'left'`). Defaults to `'trigger'`. */
+	from?: "trigger" | "pointer" | "center" | "top" | "right" | "bottom" | "left";
+	/** How it gets there: `'goo'` grows the surface with a liquid neck to its source, `'morph'` grows it without one, `'slide'` moves the finished panel in, `'fade'` only fades (what every effect becomes under reduced motion). Defaults to `'goo'`. */
+	effect?: "goo" | "morph" | "slide" | "fade";
+	/** Spring tier of a plain morph, slide or fade, which closes on the tier's faster exit tween; goo runs on its own `spring.goo`. Defaults to `'slow'`. */
+	tier?: "moderate" | "slow";
+	/** Hide the trigger while the panel is open, so the trigger reads as becoming the panel. Defaults to `false`. */
+	hideSource?: boolean;
+	/** Controlled open state. Pair with `onOpenChange`. */
+	open?: boolean;
+	/** Uncontrolled initial open state, toggled by the built-in trigger. Defaults to `false`. */
+	defaultOpen?: boolean;
+	/** Called with the next open state when the trigger is pressed. */
+	onOpenChange?: (open: boolean) => void;
+	/** Label of the built-in trigger. Defaults to `'Open'`. */
+	label?: string;
+	/** Extra classes for the stage (trigger + panel). */
+	className?: string;
+	/** The panel's content. */
+	children?: ReactNode33;
+}
+type Element_12xgc29 = JSX_1kxb29["Element"];
+/**
+* Overlays grow out of whatever opened them. One progress value on a spring
+* tier carries the surface from its source to its own box, and every
+* morphing overlay in this system runs on that one engine.
+*
+* The overlay's popup keeps its final size the whole time, so Base UI's
+* positioning, collision flipping and focus handling never see the animation.
+* Inside it, three layers move: the surface's background and its shadow (the
+* `Elevated` level, as `SURFACE_BG` / `SURFACE_SHADOW`), the goo layer that
+* melts the surface into its source, and the content, revealed by a clip
+* from the same rect. The surface moves its real box rather than being
+* clipped, so its shadow is never cut off and nothing scales.
+*
+* ## Options
+*
+* Every morphing overlay takes the same `from`, `effect` and `hideSource`
+* options, and a spring `tier` for the effects other than goo (see Motion).
+*
+* - `from` — where the surface grows from. `'trigger'` is the trigger that
+*   was pressed; it is measured again on close, and when it has gone or
+*   scrolled away the surface grows from its `'center'` instead.
+*   `'pointer'` is the press point, `'center'` the panel's own center, and an
+*   edge (`'top'`, `'right'`, `'bottom'`, `'left'`) the side of the viewport.
+*   Components also take a ref to any element, such as a card that
+*   expands.
+* - `effect` — `'goo'` (the default) grows the surface with a liquid neck to
+*   its source, like two drops of water merging; `'morph'` grows it without
+*   one; `'slide'` moves the finished panel in; `'fade'` only fades.
+* - `hideSource` — hides the source while open, so it reads as turning into
+*   the overlay. Focus can still return to it. With `effect="morph"` an
+*   anchored overlay also opens in place: the panel lays over its trigger,
+*   corner to corner, instead of beside it, so the trigger's own box is where
+*   it starts and where it shrinks back to.
+*
+* ## Motion
+*
+* Goo runs on its own tier, `spring.goo`: it lands in about 200ms with a
+* little bounce and springs back in about as long, slow enough for the neck
+* to stretch. Its blur eases away over the last stretch, so the neck pinches
+* off as the surface lands, and while it melts a hairline in the shadow's
+* color follows the liquid shape, so a surface the color of the page still
+* shows it; the surface's own shadow takes over as it lets go. The other
+* effects open on a spring tier (`slow` by default) and close on that tier's
+* faster exit tween, like every other animation here (see Motion).
+* Reduced motion, the OS setting or a `MotionConfig` asking for it, turns every
+* effect into a fade.
+*
+* ## Liquid indicators
+*
+* The same goo moves everything that travels between items: the active tab
+* of Tabs and TabsSubtle, the Switch thumb, RadioGroup's selection and the
+* fluid hover highlight of every list (Select, Dropdown, Combobox, Card,
+* Accordion, FluidHover). The indicator springs to its new item and leaves
+* a blob behind. The blob lingers for a third of the spring, then follows
+* to the back of the new item while it shrinks, so the two melt into one
+* stretched drop that lets go. A long move tears it into a drop and a
+* droplet that catches up and is absorbed.
+*
+* Merged selections (CheckboxGroup, a multiple Dropdown) melt the same way:
+* a checked row grows out of its center and flows into its checked
+* neighbours, and an unchecked one pinches off and shrinks away.
+*
+* - The goo filter runs only while a blob is alive; at rest an indicator is
+*   one plain element.
+* - The melted shape is filled with the indicator's own token, so
+*   translucent fills such as `bg-hover` and `bg-active` melt like opaque
+*   surfaces. Shadows are drawn again beneath the goo while it moves.
+* - A short move or a resize in place springs without a blob, and a square
+*   indicator, with no radius to melt, only slides.
+* - Reduced motion snaps the indicator into place.
+*
+* ## Shared parts
+*
+* `Morph.Part` pairs an element in the trigger with its twin in the overlay
+* (same `id`), so the part flies from one to the other while the surface
+* morphs, and back on close: a card's image or title moving into a Dialog.
+*
+* ## The `Morph` stage
+*
+* `Morph` itself is a docs stage, not a building block: a trigger and a small
+* panel below it that plays one `from` × `effect` pair.
+*
+* Statics:
+* - `Morph.Part` — a shared part (`id`, `className`), for overlays that scope
+*   parts (Dialog).
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Morph2({ from, effect, tier, hideSource, open, defaultOpen, onOpenChange, label, className, children }: MorphProps): Element_12xgc29;
+import { ReactNode as ReactNode34 } from "react";
+declare const spring: {
+	readonly fast: {
+		readonly type: "spring";
+		readonly duration: 0.08;
+		readonly bounce: 0;
+		readonly exit: {
+			readonly duration: 0.06;
+		};
+	};
+	readonly moderate: {
+		readonly type: "spring";
+		readonly duration: 0.16;
+		readonly bounce: 0;
+		readonly exit: {
+			readonly duration: 0.12;
+		};
+	};
+	readonly slow: {
+		readonly type: "spring";
+		readonly duration: 0.24;
+		readonly bounce: 0.12;
+		readonly exit: {
+			readonly duration: 0.16;
+		};
+	};
+	readonly goo: {
+		readonly type: "spring";
+		readonly visualDuration: 0.25;
+		readonly bounce: 0.15;
+		readonly exit: {
+			readonly type: "spring";
+			readonly visualDuration: 0.2;
+			readonly bounce: 0;
+		};
+	};
+};
+declare const exitFallbackMs: (tier: {
+	exit: {
+		duration: number;
+	} | {
+		visualDuration: number;
+	};
+}) => number;
+import { JSX as JSX_1kxb30 } from "react";
+type SpringTier = keyof typeof spring;
+interface MotionProps {
+	/** Spring tier the children enter on (`spring.<tier>`); they leave on its `.exit` tween. `fast` for hover, fades and small toggles, `moderate` for dropdowns and tabs, `slow` for dialogs and large surfaces. Defaults to `'moderate'`. */
+	tier?: "fast" | "moderate" | "slow";
+	/** Controlled visibility — `true` animates the children in, `false` animates them out. Pair with `onShowChange`. */
+	show?: boolean;
+	/** Uncontrolled initial visibility, toggled by the built-in trigger. Defaults to `true`. */
+	defaultShow?: boolean;
+	/** Called with the next visibility when the built-in trigger is pressed. */
+	onShowChange?: (show: boolean) => void;
+	/** Leave on the tier's enter spring instead of its faster `.exit` tween — the drag FF's motion rules avoid; only for side-by-side comparisons. Defaults to `false`. */
+	sameExit?: boolean;
+	/** Forwarded to motion's `<MotionConfig reducedMotion>`: `'user'` follows the OS setting, `'always'` previews it (transforms drop out, opacity fades stay), `'never'` ignores it. Defaults to `'user'`. */
+	reducedMotion?: "user" | "always" | "never";
+	/** Extra classes for the wrapper (stage + trigger column). */
+	className?: string;
+	/** The content that animates in and out. */
+	children: ReactNode34;
+}
+type Element_12xgc30 = JSX_1kxb30["Element"];
+/**
+* Three spring speeds, exits a little faster than entrances, and one fluid
+* hover shared by every list. Pick a speed, wire it in — every component
+* follows the same pattern.
+*
+* All animation comes from one of three springs in `lib/springs`
+* (re-exported here as `spring`). Hover states and small toggles use `fast`,
+* dropdowns and tabs use `moderate`, dialogs and drawers use `slow`. No
+* component invents its own timing, so things you've never thought about
+* together move at the same pace.
+*
+* Each tier's value is the **enter** transition; its `.exit` is the matching
+* **exit** — a plain tween, no bounce, one tier quicker — so a dismissal reads
+* as crisp and final rather than replaying the entrance in reverse. The bigger
+* the thing that moves, the slower the tier. `moderate` is critically damped: it
+* lands exactly with no overshoot, so it also carries panels that must settle
+* precisely.
+*
+* A fourth tier, `goo`, belongs to the morph engine alone (see Morph): the goo
+* effect lands in about 200ms with a little bounce and springs back rather
+* than tweening, so its liquid neck has time to stretch and pinch off.
+*
+* ## Usage
+*
+* Enter with `transition={spring.fast}` and leave with `exit={{ opacity: 0,
+* transition: spring.fast.exit }}`. Never hand-write a duration: the values
+* belong in `springs`, not in component code.
+*
+* - `exitFallbackMs(tier)` (also exported) is the tier's exit in ms plus a 100ms
+*   buffer, for deferred-unmount timers that guard an exit tween.
+* - CSS consumers get the same tiers from `tokens/motion.css`
+*   (`--duration-<tier>` and `--duration-<tier>-exit`).
+*
+* ## Reduced motion
+*
+* Every spring respects the OS setting once the app tree is wrapped in
+* `<MotionConfig reducedMotion="user">`. With reduced motion on, position and
+* scale changes drop out and only the opacity fades remain.
+*
+* ## The `Motion` demo
+*
+* `Motion` itself is a docs demo, not a building block: it shows or hides its
+* children with one tier's enter spring and exit tween (fade + scale + a short
+* rise), with a built-in Show/Hide trigger and a readout of the token it plays.
+* Hidden children keep their space and leave the accessibility tree.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function Motion({ tier, show, defaultShow, onShowChange, sameExit, reducedMotion, className, children }: MotionProps): Element_12xgc30;
+import { ComponentPropsWithoutRef as ComponentPropsWithoutRef2, ForwardRefExoticComponent as ForwardRefExoticComponent13, ReactNode as ReactNode35, RefAttributes as RefAttributes13 } from "react";
+import { ScrollAreaScrollbarProps as ScrollAreaScrollbarProps_g9nf4s } from "@base-ui/react";
+type Orientation = "vertical" | "horizontal" | "both";
+interface ScrollAreaProps extends ComponentPropsWithoutRef2<"div"> {
+	/** Classes for the inner scrolling viewport — where the `scroll-fade` / `scroll-fade-x` utility goes. */
+	viewportClassName?: string;
+	/** Which axes get scrollbars. Defaults to `"vertical"`. */
+	orientation?: Orientation;
+	/** Classes for the outer container — set the height/width constraint here. */
+	className?: string;
+	/** The scrolling content. Give it an intrinsic size (`w-max`, `whitespace-nowrap`) to overflow horizontally. */
+	children?: ReactNode35;
+}
+interface ScrollAreaStatics {
+	/** `ScrollBar` — one scrollbar, for composing a Base UI scroll area by hand. */
+	Bar: typeof ScrollBar;
+}
+/**
+* A scrollbar that stays out of the way but never disappears, over shadcn's
+* scroll-fade as the baseline edge treatment — restyled to the shape system,
+* with native scroll physics on touch.
+*
+* macOS hides the scrollbar until you start scrolling, so a clipped list
+* gives no sign it has more below. Here the thumb rests narrow and
+* low-contrast, then widens and darkens on hover, and its radius follows the
+* shape system. `className` constrains the outer box; `viewportClassName`
+* goes on the inner scrolling viewport, where the `scroll-fade` (or
+* `scroll-fade-x`) utility dissolves the edges that have more to scroll. On
+* touch-primary devices the whole thing steps aside for native overflow
+* scrolling. Built on Base UI's ScrollArea; scrollbar machinery adapted from
+* Lina (https://lina.sameer.sh).
+*
+* Statics:
+* - `ScrollArea.Bar` — the standalone `ScrollBar`, for hand-composed scroll
+*   areas.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const ScrollArea: ForwardRefExoticComponent13<ScrollAreaProps & RefAttributes13<HTMLDivElement>> & ScrollAreaStatics;
+declare const ScrollBar: ForwardRefExoticComponent13<Omit<Omit<ScrollAreaScrollbarProps_g9nf4s, "ref"> & RefAttributes13<HTMLDivElement>, "ref"> & RefAttributes13<HTMLDivElement>>;
+import { ReactNode as ReactNode36 } from "react";
+import { JSX as JSX_1kxb31 } from "react";
+type Element_12xgc31 = JSX_1kxb31["Element"];
+/**
+* Two component sizes: a 36px default and a 28px compact. An interface reads
+* as one product when its controls share a sizing rhythm — a button next to a
+* select next to a tab should land on the same height. Each size scales text,
+* icons, padding and gaps together, not just the box. Compact is for dense,
+* data-heavy tools (filter bars, toolbars, table headers, sidebars); default
+* is the right call for everything else.
+*
+* Density is a region decision, not a per-control one: wrap the region in a
+* `SizeProvider` and every sized component inside follows — menus included,
+* since React context crosses portals. Precedence is explicit `size` prop on
+* the component > nearest `SizeProvider` > `'default'`. Button, Badge,
+* Select, Tabs, TabsSubtle, Dropdown, CheckboxGroup, RadioGroup, Input,
+* InputGroup, InputCopy, InputMessage, Table, Switch, Slider, Accordion, Card,
+* ColorPicker, ThinkingIndicator, Calendar and the date and time pickers all
+* take that per-component `size`. Type follows the ladder too: compact drops
+* each type role one notch.
+*
+* Also exported from this item: `useSize(override?)`, `useSizeVariant(override?)`,
+* `useSizeContext()` (`{ size, setSize }` inside a provider), `useTypeScale(override?)`,
+* the `sizeMap` and `typeScale` tables, and the `SizeVariant`, `SizeClasses`,
+* `TypeScaleRole`, `TypeScaleStep` types.
+*
+* @example {@include ./examples.mdx}
+*/
+declare function SizeProvider({ children, size, defaultSize }: {
+	/** The region whose controls follow the step — popups opened from inside it included. */
+	children: ReactNode36;
+	/** Controlled variant — pins every control in the subtree to one step, overriding internal state. `'default'` is 36px controls, `'compact'` is 28px. */
+	size?: "default" | "compact";
+	/** Uncontrolled initial variant, switchable via `useSizeContext().setSize`. Defaults to `'default'`. */
+	defaultSize?: "default" | "compact";
+}): Element_12xgc31;
+import { ComponentPropsWithoutRef as ComponentPropsWithoutRef3, ForwardRefExoticComponent as ForwardRefExoticComponent14, ReactNode as ReactNode38, RefAttributes as RefAttributes14 } from "react";
+declare function surfaceClasses(bgLevel: number, shadowLevel?: number): string;
+import { ReactNode as ReactNode37 } from "react";
+import { JSX as JSX_1kxb32 } from "react";
+declare function useSurface(): number;
+type Element_12xgc32 = JSX_1kxb32["Element"];
+declare function SurfaceProvider({ value, children }: {
+	value: number;
+	children: ReactNode37;
+}): Element_12xgc32;
+interface ElevatedProps extends ComponentPropsWithoutRef3<"div"> {
+	/**
+	* Steps above the current substrate.
+	*
+	* The component's own surface level becomes `min(substrate + offset, 8)`
+	* and is re-provided to descendants via SurfaceProvider, so further
+	* nesting walks up the ladder automatically.
+	*
+	* Conventional offsets:
+	*   2 — dropdown / popover / select menu
+	*   4 — dialog / modal
+	*/
+	offset: number;
+	/**
+	* Override for the shadow level. Defaults to the computed surface level.
+	*
+	* Pass a fixed value when the component should keep a constant shadow
+	* weight regardless of how deeply it's nested — e.g. a dropdown always
+	* reads `shadow-surface-3` whether it opens on the page or inside a
+	* dialog, even though its background tracks the substrate.
+	*/
+	shadowLevel?: number;
+	/** Merged after the surface classes; radius and padding go here. */
+	className?: string;
+	/** Content of the surface. Everything inside reads this surface's level as its substrate. */
+	children?: ReactNode38;
+}
+interface ElevatedStatics {
+	/** `SurfaceProvider` — set the substrate for a subtree by hand. */
+	Provider: typeof SurfaceProvider;
+}
+/**
+* Eight surface levels that nest. Components read their substrate from
+* context and lift relative to it, so popovers, dropdowns, and dialogs stay
+* visible at any depth — in both light and dark mode.
+*
+* Three pieces: tokens, substrate context, and the primitive. The tokens are
+* eight `bg-surface-N` / `shadow-surface-N` pairs. The substrate is a React
+* context holding the level of the container you are in (1, the page, when
+* nothing provides one). `Elevated` reads that substrate, settles at
+* `min(substrate + offset, 8)`, paints the matching background and shadow,
+* and re-provides its own level, so nested surfaces keep climbing the ladder
+* without anything passed between them. Conventional offsets: 2 for a
+* dropdown, popover or select menu; 4 for a dialog or modal. All other props
+* (ref included) go to the `div`.
+*
+* Statics:
+* - `Elevated.Provider` — `SurfaceProvider`: set the substrate for a subtree
+*   by hand (1 page, 3 popover, 5 dialog).
+*
+* Also exported: `SurfaceProvider`, `useSurface()` (the current substrate
+* level, 1 when no provider is present) and `surfaceClasses(bgLevel,
+* shadowLevel = bgLevel)` for components that paint a level without
+* `Elevated`.
+*
+* @example {@include ./examples.mdx}
+*/
+declare const Elevated: ForwardRefExoticComponent14<ElevatedProps & RefAttributes14<HTMLDivElement>> & ElevatedStatics;
+import { ReactNode as ReactNode39 } from "react";
+import { JSX as JSX_1kxb33 } from "react";
+type ShapeVariant = "pill" | "rounded";
+type Element_12xgc33 = JSX_1kxb33["Element"];
+declare function ShapeProvider({ children, defaultShape }: {
+	children: ReactNode39;
+	defaultShape?: ShapeVariant;
+}): Element_12xgc33;
+import { CnFunction } from "cn";
+declare const cn: CnFunction;
+export { useTypeScale, useToast, useSurface, useSizeVariant, useSizeContext, useSize, useSidebar, useRegisterFluidHoverItem, useFluidHover, useDropdownMaybe, useDropdown, useDialogState, typeScale, triggerVariants, surfaceClasses, spring, sizeMap, sidebarMenuButtonVariants, parseColor, exitFallbackMs, fieldVariants as comboboxFieldVariants, cn, buttonVariants, buildParsed, badgeVariants, badgeColors, ValuePosition, UseFluidHoverReturn, UseFluidHoverOptions, TypeScaleStep, TypeScaleRole, TooltipSide, TooltipProviderProps, TooltipProvider, TooltipProps, TooltipPortalContainer, Tooltip, ToastType, ToastTriggerProps, ToastTrigger, ToastProps, ToastPosition, ToastOptions, Toast, TimePickerProps, TimePicker, ThinkingIndicatorProps, ThinkingIndicator, TabsSubtleProps, TabsSubtlePanelProps, TabsSubtlePanel, TabsSubtleItemProps, TabsSubtleItem, TabsSubtle, TabsProps, TabsListProps, TabsList, Tabs, TableRowProps, TableRow, TableProps, TableHeader, TableHead, TableCell, TableBody, Table, TabPanelProps, TabPanel, TabItemProps, TabItem, SwitchProps, Switch, SurfaceProvider, SpringTier, SliderValue, SliderProps, SliderComfortableProps, SliderComfortable, Slider, SizeVariant, SizeProvider, SizeClasses, SidebarVariant, SidebarTriggerProps, SidebarTrigger, SidebarSide, SidebarSeparator, SidebarSelectionValue, SidebarSelection, SidebarSectionProps, SidebarRailProps, SidebarRail, SidebarProviderProps, SidebarProvider, SidebarProps, SidebarMenuSubProps, SidebarMenuSubItemProps, SidebarMenuSubItem, SidebarMenuSubButtonProps, SidebarMenuSubButton, SidebarMenuSub, SidebarMenuSkeletonProps, SidebarMenuSkeleton, SidebarMenuProps, SidebarMenuItemProps, SidebarMenuItem, SidebarMenuButtonProps, SidebarMenuButton, SidebarMenuBadgeProps, SidebarMenuBadge, SidebarMenuActions, SidebarMenuActionProps, SidebarMenuAction, SidebarMenu, SidebarInsetProps, SidebarInset, SidebarInputProps, SidebarInput, SidebarHeader, SidebarGroupLabelProps, SidebarGroupLabel, SidebarGroupContent, SidebarGroupActions, SidebarGroupActionProps, SidebarGroupAction, SidebarGroup, SidebarFooter, SidebarContextValue, SidebarContentProps, SidebarContent, SidebarCollapsible, SidebarAppProps, SidebarApp, Sidebar, SheetSide, SheetProps, SheetIndent, SheetContentProps, SheetContent, Sheet, ShapeProvider, SelectTriggerProps, SelectTrigger, SelectSeparator, SelectProps, SelectLabel, SelectItemProps, SelectItem, SelectGroup, SelectContentProps, SelectContent, Select, SearchProps, Search2 as Search, ScrollBar, ScrollAreaProps, ScrollArea, SIDEBAR_WIDTH_MOBILE, SIDEBAR_WIDTH, SIDEBAR_MIN_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_KEYBOARD_SHORTCUT_RIGHT, SIDEBAR_KEYBOARD_SHORTCUT, SIDEBAR_COOKIE_NAME, SIDEBAR_COOKIE_MAX_AGE, RadioItemProps, RadioItem, RadioGroupProps, RadioGroup, QueuedMessage, PreviewCardTriggerProps, PreviewCardTrigger, PreviewCardProps, PreviewCardContentProps, PreviewCardContent, PreviewCard, PopoverTriggerProps, PopoverTrigger, PopoverTitle, PopoverProps, PopoverDescription, PopoverContentProps, PopoverContent, PopoverClose, Popover2 as Popover, ParsedColor, MotionProps, Motion, MorphProps, MorphPart, Morph2 as Morph, MonthPickerProps, MonthPicker, MenuItemRenderOptions, MenuItem2 as MenuItem, LabelProps, Label2 as Label, ItemRect, InputProps, InputMessageStatus, InputMessageSlotContext, InputMessageProps, InputMessage, InputGroupProps, InputGroup, InputFieldProps, InputCopyVariant, InputCopyProps, InputCopyAlign, InputCopy, Input2 as Input, IconProvider, FluidHoverProps, FluidHoverItemProps, FluidHoverItem, FluidHoverHighlightProps, FluidHoverHighlight, FluidHoverAxis, FluidHover, FileThumbnail, ElevatedProps, Elevated, DurationPickerProps, DurationPicker, DropdownTriggerProps, DropdownTrigger, DropdownSeparator, DropdownSearchProps, DropdownSearch, DropdownProps, DropdownMenuProps, DropdownMenu, DropdownLabel, DropdownEmpty, DropdownContextValue, DropdownContentProps, DropdownContent, Dropdown, DialogSlotProps as DialogTriggerProps, DialogTrigger, DialogTitle, DialogState, DialogProps, DialogHeader, DialogFooter, DialogDescription, DialogContentProps, DialogContent, DialogSlotProps as DialogCloseProps, DialogClose, Dialog, DateRangePickerProps, DateRangePicker, DatePickerProps, DatePicker, CraftProps, ContextMenuProps, ContextMenuItemProps, ContextMenuItem, ContextMenuContentProps, ContextMenuContent, ContextMenu, CommandTrigger, CommandShortcut, CommandProps, CommandPaletteProps, CommandPalette, CommandListRoot, CommandList, CommandItems, CommandItem, CommandGroup, CommandContentProps, CommandContent, Command, ComboboxValue, ComboboxProps, ComboboxListProps, ComboboxList, ComboboxItemProps, ComboboxItemObject, ComboboxItemData, ComboboxItem, ComboboxInputProps, ComboboxInput, ComboboxEmptyProps, ComboboxEmpty, ComboboxContentProps, ComboboxContent, ComboboxChipsProps, ComboboxChips, Combobox, ColorTile, ColorSwatchProps, ColorSwatch, ColorPickerProps, ColorPickerPortalContainer, ColorPickerPopoverProps, ColorPickerPopover, ColorPicker, ColorFormat, Code, CheckboxItemProps, CheckboxItem, CheckboxGroupProps, CheckboxGroup, CardTitle, CardProps, CardMedia, CardLogo, CardImage, CardHeader, CardGroupProps, CardGroup, CardFooter, CardFeature, CardEyebrow, CardDescription, CardContent, CardButtonVariant, CardButtonProps, CardButton, CardAction, Card, CalendarProps, Calendar, ButtonSize, ButtonProps, Button2 as Button, BadgeSize, BadgeProps, BadgeColor, Badge, AlertDialogProps, AlertDialogContent, AlertDialog, AccordionTrigger, AccordionItem, AccordionGroup, AccordionContent, Accordion };