@momentumworld/ui-react 0.17.0

package/dist/index.d.ts

@@ -0,0 +1,2162 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { Accordion as Accordion$1 } from '@base-ui/react/accordion';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as _base_ui_react from '@base-ui/react';
+import { AlertDialog as AlertDialog$1 } from '@base-ui/react/alert-dialog';
+import { useRender } from '@base-ui/react/use-render';
+import { OrbState, OrbSize } from 'thinking-orbs';
+export { OrbSize, OrbState, OrbTheme, ThinkingOrb, ThinkingOrbProps } from 'thinking-orbs';
+import { Autocomplete as Autocomplete$1 } from '@base-ui/react/autocomplete';
+import { Avatar as Avatar$1 } from '@base-ui/react/avatar';
+import { B as Button, a as ButtonProps, b as InputProps, I as Input } from './input-JCZs61MO.js';
+export { c as buttonVariants } from './input-JCZs61MO.js';
+import { DayPicker, DateRange } from 'react-day-picker';
+import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
+import * as RechartsPrimitive from 'recharts';
+import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
+import { CheckboxGroup as CheckboxGroup$1 } from '@base-ui/react/checkbox-group';
+import { Collapsible as Collapsible$1 } from '@base-ui/react/collapsible';
+import * as react_aria_components from 'react-aria-components';
+import { ColorSlider, ColorArea as ColorArea$1, ColorPicker as ColorPicker$1, ColorThumb as ColorThumb$1, ColorSwatch as ColorSwatch$1, ColorField, ColorSwatchPicker } from 'react-aria-components';
+export { getColorChannels, parseColor } from 'react-aria-components';
+import { Combobox as Combobox$1 } from '@base-ui/react/combobox';
+import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
+import { Options, GlobalOptions } from 'canvas-confetti';
+import { Drawer as Drawer$1 } from 'vaul';
+import { ContextMenu as ContextMenu$1 } from '@base-ui/react/context-menu';
+import { Field as Field$1 } from '@base-ui/react/field';
+import { Fieldset as Fieldset$1 } from '@base-ui/react/fieldset';
+import { Form as Form$1 } from '@base-ui/react/form';
+import { Separator as Separator$1 } from '@base-ui/react/separator';
+import { Tooltip as Tooltip$1 } from '@base-ui/react/tooltip';
+import { OTPInput } from 'input-otp';
+import { Menu as Menu$1 } from '@base-ui/react/menu';
+import { MenubarProps } from '@base-ui/react/menubar';
+import { Meter as Meter$1 } from '@base-ui/react/meter';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { NavigationMenu as NavigationMenu$1 } from '@base-ui/react/navigation-menu';
+import { NumberField as NumberField$1 } from '@base-ui/react/number-field';
+import { Popover as Popover$1 } from '@base-ui/react/popover';
+import { PreviewCard as PreviewCard$1 } from '@base-ui/react/preview-card';
+import { Progress as Progress$1 } from '@base-ui/react/progress';
+import { Options as Options$1 } from 'qr-code-styling';
+import { Radio as Radio$1 } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
+import * as ResizablePrimitive from 'react-resizable-panels';
+import { ScrollArea as ScrollArea$1 } from '@base-ui/react/scroll-area';
+import { Slider as Slider$1 } from '@base-ui/react/slider';
+import { Loader2Icon } from 'lucide-react';
+import { useSpinDelay } from 'spin-delay';
+import { Switch as Switch$1 } from '@base-ui/react/switch';
+import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
+import { Duration } from 'date-fns';
+import { Toast } from '@base-ui/react/toast';
+import { Toggle as Toggle$2 } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroup$1 } from '@base-ui/react/toggle-group';
+import { Toolbar as Toolbar$1 } from '@base-ui/react/toolbar';
+import { ClassValue } from 'clsx';
+import '@base-ui/react/input';
+
+declare function Accordion(props: Accordion$1.Root.Props): React$1.JSX.Element;
+declare function AccordionItem({ className, ...props }: Accordion$1.Item.Props): React$1.JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: Accordion$1.Trigger.Props): React$1.JSX.Element;
+declare function AccordionPanel({ className, children, ...props }: Accordion$1.Panel.Props): React$1.JSX.Element;
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "error" | "info" | "success" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof alertVariants>): React$1.JSX.Element;
+declare function AlertTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function AlertDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function AlertAction({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+declare const AlertDialogCreateHandle: typeof AlertDialog$1.createHandle;
+declare const AlertDialog: typeof AlertDialog$1.Root;
+declare const AlertDialogPortal: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.DialogPortalProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function AlertDialogTrigger(props: AlertDialog$1.Trigger.Props): React$1.JSX.Element;
+declare function AlertDialogBackdrop({ className, ...props }: AlertDialog$1.Backdrop.Props): React$1.JSX.Element;
+declare function AlertDialogViewport({ className, ...props }: AlertDialog$1.Viewport.Props): React$1.JSX.Element;
+declare function AlertDialogPopup({ className, bottomStickOnMobile, ...props }: AlertDialog$1.Popup.Props & {
+    bottomStickOnMobile?: boolean;
+}): React$1.JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare function AlertDialogFooter({ className, variant, ...props }: React.ComponentProps<"div"> & {
+    variant?: "default" | "bare";
+}): React$1.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: AlertDialog$1.Title.Props): React$1.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: AlertDialog$1.Description.Props): React$1.JSX.Element;
+declare function AlertDialogClose(props: AlertDialog$1.Close.Props): React$1.JSX.Element;
+
+type ThemeTogglerVariant = "circle" | "square" | "triangle" | "diamond" | "hexagon" | "rectangle" | "star";
+interface AnimatedThemeTogglerProps extends React.ComponentPropsWithoutRef<"button"> {
+    /** Duration of the reveal animation in milliseconds. */
+    duration?: number;
+    /** Clip-path shape used for the view-transition reveal. */
+    variant?: ThemeTogglerVariant;
+    /** Expand from the viewport center instead of the button center. */
+    fromCenter?: boolean;
+}
+/**
+ * Animated light/dark toggle using the View Transitions API.
+ *
+ * Drives the kit's `ThemeProvider` (via `useTheme`), so persistence and the
+ * `data-theme` attribute are handled for you. On browsers without the View
+ * Transitions API it falls back to an instant toggle.
+ *
+ * Requires the kit stylesheet (`@countryclub/ui-react/styles.css`), which
+ * defines the scoped `::view-transition` rules.
+ */
+declare function AnimatedThemeToggler({ className, duration, variant, fromCenter, ...props }: AnimatedThemeTogglerProps): React$1.JSX.Element;
+
+declare const appStoreButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function GooglePlayLogoIcon(props: React$1.ComponentProps<"svg">): React$1.JSX.Element;
+declare function AppleLogoIcon(props: React$1.ComponentProps<"svg">): React$1.JSX.Element;
+declare function GalaxyStoreLogoIcon(props: React$1.ComponentProps<"svg">): React$1.JSX.Element;
+declare function AppGalleryLogoIcon(props: React$1.ComponentProps<"svg">): React$1.JSX.Element;
+type AppStoreButtonStore = "google-play" | "app-store" | "galaxy-store" | "app-gallery";
+interface AppStoreButtonProps extends useRender.ComponentProps<"button"> {
+    /** Which store badge to render: google-play, app-store, galaxy-store or app-gallery. */
+    store: AppStoreButtonStore;
+    variant?: VariantProps<typeof appStoreButtonVariants>["variant"];
+}
+declare function AppStoreButton({ className, store, variant, render, ...props }: AppStoreButtonProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+declare function AspectRatio({ ratio, className, style, ...props }: React$1.ComponentProps<"div"> & {
+    ratio?: number;
+}): React$1.JSX.Element;
+
+interface AuroraOrbProps {
+    /**
+     * Which thinking-orbs animation to show: "working" | "searching" |
+     * "solving" | "listening" | "composing" | "shaping". Default "working".
+     */
+    state?: OrbState;
+    /** Tuned size preset from thinking-orbs — 20 (inline) or 64 (avatar). Default 20. */
+    size?: OrbSize;
+    /** Animation speed multiplier on top of the preset's baked speed. Default 1. */
+    speed?: number;
+    /**
+     * Gradient stops swept across the dots, matching AuroraText's default RGB
+     * set (pink → purple → blue → sky). Vivid stops stay legible on both light
+     * and dark backgrounds — the dots are painted with these colors directly.
+     */
+    colors?: string[];
+    className?: string;
+}
+/**
+ * A `thinking-orbs` orb recolored with the aurora gradient — the dotted-orb
+ * counterpart to `AuroraText`.
+ *
+ * The stock `<ThinkingOrb>` has no color API (its canvas paints monochrome
+ * theme ink only), but the package exports its frame painters (`MODE_DRAWS` +
+ * `resolvePreset`) for custom rendering. So we run the same animation loop
+ * and, after each frame, composite a slowly rotating aurora gradient onto the
+ * dots via `source-in`: the dots' alpha (their depth shading) survives while
+ * their ink color is replaced by the gradient. Theme detection becomes
+ * unnecessary — the gradient works on light and dark backgrounds alike.
+ * Respects prefers-reduced-motion (renders a single still frame).
+ *
+ * @example
+ * <AuroraOrb state="solving" speed={0.7} />
+ * <AuroraOrb size={64} colors={["#22d3ee", "#a855f7", "#f43f5e"]} />
+ */
+declare function AuroraOrb({ className, colors, size, speed, state, }: AuroraOrbProps): React$1.JSX.Element;
+
+interface AuroraTextProps {
+    children: ReactNode;
+    className?: string;
+    /**
+     * Gradient stops, cycled left→right and looped back to the first. The default
+     * is a vivid RGB set (pink → purple → blue → sky) chosen to stay legible on
+     * BOTH light and dark backgrounds — the text is painted with these colors
+     * (transparent fill + clipped gradient), so it never depends on the page bg.
+     */
+    colors?: string[];
+    /** Animation speed multiplier. 1 ≈ a 10s loop; 2 is twice as fast. */
+    speed?: number;
+    /** Add a soft, blurred RGB halo behind the text (a subtle aura). */
+    glow?: boolean;
+}
+/**
+ * Animated RGB gradient text: the gradient slowly sweeps across the glyphs on a
+ * loop (via `background-position`, so it's GPU-composited and cheap — safe on
+ * mobile). Purely CSS; no JS ticking. The real text is kept in an `sr-only`
+ * span so it stays selectable/announced while the visible layer is decorative.
+ *
+ * @example
+ * <AuroraText>Thinking</AuroraText>
+ * <AuroraText glow speed={1.4} colors={["#22d3ee", "#a855f7", "#f43f5e"]}>Live</AuroraText>
+ */
+declare const AuroraText: React$1.NamedExoticComponent<AuroraTextProps>;
+
+declare const Autocomplete: typeof Autocomplete$1.Root;
+declare function AutocompleteInput({ className, showTrigger, showClear, startAddon, size, ...props }: Omit<Autocomplete$1.Input.Props, "size"> & {
+    showTrigger?: boolean;
+    showClear?: boolean;
+    startAddon?: React.ReactNode;
+    size?: "sm" | "default" | "lg" | number;
+    ref?: React.Ref<HTMLInputElement>;
+}): React$1.JSX.Element;
+declare function AutocompletePopup({ className, children, sideOffset, ...props }: Autocomplete$1.Popup.Props & {
+    sideOffset?: number;
+}): React$1.JSX.Element;
+declare function AutocompleteItem({ className, children, ...props }: Autocomplete$1.Item.Props): React$1.JSX.Element;
+declare function AutocompleteSeparator({ className, ...props }: Autocomplete$1.Separator.Props): React$1.JSX.Element;
+declare function AutocompleteGroup({ className, ...props }: Autocomplete$1.Group.Props): React$1.JSX.Element;
+declare function AutocompleteGroupLabel({ className, ...props }: Autocomplete$1.GroupLabel.Props): React$1.JSX.Element;
+declare function AutocompleteEmpty({ className, ...props }: Autocomplete$1.Empty.Props): React$1.JSX.Element;
+declare function AutocompleteRow({ className, ...props }: Autocomplete$1.Row.Props): React$1.JSX.Element;
+declare function AutocompleteValue({ ...props }: Autocomplete$1.Value.Props): React$1.JSX.Element;
+declare function AutocompleteList({ className, ...props }: Autocomplete$1.List.Props): React$1.JSX.Element;
+declare function AutocompleteClear({ className, ...props }: Autocomplete$1.Clear.Props): React$1.JSX.Element;
+declare function AutocompleteStatus({ className, ...props }: Autocomplete$1.Status.Props): React$1.JSX.Element;
+declare function AutocompleteCollection({ ...props }: Autocomplete$1.Collection.Props): React$1.JSX.Element;
+declare function AutocompleteTrigger({ className, ...props }: Autocomplete$1.Trigger.Props): React$1.JSX.Element;
+declare const useAutocompleteFilter: (options?: _base_ui_react.AutocompleteFilterOptions) => _base_ui_react.AutocompleteFilter;
+
+declare const avatarVariants: (props?: ({
+    size?: "lg" | "sm" | "xl" | "xs" | "md" | "2xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AvatarSize$1 = NonNullable<VariantProps<typeof avatarVariants>["size"]>;
+interface AvatarProps extends Avatar$1.Root.Props, VariantProps<typeof avatarVariants> {
+    /** Image URL. When omitted or it fails to load, the fallback is shown. */
+    src?: string;
+    alt?: string;
+    /** Initials shown when there is no image. */
+    initials?: React$1.ReactNode;
+    /** Custom fallback node (overrides initials and the placeholder icon). */
+    placeholder?: React$1.ReactNode;
+    /** Icon component used as the fallback when nothing else is provided. */
+    placeholderIcon?: React$1.ElementType;
+    /** A presence dot in the bottom-right corner. */
+    status?: "online" | "offline";
+    /** Shows a verified tick in the bottom-right corner. */
+    verified?: boolean;
+    /** A node (e.g. <AvatarCompanyIcon />) shown in the top-right corner. */
+    badge?: React$1.ReactNode;
+}
+declare function Avatar({ className, size, src, alt, initials, placeholder, placeholderIcon: PlaceholderIcon, status, verified, badge, children, ...props }: AvatarProps): React$1.JSX.Element;
+declare function AvatarImage({ className, ...props }: Avatar$1.Image.Props): React$1.JSX.Element;
+declare function AvatarFallback({ className, ...props }: Avatar$1.Fallback.Props): React$1.JSX.Element;
+/** A small company/brand logo badge, meant for the Avatar `badge` prop. */
+declare function AvatarCompanyIcon({ className, size, alt, ...props }: React$1.ComponentProps<"img"> & {
+    size?: "sm" | "md" | "lg";
+}): React$1.JSX.Element;
+/** A dashed "add" button sized to match avatars — for avatar groups. */
+declare function AvatarAddButton({ className, size, ...props }: React$1.ComponentProps<"button"> & {
+    size?: AvatarSize$1;
+}): React$1.JSX.Element;
+/** An avatar paired with a title and subtitle. */
+declare function AvatarLabelGroup({ className, size, src, alt, initials, status, verified, title, subtitle, ...props }: React$1.ComponentProps<"div"> & {
+    size?: "sm" | "md" | "lg";
+    src?: string;
+    alt?: string;
+    initials?: string;
+    status?: "online" | "offline";
+    verified?: boolean;
+    title: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
+}): React$1.JSX.Element;
+/** A larger, framed profile photo with optional verified tick. */
+declare function AvatarProfilePhoto({ className, size, ...props }: Omit<AvatarProps, "size"> & {
+    size?: "sm" | "md" | "lg";
+}): React$1.JSX.Element;
+
+type AvatarSize = NonNullable<VariantProps<typeof avatarVariants>["size"]>;
+declare const avatarGroupVariants: (props?: ({
+    overlap?: "lg" | "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AvatarGroupItem {
+    src?: string;
+    /** Initials shown when there is no image. */
+    initials?: React$1.ReactNode;
+    alt?: string;
+    /**
+     * Label revealed on hover when `showNameOnHover` is set (e.g. the person's
+     * name). Falls back to `alt` when omitted.
+     */
+    name?: React$1.ReactNode;
+}
+interface AvatarGroupProps extends React$1.ComponentProps<"div">, VariantProps<typeof avatarGroupVariants> {
+    /** Data-driven avatars. Omit to compose `<Avatar>` children yourself. */
+    items?: AvatarGroupItem[];
+    /** Cap the visible avatars; the rest collapse into a "+N" chip. */
+    max?: number;
+    size?: AvatarSize;
+    /**
+     * Reveal each avatar's `name` (or `alt`) in a tooltip above it on hover /
+     * focus. Only applies to the data-driven `items` path.
+     */
+    showNameOnHover?: boolean;
+}
+/**
+ * A row of overlapping avatars with an overflow "+N" chip. Pass `items` for the
+ * data-driven path, or compose `<Avatar>` children directly for full control.
+ *
+ * With `showNameOnHover`, hovering (or focusing) an avatar reveals its `name`
+ * in a tooltip — e.g. hovering Amir's photo shows "Amir".
+ */
+declare function AvatarGroup({ className, items, max, size, overlap, showNameOnHover, children, ...props }: AvatarGroupProps): React$1.JSX.Element;
+
+interface AnimatedCounterProps extends Omit<React$1.ComponentProps<"span">, "children"> {
+    /** The target value to animate to. */
+    value: number;
+    /** Tween duration in ms (default 650). */
+    duration?: number;
+    /** Decimal places to render (default 0). */
+    decimals?: number;
+    /** Prefix rendered before the number, e.g. "$". */
+    prefix?: string;
+    /** Suffix rendered after the number, e.g. "%". */
+    suffix?: string;
+    /** Group digits with thousands separators (default true). */
+    separator?: boolean;
+}
+/**
+ * A number that tweens smoothly from its previous value to the next whenever
+ * `value` changes — e.g. dashboard stats re-counting when the time range
+ * switches. Dependency-free (requestAnimationFrame), so it stays tiny and works
+ * anywhere. Respects `prefers-reduced-motion` by snapping to the final value.
+ *
+ * The animation is purely visual; the accessible text is always the final
+ * value (via `aria-label`) so screen readers never read the intermediate tween.
+ */
+declare function AnimatedCounter({ value, duration, decimals, prefix, suffix, separator, className, ...props }: AnimatedCounterProps): React$1.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    shape?: "default" | "pill" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+    variant?: "default" | "error" | "info" | "success" | "warning" | "destructive" | "outline" | "secondary" | "modern" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends useRender.ComponentProps<"span"> {
+    variant?: VariantProps<typeof badgeVariants>["variant"];
+    size?: VariantProps<typeof badgeVariants>["size"];
+    shape?: VariantProps<typeof badgeVariants>["shape"];
+}
+declare function Badge({ className, variant, size, shape, render, ...props }: BadgeProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/** A small status dot. Inherits the badge's text color; recolor via className. */
+declare function BadgeDot({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+/** A tiny round avatar image sized to sit inside a badge. */
+declare function BadgeAvatar({ alt, className, ...props }: React$1.ComponentProps<"img">): React$1.JSX.Element;
+/** A round country flag. `country` is an ISO 3166-1 alpha-2 code (e.g. "AU"). */
+declare function BadgeFlag({ alt, className, country, src, ...props }: React$1.ComponentProps<"img"> & {
+    country?: string;
+}): React$1.JSX.Element;
+/** A small remove button for dismissible badges. Renders an X by default. */
+declare function BadgeCloseButton({ children, className, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element;
+
+declare const badgeGroupVariants: (props?: ({
+    align?: "leading" | "trailing" | null | undefined;
+    color?: "error" | "success" | "warning" | "gray" | "brand" | null | undefined;
+    variant?: "pill" | "modern" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeGroupColor = NonNullable<VariantProps<typeof badgeGroupVariants>["color"]>;
+interface BadgeGroupProps extends Omit<useRender.ComponentProps<"span">, "color"> {
+    /** `pill` is a tonal, fully-rounded chip; `modern` is a bordered card-style chip with a status dot. */
+    variant?: VariantProps<typeof badgeGroupVariants>["variant"];
+    color?: BadgeGroupColor;
+    /** Which side of the message the inner badge sits on. */
+    align?: VariantProps<typeof badgeGroupVariants>["align"];
+    /** Short label rendered inside the inner badge. */
+    badge: React$1.ReactNode;
+    /** Arrow shown after the message (leading) or inside the badge (trailing). Pass `null` to hide. */
+    icon?: React$1.ReactNode;
+}
+declare function BadgeGroup({ className, variant, color, align, badge, icon, children, render, ...props }: BadgeGroupProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+declare function Breadcrumb({ ...props }: React$1.ComponentProps<"nav">): React$1.JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React$1.ComponentProps<"ol">): React$1.JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+declare function BreadcrumbLink({ className, render, ...props }: useRender.ComponentProps<"a">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function BreadcrumbPage({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+
+declare function Calendar({ className, classNames, showOutsideDays, components: userComponents, ...props }: React$1.ComponentProps<typeof DayPicker>): React$1.JSX.Element;
+
+interface DatePickerProps {
+    /** The selected date (controlled). */
+    value?: Date;
+    onValueChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    /** Trigger button `disabled`. */
+    disabled?: boolean;
+    /** Restrict selectable days (passed straight to react-day-picker). */
+    fromDate?: Date;
+    toDate?: Date;
+    /** date-fns format for the trigger label (default "LLL dd, y"). */
+    displayFormat?: string;
+    align?: "start" | "center" | "end";
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+}
+/**
+ * A single-date picker: a button that opens a calendar in a popover. The
+ * canonical way to take a date in this system — never a native `<input
+ * type="date">`. Controlled via `value` / `onValueChange`.
+ */
+declare function DatePicker({ value, onValueChange, placeholder, disabled, fromDate, toDate, displayFormat, align, className, id, ...props }: DatePickerProps): React$1.JSX.Element;
+interface DateRangePickerProps {
+    value?: DateRange;
+    onValueChange?: (range: DateRange | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    fromDate?: Date;
+    toDate?: Date;
+    numberOfMonths?: number;
+    displayFormat?: string;
+    align?: "start" | "center" | "end";
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+}
+/**
+ * A date-range picker: pick a start and (optionally) end date. Controlled via
+ * `value` / `onValueChange` with react-day-picker's `{from, to}` shape.
+ */
+declare function DateRangePicker({ value, onValueChange, placeholder, disabled, fromDate, toDate, numberOfMonths, displayFormat, align, className, id, ...props }: DateRangePickerProps): React$1.JSX.Element;
+
+/**
+ * A time of day is a STRING here, not a `Date`.
+ *
+ * "Nine in the morning, every Tuesday" has no date, and giving it one forces every
+ * caller to invent a day and then remember to ignore it — which is how a weekly
+ * opening hour ends up shifted by a timezone that was never part of the question.
+ * `TimePicker` therefore speaks `"HH:mm"`, zero-padded and 24-hour, which is also
+ * what a DRF `TimeField` parses. `DateTimePicker` below takes a real `Date`, because
+ * an instant genuinely is one.
+ */
+type TimeValue = string;
+interface TimePickerProps {
+    /** The selected time as `"HH:mm"` (controlled). */
+    value?: TimeValue | null;
+    onValueChange?: (value: TimeValue | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Minutes between offered times. 15 by default; 5 and 30 are the other useful ones. */
+    step?: number;
+    /** Bounds, inclusive, as `"HH:mm"`. */
+    min?: TimeValue;
+    max?: TimeValue;
+    /** `false` shows a 24-hour clock. The value on the wire is 24-hour either way. */
+    hour12?: boolean;
+    align?: "start" | "center" | "end";
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+}
+/**
+ * A time picker: a button that opens a list of times in a popover. The canonical way
+ * to take a time of day in this system — never a native `<input type="time">`, which
+ * draws the *browser's* control (light in dark mode, its own glyph, its own idea of a
+ * locale) in the middle of one of our forms, and asks somebody to type `--:-- --`.
+ *
+ * Deliberately a fixed list rather than two spinners: the times these are used for are
+ * office hours and appointment slots, which land on the quarter hour, and a list can be
+ * read and clicked in one gesture. Pass `step={5}` where a finer time is real.
+ */
+declare function TimePicker({ value, onValueChange, placeholder, disabled, step, min, max, hour12, align, className, id, ...props }: TimePickerProps): React$1.JSX.Element;
+interface DateTimePickerProps {
+    /** The selected instant (controlled). */
+    value?: Date;
+    onValueChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    fromDate?: Date;
+    toDate?: Date;
+    step?: number;
+    hour12?: boolean;
+    /** The time a day picked before any time gets. */
+    defaultTime?: TimeValue;
+    /** date-fns format for the date half of the trigger label. */
+    displayFormat?: string;
+    align?: "start" | "center" | "end";
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+}
+/**
+ * A date *and* a time, in one popover: the calendar beside the list of times.
+ *
+ * One control and not two fields, because the two halves are one answer — "from when"
+ * — and two controls make it possible to submit half of it. Picking a day keeps the
+ * time already chosen (or `defaultTime`), and picking a time keeps the day, so the
+ * order they are pressed in does not matter.
+ */
+declare function DateTimePicker({ value, onValueChange, placeholder, disabled, fromDate, toDate, step, hour12, defaultTime, displayFormat, align, className, id, ...props }: DateTimePickerProps): React$1.JSX.Element;
+
+declare function Card({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFrame({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFrameHeader({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFrameTitle({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFrameDescription({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFrameFooter({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardHeader({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardTitle({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardDescription({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardAction({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardPanel({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function CardFooter({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+    /** Fades the leading/trailing edges of the viewport for a soft overflow. */
+    fade?: boolean;
+};
+type CarouselContextProps = {
+    carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+    api: ReturnType<typeof useEmblaCarousel>[1];
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+} & CarouselProps;
+declare function useCarousel(): CarouselContextProps;
+declare function Carousel({ orientation, opts, setApi, plugins, fade, className, children, ...props }: React$1.ComponentProps<"div"> & CarouselProps): React$1.JSX.Element;
+declare function CarouselContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CarouselItem({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): React$1.JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): React$1.JSX.Element;
+
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: "[data-theme=\"dark\"]";
+};
+type ChartConfig = {
+    [k in string]: {
+        label?: React$1.ReactNode;
+        icon?: React$1.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare function ChartContainer({ id, className, children, config, ...props }: React$1.ComponentProps<"div"> & {
+    config: ChartConfig;
+    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}): React$1.JSX.Element;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React$1.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+type TooltipPayloadItem = {
+    dataKey?: string | number;
+    name?: string | number;
+    value?: number | string;
+    color?: string;
+    fill?: string;
+    payload?: Record<string, unknown> & {
+        fill?: string;
+    };
+};
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: React$1.ComponentProps<"div"> & {
+    active?: boolean;
+    payload?: TooltipPayloadItem[];
+    indicator?: "line" | "dot" | "dashed";
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    label?: unknown;
+    labelFormatter?: (value: React$1.ReactNode, payload: TooltipPayloadItem[]) => React$1.ReactNode;
+    labelClassName?: string;
+    formatter?: (value: number | string, name: string | number, item: TooltipPayloadItem, index: number, payload: TooltipPayloadItem["payload"]) => React$1.ReactNode;
+    color?: string;
+    nameKey?: string;
+    labelKey?: string;
+}): React$1.JSX.Element | null;
+declare const ChartLegend: React$1.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React$1.ReactPortal | null>;
+type LegendPayloadItem = {
+    value?: string | number;
+    dataKey?: string | number;
+    color?: string;
+};
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React$1.ComponentProps<"div"> & {
+    hideIcon?: boolean;
+    payload?: LegendPayloadItem[];
+    verticalAlign?: "top" | "bottom" | "middle";
+    nameKey?: string;
+}): React$1.JSX.Element | null;
+
+/**
+ * Chat primitives for AI-assistant experiences: a column layout, an
+ * auto-scrolling message viewport, role-styled message bubbles, header chrome,
+ * an empty-state hero with suggestion prompts, tool activity chips/cards,
+ * a typing indicator, and a submit-on-Enter composer. Purely presentational —
+ * bring your own state.
+ */
+declare function Chat({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+/**
+ * Header chrome for a chat panel: avatar + title on the left, icon actions on
+ * the right. Compose `ChatHeaderAvatar`, `ChatHeaderTitle` and
+ * `ChatHeaderActions` inside.
+ */
+declare function ChatHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatHeaderAvatar({ className, children, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function ChatHeaderTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatHeaderActions({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatMessages({ autoScroll, className, children, ...props }: React$1.ComponentProps<"div"> & {
+    /** Keep the viewport pinned to the bottom while new messages stream in. */
+    autoScroll?: boolean;
+}): React$1.JSX.Element;
+/**
+ * Centered hero shown when the conversation is empty. Compose
+ * `ChatEmptyStateIcon`, `ChatEmptyStateTitle`, `ChatEmptyStateDescription`
+ * and `ChatSuggestions` inside.
+ */
+declare function ChatEmptyState({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatEmptyStateIcon({ className, children, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function ChatEmptyStateTitle({ className, ...props }: React$1.ComponentProps<"p">): React$1.JSX.Element;
+declare function ChatEmptyStateDescription({ className, ...props }: React$1.ComponentProps<"p">): React$1.JSX.Element;
+/** Vertical stack of `ChatSuggestion` prompts. */
+declare function ChatSuggestions({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+interface ChatSuggestionProps extends React$1.ComponentProps<"button"> {
+    /** Leading icon; defaults to a sparkle. */
+    icon?: React$1.ReactNode;
+    /** Position in the list — staggers the entrance animation. */
+    index?: number;
+}
+/**
+ * One tappable suggested prompt: icon chip + label, with an arrow that slides
+ * in on hover and a staggered fade-in entrance (via `index`).
+ */
+declare function ChatSuggestion({ className, children, icon, index, style, ...props }: ChatSuggestionProps): React$1.JSX.Element;
+declare const chatMessageVariants: (props?: ({
+    from?: "user" | "assistant" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ChatMessageProps extends React$1.ComponentProps<"div">, VariantProps<typeof chatMessageVariants> {
+}
+declare function ChatMessage({ className, from, ...props }: ChatMessageProps): React$1.JSX.Element;
+declare const chatMessageBubbleVariants: (props?: ({
+    from?: "user" | "assistant" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ChatMessageBubbleProps extends React$1.ComponentProps<"div">, VariantProps<typeof chatMessageBubbleVariants> {
+}
+declare function ChatMessageBubble({ className, from, ...props }: ChatMessageBubbleProps): React$1.JSX.Element;
+/**
+ * Small inline pill for tool activity ("Using X…", "X finished"). Pass the
+ * status icon (wrench, spinner, check) as `icon`.
+ */
+declare function ChatToolChip({ className, children, icon, ...props }: React$1.ComponentProps<"div"> & {
+    icon?: React$1.ReactNode;
+}): React$1.JSX.Element;
+/**
+ * Framed card for tool activity inside a conversation: running/finished tool
+ * calls, results, and write-action approval prompts. Compose with `Button`s
+ * in the `actions` area for approve/decline flows.
+ */
+declare function ChatToolCard({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatToolCardHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatToolCardActions({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ChatTypingIndicator({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+interface ChatInputProps extends Omit<React$1.ComponentProps<"textarea">, "onSubmit" | "value" | "onChange"> {
+    value: string;
+    onValueChange: (value: string) => void;
+    /** Called with the trimmed message when the user submits (Enter or button). */
+    onSubmit: (value: string) => void;
+    /** Disables both the textarea and the send button (e.g. while sending). */
+    disabled?: boolean;
+}
+/**
+ * Composer: a rounded card wrapping an auto-growing textarea and a round send
+ * button. Enter submits, Shift+Enter inserts a newline.
+ */
+declare function ChatInput({ className, disabled, onSubmit, onValueChange, placeholder, value, ...props }: ChatInputProps): React$1.JSX.Element;
+
+type ChatDividerVariant = "default" | "summary" | "unread";
+interface ChatDividerProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Centered label, e.g. "New messages", "You're caught up", "Earlier messages summarized". */
+    label?: React$1.ReactNode;
+    /** Optional leading icon (e.g. a summary or sparkle glyph). */
+    icon?: React$1.ReactNode;
+    /**
+     * - `default`  — neutral hairline with a muted label.
+     * - `summary`  — marks where a rolling summary folds older history.
+     * - `unread`   — the "new messages" baseline; accented so it stands out.
+     */
+    variant?: ChatDividerVariant;
+}
+/**
+ * A centered, labeled divider for the message stream: the point a rolling summary
+ * folds history (`summary`), the unread baseline (`unread`), or a plain date/section
+ * break (`default`). Pairs with the backend `AgentSummaryCheckpoint` and each
+ * participant's `joined_seq`/`last_read_seq`.
+ */
+declare function ChatDivider({ label, icon, variant, className, ...props }: ChatDividerProps): React$1.JSX.Element;
+
+declare const checkboxSizes: {
+    readonly sm: {
+        readonly box: "size-4.5 sm:size-4";
+        readonly icon: "size-3.5 sm:size-3";
+    };
+    readonly md: {
+        readonly box: "size-5";
+        readonly icon: "size-4";
+    };
+};
+interface CheckboxProps extends Checkbox$1.Root.Props {
+    /** Visual size of the checkbox. Defaults to "sm". */
+    size?: keyof typeof checkboxSizes;
+}
+declare function Checkbox({ className, size, ...props }: CheckboxProps): React$1.JSX.Element;
+
+declare function CheckboxGroup({ className, ...props }: CheckboxGroup$1.Props): React$1.JSX.Element;
+
+declare function Collapsible({ ...props }: Collapsible$1.Root.Props): React$1.JSX.Element;
+declare function CollapsibleTrigger({ className, ...props }: Collapsible$1.Trigger.Props): React$1.JSX.Element;
+declare function CollapsiblePanel({ className, ...props }: Collapsible$1.Panel.Props): React$1.JSX.Element;
+
+declare function useColorPicker(): react_aria_components.ColorPickerState;
+declare function ColorPickerProvider(props: React$1.ComponentProps<typeof ColorPicker$1>): React$1.JSX.Element;
+declare function ColorArea({ className, ...props }: React$1.ComponentProps<typeof ColorArea$1>): React$1.JSX.Element;
+declare function ColorThumb({ className, ...props }: React$1.ComponentProps<typeof ColorThumb$1>): React$1.JSX.Element;
+/**
+ * Hue, in HSB whatever the colour arrived as.
+ *
+ * `colorSpace` is not decoration here. A slider reads its channel off the picker's
+ * current colour, and `hue` is not a channel an RGB colour has — so a picker handed
+ * `"#8c1515"`, which is every picker handed a hex, threw `Unknown color channel: hue`
+ * and took the page down with it. Naming the space converts on the way in instead,
+ * which is what a hue slider means by "hue" in the first place.
+ *
+ * A caller may still override it; HSL is the other space with a hue.
+ */
+declare function ColorHueSlider(props: Omit<React$1.ComponentProps<typeof ColorSlider>, "channel">): React$1.JSX.Element;
+declare function ColorAlphaSlider(props: Omit<React$1.ComponentProps<typeof ColorSlider>, "channel">): React$1.JSX.Element;
+declare function ColorSwatch({ className, ...props }: React$1.ComponentProps<typeof ColorSwatch$1>): React$1.JSX.Element;
+declare function ColorValueInput({ className, ...props }: Omit<React$1.ComponentProps<typeof ColorField>, "children">): React$1.JSX.Element;
+/**
+ * A grid of colours somebody can pick from, and optionally add to.
+ *
+ * `onAdd` is what makes it "saved colours" rather than a fixed palette: the plus tile
+ * only appears when there is somewhere for the current colour to go.
+ */
+declare function ColorSavedColors({ className, colors, onSelect, onAdd, size, ...props }: Omit<React$1.ComponentProps<typeof ColorSwatchPicker>, "onChange" | "children"> & {
+    colors: string[];
+    onSelect?: (color: string) => void;
+    onAdd?: () => void;
+    size?: "sm" | "md";
+}): React$1.JSX.Element;
+/**
+ * Pick a colour from anywhere on the screen.
+ *
+ * Renders nothing where the browser has no `EyeDropper` — Firefox and Safari do not,
+ * and a button that silently does nothing is worse than one that is not offered. The
+ * check runs in an effect rather than during render, because `window` is not there on
+ * the server and a hydration mismatch over a button is still a hydration mismatch.
+ */
+declare function ColorEyeDropper({ className, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element | null;
+/** The current colour as a swatch — reads state, so it needs no props. */
+declare function ColorPreview({ className }: {
+    className?: string;
+}): React$1.JSX.Element;
+/**
+ * The whole picker, already composed — plane, hue, alpha, eyedropper and a hex box.
+ *
+ * What a screen reaches for when it just wants "let them choose a colour". Anything
+ * more specific composes the parts above instead.
+ */
+declare function ColorPickerPanel({ className, withAlpha, savedColors, onSaveColor, ...props }: Omit<React$1.ComponentProps<typeof ColorPicker$1>, "children"> & {
+    /** Wraps the panel, not the provider — the provider renders no element. */
+    className?: string;
+    withAlpha?: boolean;
+    savedColors?: string[];
+    onSaveColor?: () => void;
+}): React$1.JSX.Element;
+/**
+ * The compound namespace.
+ *
+ * Exported as one object rather than a dozen loose names because the parts are only
+ * meaningful together, and `ColorPicker.Area` says which state it reads in a way that
+ * `ColorArea` does not.
+ */
+declare const ColorPicker: typeof ColorPickerPanel & {
+    Provider: typeof ColorPickerProvider;
+    Area: typeof ColorArea;
+    Thumb: typeof ColorThumb;
+    HueSlider: typeof ColorHueSlider;
+    AlphaSlider: typeof ColorAlphaSlider;
+    Swatch: typeof ColorSwatch;
+    Preview: typeof ColorPreview;
+    ValueInput: typeof ColorValueInput;
+    SavedColors: typeof ColorSavedColors;
+    EyeDropper: typeof ColorEyeDropper;
+};
+
+declare function Combobox<ItemValue, Multiple extends boolean | undefined = false>(props: Combobox$1.Root.Props<ItemValue, Multiple>): React$1.JSX.Element;
+declare function ComboboxInput({ className, showTrigger, showClear, startAddon, size, ...props }: Omit<Combobox$1.Input.Props, "size"> & {
+    showTrigger?: boolean;
+    showClear?: boolean;
+    startAddon?: React$1.ReactNode;
+    size?: "sm" | "default" | "lg" | number;
+    ref?: React$1.Ref<HTMLInputElement>;
+}): React$1.JSX.Element;
+declare function ComboboxTrigger({ className, ...props }: Combobox$1.Trigger.Props): React$1.JSX.Element;
+declare function ComboboxPopup({ className, children, sideOffset, ...props }: Combobox$1.Popup.Props & {
+    sideOffset?: number;
+}): React$1.JSX.Element;
+declare function ComboboxItem({ className, children, ...props }: Combobox$1.Item.Props): React$1.JSX.Element;
+declare function ComboboxSeparator({ className, ...props }: Combobox$1.Separator.Props): React$1.JSX.Element;
+declare function ComboboxGroup({ className, ...props }: Combobox$1.Group.Props): React$1.JSX.Element;
+declare function ComboboxGroupLabel({ className, ...props }: Combobox$1.GroupLabel.Props): React$1.JSX.Element;
+declare function ComboboxEmpty({ className, ...props }: Combobox$1.Empty.Props): React$1.JSX.Element;
+declare function ComboboxRow({ className, ...props }: Combobox$1.Row.Props): React$1.JSX.Element;
+declare function ComboboxValue({ ...props }: Combobox$1.Value.Props): React$1.JSX.Element;
+declare function ComboboxList({ className, ...props }: Combobox$1.List.Props): React$1.JSX.Element;
+declare function ComboboxClear({ className, ...props }: Combobox$1.Clear.Props): React$1.JSX.Element;
+declare function ComboboxStatus({ className, ...props }: Combobox$1.Status.Props): React$1.JSX.Element;
+declare function ComboboxCollection(props: Combobox$1.Collection.Props): React$1.JSX.Element;
+declare function ComboboxChips({ className, children, startAddon, ...props }: Combobox$1.Chips.Props & {
+    startAddon?: React$1.ReactNode;
+}): React$1.JSX.Element;
+declare function ComboboxChip({ children, ...props }: Combobox$1.Chip.Props): React$1.JSX.Element;
+declare const useComboboxFilter: typeof Combobox$1.useFilter;
+
+declare const CommandDialog: typeof Dialog$1.Root;
+declare const CommandCreateHandle: typeof Dialog$1.createHandle;
+declare function CommandDialogTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
+declare function CommandDialogPopup({ className, children, ...props }: Dialog$1.Popup.Props): React$1.JSX.Element;
+declare function Command({ autoHighlight, keepHighlight, ...props }: React$1.ComponentProps<typeof Autocomplete>): React$1.JSX.Element;
+declare function CommandInput({ className, placeholder, ...props }: React$1.ComponentProps<typeof AutocompleteInput>): React$1.JSX.Element;
+declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof AutocompleteList>): React$1.JSX.Element;
+declare function CommandEmpty({ className, ...props }: React$1.ComponentProps<typeof AutocompleteEmpty>): React$1.JSX.Element;
+declare function CommandPanel({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof AutocompleteGroup>): React$1.JSX.Element;
+declare function CommandGroupLabel({ className, ...props }: React$1.ComponentProps<typeof AutocompleteGroupLabel>): React$1.JSX.Element;
+declare function CommandCollection({ ...props }: React$1.ComponentProps<typeof AutocompleteCollection>): React$1.JSX.Element;
+declare function CommandItem({ className, ...props }: React$1.ComponentProps<typeof AutocompleteItem>): React$1.JSX.Element;
+declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof AutocompleteSeparator>): React$1.JSX.Element;
+declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
+declare function CommandFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+/** The brand celebration palette — soft violet / pink / peach / cream. */
+declare const CONFETTI_COLORS: readonly ["#a786ff", "#fd8bbc", "#eca184", "#f8deb1"];
+interface SideCannonsOptions {
+    /** How long the cannons keep firing, in ms (default 3000). */
+    durationMs?: number;
+    /** Confetti colors (default {@link CONFETTI_COLORS}). */
+    colors?: readonly string[];
+    /** Particles emitted per side per frame (default 2). */
+    particleCount?: number;
+    /** z-index of the confetti canvas (default 100). */
+    zIndex?: number;
+}
+/**
+ * Fires confetti from the left and right edges of the viewport for a few
+ * seconds — the "side cannons" celebration. Purely imperative, so it can be
+ * triggered from an effect (e.g. the first time a page loads) without rendering
+ * anything. No-ops on the server and when the user prefers reduced motion.
+ *
+ * @example
+ * useEffect(() => { sideCannons(); }, []);
+ */
+declare function sideCannons(options?: SideCannonsOptions): void;
+type ConfettiApi = {
+    /** Fire the confetti instance, merging `options` over the component's. */
+    fire: (options?: Options) => void;
+};
+type ConfettiRef = ConfettiApi | null;
+type ConfettiProps = React$1.ComponentPropsWithRef<"canvas"> & {
+    /** Per-shot options merged into every `fire()` call. */
+    options?: Options;
+    /** Global options passed to `confetti.create` (resize / worker). */
+    globalOptions?: GlobalOptions;
+    /** Skip the automatic fire on mount — drive it via the ref instead. */
+    manualstart?: boolean;
+    children?: ReactNode;
+};
+declare const Confetti: React$1.ForwardRefExoticComponent<Omit<ConfettiProps, "ref"> & React$1.RefAttributes<ConfettiRef>>;
+/** Access the nearest {@link Confetti}'s imperative `fire()` from a child. */
+declare function useConfetti(): ConfettiApi;
+interface ConfettiButtonProps extends ButtonProps {
+    /** Confetti options; origin defaults to the button's center. */
+    options?: Options & GlobalOptions & {
+        canvas?: HTMLCanvasElement;
+    };
+}
+/**
+ * A {@link Button} that bursts confetti from its own center on click. Handy for
+ * "Claim", "Done", or other one-off celebratory actions.
+ */
+declare function ConfettiButtonComponent({ options, children, onClick, ...props }: ConfettiButtonProps): React$1.JSX.Element;
+declare namespace ConfettiButtonComponent {
+    var displayName: string;
+}
+declare const ConfettiButton: typeof ConfettiButtonComponent;
+
+type ContextMeterState = "ok" | "warn" | "summarizing" | "full";
+interface ContextMeterProps extends Omit<React$1.SVGProps<SVGSVGElement>, "children"> {
+    /** Tokens currently in context. Used with `budget` when `pct` is not given. */
+    used?: number;
+    /** The model's context budget in tokens. */
+    budget?: number;
+    /** Fill fraction 0..1. Takes precedence over `used`/`budget` when provided. */
+    pct?: number;
+    /** Visual state; derived from the thresholds below when omitted. */
+    state?: ContextMeterState;
+    /** Threshold fractions — mirror the backend `config.context` values. */
+    warnAt?: number;
+    summarizeAt?: number;
+    lockAt?: number;
+    /** Diameter in px. */
+    size?: number;
+    /** Ring thickness in px. */
+    strokeWidth?: number;
+    /** Render the rounded percentage in the ring's center. */
+    showLabel?: boolean;
+    className?: string;
+}
+/**
+ * A compact radial gauge for how full an agent conversation's context window is.
+ *
+ * Feed it the backend `context_meter` payload (`pct`/`state` + thresholds) or a
+ * raw `used`/`budget` pair. The ring colors shift as the conversation approaches
+ * the summarize (folds older messages) and lock (must start a new chat) points,
+ * mirroring Claude Code's context indicator. Theme-aware and accessible
+ * (`role="meter"`).
+ */
+declare function ContextMeter({ used, budget, pct, state, warnAt, summarizeAt, lockAt, size, strokeWidth, showLabel, className, ...props }: ContextMeterProps): React$1.JSX.Element;
+
+type CreditCardType = "transparent" | "transparent-gradient" | "brand-dark" | "brand-light" | "gray-dark" | "gray-light" | "transparent-strip" | "gray-strip" | "gradient-strip" | "salmon-strip" | "gray-strip-vertical" | "gradient-strip-vertical" | "salmon-strip-vertical";
+interface CreditCardProps extends React$1.ComponentProps<"div"> {
+    type?: CreditCardType;
+    company?: React$1.ReactNode;
+    cardNumber?: string;
+    cardHolder?: string;
+    cardExpiration?: string;
+    /** Rendered width in px — the height follows the 316 × 190 aspect ratio. */
+    width?: number;
+}
+declare function CreditCard({ className, style, type, company, cardNumber, cardHolder, cardExpiration, width, ...props }: CreditCardProps): React$1.JSX.Element;
+
+interface DataTablePagedColumn {
+    key: string;
+    label?: string;
+}
+interface DataTablePagedProps {
+    /** Columns to render. Pass `label` to override the header text. */
+    columns: DataTablePagedColumn[];
+    /** Row objects; values are rendered with `String(...)` unless a ReactNode. */
+    rows: Record<string, unknown>[];
+    pageSize?: number;
+    /** Show the client-side search box (filters across all columns). */
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyLabel?: string;
+    /**
+     * Total row count when `rows` is only one page of a larger server-side set —
+     * shown as "n of total" in the footer.
+     */
+    totalCount?: number;
+    className?: string;
+}
+/**
+ * Client-side paginated (and optionally searchable) data table. Designed for
+ * result sets a chat agent or API returns: pass plain row objects and column
+ * keys, get a themed table with pagination that never renders huge lists.
+ */
+declare function DataTablePaged({ className, columns, emptyLabel, pageSize, rows, searchable, searchPlaceholder, totalCount, }: DataTablePagedProps): React$1.JSX.Element;
+
+declare function Drawer(props: React$1.ComponentProps<typeof Drawer$1.Root>): React$1.JSX.Element;
+declare function DrawerTrigger(props: React$1.ComponentProps<typeof Drawer$1.Trigger>): React$1.JSX.Element;
+declare function DrawerPortal(props: React$1.ComponentProps<typeof Drawer$1.Portal>): React$1.JSX.Element;
+declare function DrawerClose(props: React$1.ComponentProps<typeof Drawer$1.Close>): React$1.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Overlay>): React$1.JSX.Element;
+declare function DrawerContent({ className, children, ...props }: React$1.ComponentProps<typeof Drawer$1.Content>): React$1.JSX.Element;
+declare function DrawerHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Title>): React$1.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Description>): React$1.JSX.Element;
+
+declare function ContextMenu({ ...props }: ContextMenu$1.Root.Props): React$1.JSX.Element;
+declare function ContextMenuPortal({ ...props }: ContextMenu$1.Portal.Props): React$1.JSX.Element;
+declare function ContextMenuTrigger({ className, ...props }: ContextMenu$1.Trigger.Props): React$1.JSX.Element;
+declare function ContextMenuContent({ className, align, alignOffset, side, sideOffset, ...props }: ContextMenu$1.Popup.Props & Pick<ContextMenu$1.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React$1.JSX.Element;
+declare function ContextMenuGroup({ ...props }: ContextMenu$1.Group.Props): React$1.JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: ContextMenu$1.GroupLabel.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: ContextMenu$1.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React$1.JSX.Element;
+declare function ContextMenuSub({ ...props }: ContextMenu$1.SubmenuRoot.Props): React$1.JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: ContextMenu$1.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function ContextMenuSubContent({ ...props }: React$1.ComponentProps<typeof ContextMenuContent>): React$1.JSX.Element;
+declare function ContextMenuCheckboxItem({ className, children, checked, inset, ...props }: ContextMenu$1.CheckboxItem.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: ContextMenu$1.RadioGroup.Props): React$1.JSX.Element;
+declare function ContextMenuRadioItem({ className, children, inset, ...props }: ContextMenu$1.RadioItem.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: ContextMenu$1.Separator.Props): React$1.JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+
+declare const DialogCreateHandle: typeof Dialog$1.createHandle;
+declare const Dialog: typeof Dialog$1.Root;
+declare const DialogPortal: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.DialogPortalProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function DialogTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
+declare function DialogClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
+declare function DialogBackdrop({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
+declare function DialogViewport({ className, ...props }: Dialog$1.Viewport.Props): React$1.JSX.Element;
+declare function DialogPopup({ className, children, showCloseButton, bottomStickOnMobile, ...props }: Dialog$1.Popup.Props & {
+    showCloseButton?: boolean;
+    bottomStickOnMobile?: boolean;
+}): React$1.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare function DialogFooter({ className, variant, ...props }: React.ComponentProps<"div"> & {
+    variant?: "default" | "bare";
+}): React$1.JSX.Element;
+declare function DialogTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
+declare function DialogDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
+declare function DialogPanel({ className, scrollFade, ...props }: React.ComponentProps<"div"> & {
+    scrollFade?: boolean;
+}): React$1.JSX.Element;
+
+declare function Empty({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): React$1.JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"p">): React$1.JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+
+declare const fabVariants: (props?: ({
+    position?: "bottom-right" | "bottom-left" | "top-right" | "top-left" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface FabProps extends ButtonProps {
+    position?: VariantProps<typeof fabVariants>["position"];
+}
+/**
+ * Floating action button — a fixed, round icon button used to summon overlays
+ * such as chat widgets. Composes `Button`, so all button variants/sizes apply.
+ */
+declare function Fab({ className, position, size, ...props }: FabProps): React$1.JSX.Element;
+
+declare const featuredIconVariants: (props?: ({
+    color?: "error" | "success" | "warning" | "gray" | "brand" | null | undefined;
+    size?: "lg" | "sm" | "xl" | "md" | null | undefined;
+    theme?: "dark" | "light" | "outline" | "modern" | "modern-neue" | "gradient" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type FeaturedIconTheme = NonNullable<VariantProps<typeof featuredIconVariants>["theme"]>;
+type FeaturedIconColor = NonNullable<VariantProps<typeof featuredIconVariants>["color"]>;
+interface FeaturedIconProps extends Omit<React$1.ComponentProps<"span">, "color"> {
+    theme?: FeaturedIconTheme;
+    color?: FeaturedIconColor;
+    size?: VariantProps<typeof featuredIconVariants>["size"];
+    /** Icon component rendered inside (e.g. a lucide icon). Or pass children. */
+    icon?: React$1.ElementType;
+}
+declare function FeaturedIcon({ className, theme, color, size, icon: Icon, children, ...props }: FeaturedIconProps): React$1.JSX.Element;
+
+declare function Field({ className, ...props }: Field$1.Root.Props): React$1.JSX.Element;
+declare function FieldLabel({ className, ...props }: Field$1.Label.Props): React$1.JSX.Element;
+declare function FieldItem({ className, ...props }: Field$1.Item.Props): React$1.JSX.Element;
+declare function FieldDescription({ className, ...props }: Field$1.Description.Props): React$1.JSX.Element;
+declare function FieldError({ className, ...props }: Field$1.Error.Props): React$1.JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare const FieldControl: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.FieldControlProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare const FieldValidity: React$1.FC<_base_ui_react.FieldValidityProps>;
+
+declare function Fieldset({ className, ...props }: Fieldset$1.Root.Props): React$1.JSX.Element;
+declare function FieldsetLegend({ className, ...props }: Fieldset$1.Legend.Props): React$1.JSX.Element;
+
+declare function Form({ className, ...props }: Form$1.Props): React$1.JSX.Element;
+
+declare function Frame({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function FramePanel({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function FrameHeader({ className, ...props }: React$1.ComponentProps<"header">): React$1.JSX.Element;
+declare function FrameTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function FrameDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function FrameFooter({ className, ...props }: React$1.ComponentProps<"footer">): React$1.JSX.Element;
+
+interface ErrorOrEmptyStateProps extends Omit<React__default.ComponentProps<"div">, "title"> {
+    title?: React__default.ReactNode;
+    description?: React__default.ReactNode;
+    actions?: React__default.ReactNode;
+    media?: React__default.ReactNode;
+    mediaVariant?: "icon" | "default";
+    compact?: boolean;
+}
+declare function ErrorOrEmptyState({ title, description, actions, className, media, mediaVariant, compact, ...props }: ErrorOrEmptyStateProps): React__default.JSX.Element;
+type ErrorTemplateProps = Omit<ErrorOrEmptyStateProps, "image" | "title" | "description"> & {
+    mediaClassName?: string;
+};
+declare function NotFoundErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+declare function UnauthorizedErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+declare function ForbiddenErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+declare function InternalServerErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+declare function OfflineErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+declare function GeneralErrorState({ mediaClassName, ...props }: ErrorTemplateProps): React__default.JSX.Element;
+
+declare function Separator({ className, orientation, ...props }: Separator$1.Props): React$1.JSX.Element;
+
+declare const groupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Group({ className, orientation, children, ...props }: {
+    className?: string;
+    orientation?: VariantProps<typeof groupVariants>["orientation"];
+    children: React$1.ReactNode;
+} & React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function GroupText({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function GroupSeparator({ className, orientation, ...props }: {
+    className?: string;
+} & React$1.ComponentProps<typeof Separator>): React$1.JSX.Element;
+
+declare const TooltipCreateHandle: typeof Tooltip$1.createHandle;
+declare const TooltipProvider: React$1.FC<_base_ui_react.TooltipProviderProps>;
+declare const Tooltip: typeof Tooltip$1.Root;
+declare function TooltipTrigger(props: Tooltip$1.Trigger.Props): React$1.JSX.Element;
+declare function TooltipTitle({ className, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): React$1.JSX.Element;
+declare function TooltipDescription({ className, ...props }: React$1.HTMLAttributes<HTMLParagraphElement>): React$1.JSX.Element;
+declare function TooltipPopup({ className, align, sideOffset, side, arrow, children, ...props }: Tooltip$1.Popup.Props & {
+    align?: Tooltip$1.Positioner.Props["align"];
+    side?: Tooltip$1.Positioner.Props["side"];
+    sideOffset?: Tooltip$1.Positioner.Props["sideOffset"];
+    arrow?: boolean;
+}): React$1.JSX.Element;
+
+interface HelpTipProps {
+    /** The help text shown in the tooltip. */
+    children?: React$1.ReactNode;
+    /** Optional bold heading rendered above the description text. */
+    title?: React$1.ReactNode;
+    /** Which side of the trigger the tooltip opens on. Default "top". */
+    side?: React$1.ComponentProps<typeof TooltipPopup>["side"];
+    /** Alignment of the tooltip along the trigger. Default "center". */
+    align?: React$1.ComponentProps<typeof TooltipPopup>["align"];
+    /** Accessible label for the icon button. Default "More information". */
+    label?: string;
+    /** Hover / focus open delay in ms. Default 150. */
+    delay?: number;
+    /** Icon size in px. Default 16. */
+    iconSize?: number;
+    /** Extra classes for the trigger button. */
+    className?: string;
+    /** Extra classes for the tooltip popup. */
+    popupClassName?: string;
+    /** Render the little arrow pointing at the icon. Default false. */
+    arrow?: boolean;
+}
+/**
+ * A small "?" help affordance: an unobtrusive circular icon that reveals
+ * supporting text in a tooltip on hover / focus. Use it next to a label,
+ * heading, or field when a short explanation would help but shouldn't take up
+ * permanent space.
+ *
+ * ```tsx
+ * <span className="flex items-center gap-1.5">
+ *   My Events
+ *   <HelpTip>Every event Country Club has surfaced for you…</HelpTip>
+ * </span>
+ * ```
+ */
+declare function HelpTip({ children, title, side, align, label, delay, iconSize, className, popupClassName, arrow, }: HelpTipProps): React$1.JSX.Element;
+
+declare const HorizontalScrollFader: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const HorizontalScrollFaderContent: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const HorizontalScrollFaderLeftScroller: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+declare const HorizontalScrollFaderRightScroller: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+type TextareaProps = React$1.ComponentProps<"textarea"> & {
+    size?: "sm" | "default" | "lg" | number;
+    unstyled?: boolean;
+};
+declare function Textarea({ className, size, unstyled, ...props }: TextareaProps): React$1.JSX.Element;
+
+declare function InputGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React$1.JSX.Element;
+declare function InputGroupText({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function InputGroupInput({ className, ...props }: InputProps): React$1.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: TextareaProps): React$1.JSX.Element;
+
+type InputOTPProps = React$1.ComponentProps<typeof OTPInput>;
+declare function InputOTP({ className, containerClassName, inputMode, pattern, ...props }: InputOTPProps): React$1.JSX.Element;
+declare function InputOTPGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare const inputOTPSlotVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function InputOTPSlot({ index, className, size, ...props }: React$1.ComponentProps<"div"> & {
+    index: number;
+} & VariantProps<typeof inputOTPSlotVariants>): React$1.JSX.Element;
+declare function InputOTPSeparator({ ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+declare function ItemGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ItemSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): React$1.JSX.Element;
+declare const itemVariants: (props?: ({
+    size?: "default" | "sm" | null | undefined;
+    variant?: "default" | "outline" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ItemProps extends useRender.ComponentProps<"div"> {
+    variant?: VariantProps<typeof itemVariants>["variant"];
+    size?: VariantProps<typeof itemVariants>["size"];
+}
+declare function Item({ className, variant, size, render, ...props }: ItemProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare const itemMediaVariants: (props?: ({
+    variant?: "image" | "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function ItemMedia({ className, variant, ...props }: React$1.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>): React$1.JSX.Element;
+declare function ItemContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ItemTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ItemDescription({ className, ...props }: React$1.ComponentProps<"p">): React$1.JSX.Element;
+declare function ItemActions({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ItemHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function ItemFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+declare function Kbd({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
+declare function KbdGroup({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
+
+declare function Label({ className, render, ...props }: useRender.ComponentProps<"label">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+interface MarkdownProps {
+    /** The markdown source to render. */
+    children: string;
+    className?: string;
+}
+/**
+ * Markdown renderer for assistant/chat content (GitHub-flavored markdown).
+ * Raw HTML in the source is NOT rendered — output is limited to markdown
+ * elements, which keeps untrusted model output safe to display.
+ */
+declare function Markdown({ children, className }: MarkdownProps): React$1.JSX.Element;
+
+declare const MenuCreateHandle: typeof Menu$1.createHandle;
+declare const Menu: typeof Menu$1.Root;
+declare const MenuPortal: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.ContextMenuPortalProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function MenuTrigger(props: Menu$1.Trigger.Props): React$1.JSX.Element;
+declare function MenuPopup({ children, className, sideOffset, align, alignOffset, side, ...props }: Menu$1.Popup.Props & {
+    align?: Menu$1.Positioner.Props["align"];
+    sideOffset?: Menu$1.Positioner.Props["sideOffset"];
+    alignOffset?: Menu$1.Positioner.Props["alignOffset"];
+    side?: Menu$1.Positioner.Props["side"];
+}): React$1.JSX.Element;
+declare function MenuGroup(props: Menu$1.Group.Props): React$1.JSX.Element;
+declare function MenuItem({ className, inset, variant, ...props }: Menu$1.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React$1.JSX.Element;
+declare function MenuCheckboxItem({ className, children, checked, variant, ...props }: Menu$1.CheckboxItem.Props & {
+    variant?: "default" | "switch";
+}): React$1.JSX.Element;
+declare function MenuRadioGroup(props: Menu$1.RadioGroup.Props): React$1.JSX.Element;
+declare function MenuRadioItem({ className, children, ...props }: Menu$1.RadioItem.Props): React$1.JSX.Element;
+declare function MenuGroupLabel({ className, inset, ...props }: Menu$1.GroupLabel.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function MenuSeparator({ className, ...props }: Menu$1.Separator.Props): React$1.JSX.Element;
+declare function MenuShortcut({ className, ...props }: React$1.ComponentProps<"kbd">): React$1.JSX.Element;
+declare function MenuSub(props: Menu$1.SubmenuRoot.Props): React$1.JSX.Element;
+declare function MenuSubTrigger({ className, inset, children, ...props }: Menu$1.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React$1.JSX.Element;
+declare function MenuSubPopup({ className, sideOffset, alignOffset, align, ...props }: Menu$1.Popup.Props & {
+    align?: Menu$1.Positioner.Props["align"];
+    sideOffset?: Menu$1.Positioner.Props["sideOffset"];
+    alignOffset?: Menu$1.Positioner.Props["alignOffset"];
+}): React$1.JSX.Element;
+
+declare function Menubar({ className, ...props }: MenubarProps): React$1.JSX.Element;
+declare function MenubarMenu(props: Menu$1.Root.Props): React$1.JSX.Element;
+declare function MenubarTrigger({ className, ...props }: Menu$1.Trigger.Props): React$1.JSX.Element;
+declare function MenubarContent({ align, sideOffset, ...props }: React$1.ComponentProps<typeof MenuPopup>): React$1.JSX.Element;
+
+declare function Meter({ className, children, ...props }: Meter$1.Root.Props): React$1.JSX.Element;
+declare function MeterLabel({ className, ...props }: Meter$1.Label.Props): React$1.JSX.Element;
+declare function MeterTrack({ className, ...props }: Meter$1.Track.Props): React$1.JSX.Element;
+declare function MeterIndicator({ className, ...props }: Meter$1.Indicator.Props): React$1.JSX.Element;
+declare function MeterValue({ className, ...props }: Meter$1.Value.Props): React$1.JSX.Element;
+
+interface MultiSelectItem {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface MultiSelectProps {
+    items: MultiSelectItem[];
+    /** Controlled selected values. */
+    value?: string[];
+    /** Uncontrolled initial selected values. */
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+    size?: "sm" | "default" | "lg";
+    placeholder?: React$1.ReactNode;
+    /** Extra context rendered next to the selected count, e.g. "of 12 users". */
+    supportingText?: React$1.ReactNode;
+    /** Formats the trigger text from the selected count. Defaults to `${count} selected`. */
+    selectedCountFormatter?: (count: number) => React$1.ReactNode;
+    showSearch?: boolean;
+    searchPlaceholder?: string;
+    showFooter?: boolean;
+    selectAllLabel?: React$1.ReactNode;
+    resetLabel?: React$1.ReactNode;
+    emptyStateTitle?: React$1.ReactNode;
+    emptyStateDescription?: React$1.ReactNode;
+    disabled?: boolean;
+    name?: string;
+    required?: boolean;
+    id?: string;
+    /** Trigger class name. */
+    className?: string;
+    popupClassName?: string;
+    sideOffset?: Select$1.Positioner.Props["sideOffset"];
+}
+declare function MultiSelect({ items, value: valueProp, defaultValue, onValueChange, size, placeholder, supportingText, selectedCountFormatter, showSearch, searchPlaceholder, showFooter, selectAllLabel, resetLabel, emptyStateTitle, emptyStateDescription, disabled, name, required, id, className, popupClassName, sideOffset, }: MultiSelectProps): React$1.JSX.Element;
+
+declare function NavigationMenu({ className, children, ...props }: NavigationMenu$1.Root.Props): React$1.JSX.Element;
+declare function NavigationMenuList({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.List>): React$1.JSX.Element;
+declare function NavigationMenuItem({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Item>): React$1.JSX.Element;
+declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare function NavigationMenuTrigger({ className, children, ...props }: NavigationMenu$1.Trigger.Props): React$1.JSX.Element;
+declare function NavigationMenuContent({ className, ...props }: NavigationMenu$1.Content.Props): React$1.JSX.Element;
+declare function NavigationMenuLink({ className, ...props }: NavigationMenu$1.Link.Props): React$1.JSX.Element;
+
+declare function NumberField({ id, className, size, ...props }: NumberField$1.Root.Props & {
+    size?: "sm" | "default" | "lg";
+}): React$1.JSX.Element;
+declare function NumberFieldGroup({ className, ...props }: NumberField$1.Group.Props): React$1.JSX.Element;
+declare function NumberFieldDecrement({ className, ...props }: NumberField$1.Decrement.Props): React$1.JSX.Element;
+declare function NumberFieldIncrement({ className, ...props }: NumberField$1.Increment.Props): React$1.JSX.Element;
+declare function NumberFieldInput({ className, ...props }: NumberField$1.Input.Props): React$1.JSX.Element;
+declare function NumberFieldScrubArea({ className, label, ...props }: NumberField$1.ScrubArea.Props & {
+    label: string;
+}): React$1.JSX.Element;
+
+declare function Pagination({ className, ...props }: React$1.ComponentProps<"nav">): React$1.JSX.Element;
+declare function PaginationContent({ className, ...props }: React$1.ComponentProps<"ul">): React$1.JSX.Element;
+declare function PaginationItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+    disabled?: boolean;
+    size?: React$1.ComponentProps<typeof Button>["size"];
+} & useRender.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, disabled, size, render, ...props }: PaginationLinkProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function PaginationPrevious({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+declare function PaginationNext({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): React$1.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+
+declare function PaginationControls(props: {
+    page: number;
+    pageCount: number;
+    renderPageLink: (page: number) => PaginationLinkProps["render"];
+}): React$1.JSX.Element | null;
+
+declare const PopoverCreateHandle: typeof Popover$1.createHandle;
+declare const Popover: typeof Popover$1.Root;
+declare function PopoverTrigger({ className, children, ...props }: Popover$1.Trigger.Props): React$1.JSX.Element;
+declare function PopoverPopup({ children, className, side, align, sideOffset, alignOffset, tooltipStyle, anchor, ...props }: Popover$1.Popup.Props & {
+    side?: Popover$1.Positioner.Props["side"];
+    align?: Popover$1.Positioner.Props["align"];
+    sideOffset?: Popover$1.Positioner.Props["sideOffset"];
+    alignOffset?: Popover$1.Positioner.Props["alignOffset"];
+    tooltipStyle?: boolean;
+    anchor?: Popover$1.Positioner.Props["anchor"];
+}): React$1.JSX.Element;
+declare function PopoverClose({ ...props }: Popover$1.Close.Props): React$1.JSX.Element;
+declare function PopoverTitle({ className, ...props }: Popover$1.Title.Props): React$1.JSX.Element;
+declare function PopoverDescription({ className, ...props }: Popover$1.Description.Props): React$1.JSX.Element;
+
+declare const PreviewCard: typeof PreviewCard$1.Root;
+declare function PreviewCardTrigger({ ...props }: PreviewCard$1.Trigger.Props): React$1.JSX.Element;
+declare function PreviewCardPopup({ className, children, align, sideOffset, ...props }: PreviewCard$1.Popup.Props & {
+    align?: PreviewCard$1.Positioner.Props["align"];
+    sideOffset?: PreviewCard$1.Positioner.Props["sideOffset"];
+}): React$1.JSX.Element;
+
+declare function Progress({ className, children, ...props }: Progress$1.Root.Props): React$1.JSX.Element;
+declare function ProgressLabel({ className, ...props }: Progress$1.Label.Props): React$1.JSX.Element;
+declare function ProgressTrack({ className, ...props }: Progress$1.Track.Props): React$1.JSX.Element;
+declare function ProgressIndicator({ className, ...props }: Progress$1.Indicator.Props): React$1.JSX.Element;
+declare function ProgressValue({ className, ...props }: Progress$1.Value.Props): React$1.JSX.Element;
+/**
+ * A tooltip-like value bubble that floats above or below the track,
+ * following the progress percentage. Render it next to a ProgressTrack
+ * inside a `relative` wrapper.
+ */
+declare function ProgressFloatingValue({ className, side, value, max, children, style, ...props }: React$1.ComponentProps<"div"> & {
+    side?: "top" | "bottom";
+    value: number;
+    max?: number;
+}): React$1.JSX.Element;
+declare const progressCircleSizes: {
+    readonly sm: {
+        readonly label: "text-[0.625rem]";
+        readonly px: 64;
+        readonly stroke: 6;
+        readonly value: "text-sm";
+    };
+    readonly md: {
+        readonly label: "text-xs";
+        readonly px: 120;
+        readonly stroke: 10;
+        readonly value: "text-2xl";
+    };
+    readonly lg: {
+        readonly label: "text-sm";
+        readonly px: 160;
+        readonly stroke: 12;
+        readonly value: "text-3xl";
+    };
+};
+type ProgressCircleSize = keyof typeof progressCircleSizes;
+interface ProgressCircleProps extends Progress$1.Root.Props {
+    size?: ProgressCircleSize;
+    /** A short caption rendered above the value, inside the circle. */
+    label?: React$1.ReactNode;
+    /** Hide the centered percentage. */
+    showValue?: boolean;
+}
+/** A circular progress ring with an optional centered value and label. */
+declare function ProgressCircle({ className, size, label, showValue, value, max, ...props }: ProgressCircleProps): React$1.JSX.Element;
+/** A half-circle (gauge) progress arc with an optional value and label. */
+declare function ProgressHalfCircle({ className, size, label, showValue, value, max, ...props }: ProgressCircleProps): React$1.JSX.Element;
+
+declare const qrCodeVariants: (props?: ({
+    size?: "lg" | "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface QRCodeProps extends Omit<React$1.ComponentProps<"div">, "children">, VariantProps<typeof qrCodeVariants> {
+    /** The text or URL encoded in the QR code. */
+    value: string;
+    /**
+     * Extra qr-code-styling options merged over the themed defaults — e.g. a
+     * center image, custom dot colors or shapes. See the qr-code-styling docs.
+     */
+    options?: Partial<Options$1>;
+}
+/**
+ * A themeable QR code rendered with qr-code-styling. Dots follow the
+ * foreground color (and re-tint when the theme flips) unless overridden
+ * via `options`.
+ */
+declare function QRCode({ className, size, value, options, ...props }: QRCodeProps): React$1.JSX.Element;
+/**
+ * An animated scan-line overlay for a QR code. Render it inside a `relative`
+ * wrapper around the `<QRCode />`.
+ */
+declare function QRCodeGradientScan({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+declare function RadioGroup({ className, ...props }: RadioGroup$1.Props): React$1.JSX.Element;
+declare const radioSizes: {
+    readonly sm: {
+        readonly box: "size-4.5 sm:size-4";
+        readonly indicator: "size-4.5 sm:size-4";
+        readonly dot: "before:size-2 sm:before:size-1.5";
+        readonly check: "size-3.5 sm:size-3";
+    };
+    readonly md: {
+        readonly box: "size-5";
+        readonly indicator: "size-5";
+        readonly dot: "before:size-2";
+        readonly check: "size-4";
+    };
+};
+interface RadioProps extends Radio$1.Root.Props {
+    /** Visual size of the radio. Defaults to "sm". */
+    size?: keyof typeof radioSizes;
+    /** Indicator style: the classic dot or a checkbox-style tick. Defaults to "dot". */
+    variant?: "dot" | "check";
+}
+declare function Radio({ className, size, variant, ...props }: RadioProps): React$1.JSX.Element;
+
+declare function ResizablePanelGroup({ className, ...props }: React$1.ComponentProps<typeof ResizablePrimitive.PanelGroup>): React$1.JSX.Element;
+declare function ResizablePanel({ ...props }: React$1.ComponentProps<typeof ResizablePrimitive.Panel>): React$1.JSX.Element;
+declare function ResizableHandle({ withHandle, className, ...props }: React$1.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    withHandle?: boolean;
+}): React$1.JSX.Element;
+
+declare function ScrollArea({ className, children, scrollFade, scrollbarGutter, wheelToHorizontal, smooth, viewportClassName, ...props }: ScrollArea$1.Root.Props & {
+    scrollFade?: boolean;
+    scrollbarGutter?: boolean;
+    /**
+     * Translate vertical mouse-wheel scrolling into (eased) horizontal scrolling
+     * while the pointer is over the viewport. The page only scrolls once this
+     * element reaches its horizontal start/end.
+     */
+    wheelToHorizontal?: boolean;
+    /** Eased, momentum-style vertical wheel scrolling. */
+    smooth?: boolean;
+    viewportClassName?: string;
+}): React$1.JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: ScrollArea$1.Scrollbar.Props): React$1.JSX.Element;
+
+type AsChildProps<T extends keyof React.JSX.IntrinsicElements> = {
+    asChild?: boolean;
+    children?: React.ReactNode;
+} & React.PropsWithoutRef<React.JSX.IntrinsicElements[T]>;
+type OmitUnknown<T> = {
+    [K in keyof T as unknown extends T[K] ? never : K]: T[K];
+};
+type TailOptional<P extends any[]> = P extends [...infer H, infer T] ? [...H] | [...H, T] : never[];
+type RequiredSubset<T, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
+type Tail<P extends any[], H extends any[]> = P extends H ? void : P extends [...H, infer T] ? T : void;
+type NotNullValues<T> = {
+    [K in keyof T]: Exclude<T[K], null>;
+};
+
+declare const LeftScroller: ({ className, asChild, ...props }: AsChildProps<"button">) => React$1.JSX.Element;
+declare const RightScroller: ({ className, asChild, ...props }: AsChildProps<"button">) => React$1.JSX.Element;
+
+declare const sectionHeaderTitleVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const sectionHeaderDescriptionVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SectionHeaderProps extends Omit<React$1.ComponentProps<"div">, "title">, VariantProps<typeof sectionHeaderTitleVariants> {
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    /** Right-aligned actions (buttons, counts, menus). */
+    actions?: React$1.ReactNode;
+    /** A leading node — e.g. a `<FeaturedIcon />` or a count badge. */
+    icon?: React$1.ReactNode;
+    /** Adds a bottom hairline + padding, so the header sits above a list/grid. */
+    border?: boolean;
+}
+/**
+ * A titled section heading: title + optional description on the left, optional
+ * actions on the right, with an optional leading icon. One altitude below the
+ * page-level `DashboardHeader` — use it to introduce a card body, a list, or a
+ * settings group.
+ */
+declare function SectionHeader({ className, title, description, actions, icon, size, border, children, ...props }: SectionHeaderProps): React$1.JSX.Element;
+
+interface SmoothWheelOptions {
+    /** Turn the behaviour on/off (so it can be called unconditionally). */
+    enabled?: boolean;
+    /** Translate vertical wheel movement into horizontal scrolling. */
+    horizontal?: boolean;
+    /** Scales the wheel delta — lower feels slower/heavier. Default 0.8. */
+    multiplier?: number;
+    /** Lerp factor toward the target each frame (0–1). Lower = smoother. */
+    ease?: number;
+}
+/**
+ * Eased, momentum-style wheel scrolling for any scrollable element. Instead of
+ * jumping `scrollTop`/`scrollLeft` by the raw wheel delta (which feels fast and
+ * abrupt), it animates toward an accumulated target with `requestAnimationFrame`.
+ *
+ * It only smooths genuine mouse wheels. Trackpads already scroll smoothly with
+ * OS-level inertia, so layering our own easing on top makes it fight the native
+ * momentum — the container sticks, or snaps back to where the animation was
+ * still heading. In the default vertical mode a trackpad therefore keeps native
+ * behaviour; in horizontal mode we still translate a vertical mouse wheel into
+ * horizontal scrolling (the whole point of the mode) but let a real horizontal
+ * trackpad swipe scroll natively. Every time control returns to native
+ * scrolling — trackpad, or an edge — the in-flight animation is cancelled and
+ * the target resynced so it can never pull the position back.
+ */
+declare function useSmoothWheel(ref: React$1.RefObject<HTMLElement | null>, { enabled, horizontal, multiplier, ease, }?: SmoothWheelOptions): void;
+interface SmoothScrollProps extends React$1.ComponentProps<"div"> {
+    /** Scroll horizontally (vertical wheel is translated to horizontal). */
+    horizontal?: boolean;
+    /** Scales the wheel delta — lower feels slower/heavier. Default 0.8. */
+    multiplier?: number;
+    /** Lerp factor toward the target each frame (0–1). Lower = smoother. */
+    ease?: number;
+}
+/**
+ * A scroll container with eased, momentum-style wheel scrolling. Drop any
+ * overflowing content inside; pass `horizontal` for a row that scrolls
+ * smoothly with a normal mouse wheel.
+ */
+declare function SmoothScroll({ className, children, horizontal, multiplier, ease, ...props }: SmoothScrollProps): React$1.JSX.Element;
+
+declare const socialButtonVariants: (props?: ({
+    iconOnly?: boolean | null | undefined;
+    theme?: "color" | "gray" | "brand" | null | undefined;
+    provider?: "apple" | "dribbble" | "facebook" | "figma" | "google" | "twitter" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SocialLogoProps extends React$1.ComponentProps<"svg"> {
+    /** Render the provider's full-color logo instead of currentColor. */
+    colored?: boolean;
+}
+declare function GoogleLogoIcon({ colored, ...props }: SocialLogoProps): React$1.JSX.Element;
+declare function FacebookLogoIcon({ colored, ...props }: SocialLogoProps): React$1.JSX.Element;
+declare function XLogoIcon({ colored: _colored, ...props }: SocialLogoProps): React$1.JSX.Element;
+declare function FigmaLogoIcon({ colored, ...props }: SocialLogoProps): React$1.JSX.Element;
+declare function DribbbleLogoIcon({ colored, ...props }: SocialLogoProps): React$1.JSX.Element;
+type SocialButtonProvider = "google" | "facebook" | "apple" | "twitter" | "figma" | "dribbble";
+interface SocialButtonProps extends useRender.ComponentProps<"button"> {
+    /** Which provider to render: google, facebook, apple, twitter, figma or dribbble. */
+    provider: SocialButtonProvider;
+    /** brand (provider-filled), color (outline + full-color logo) or gray (tonal). */
+    theme?: VariantProps<typeof socialButtonVariants>["theme"];
+    /** Render a square button with the logo only. */
+    iconOnly?: boolean;
+}
+declare function SocialButton({ className, provider, theme, iconOnly, render, children, ...props }: SocialButtonProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+type Orientation = "horizontal" | "vertical";
+declare function Stepper({ value, orientation, className, ...props }: React$1.ComponentProps<"div"> & {
+    /** 1-based index of the active step. */
+    value?: number;
+    orientation?: Orientation;
+}): React$1.JSX.Element;
+declare function StepperItem({ step, completed, className, ...props }: React$1.ComponentProps<"div"> & {
+    step: number;
+    completed?: boolean;
+}): React$1.JSX.Element;
+declare function StepperTrigger({ className, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element;
+declare function StepperIndicator({ className, children, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+declare function StepperTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function StepperDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function StepperSeparator({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+interface PipelineStage {
+    /** The headline number for the stage. */
+    value: React$1.ReactNode;
+    /** The stage caption, e.g. "Target accounts". */
+    label: React$1.ReactNode;
+    /** Render the value in the brand/primary color (e.g. a final stage). */
+    accent?: boolean;
+}
+interface PipelineProps extends React$1.ComponentProps<"div"> {
+    /** Ordered funnel stages, left to right. */
+    stages: PipelineStage[];
+    /**
+     * Step-to-step conversion markers. `conversions[i]` is the share of stage `i`
+     * that advances to stage `i + 1`, and is shown as a pill right beside stage
+     * `i`'s number (length = `stages.length - 1`). Typically a percentage string.
+     */
+    conversions?: React$1.ReactNode[];
+}
+/**
+ * A conversion funnel — equal-width stages laid left to right. Each stage
+ * carries its own step-to-step conversion in a pill next to the number, and a
+ * chevron points to the next stage, so the row reads as a flow rather than a
+ * set of loose stats.
+ *
+ * The component is its own container query context: when it gets narrow (e.g.
+ * beside a docked panel) the chevrons hide and the stages reflow into a
+ * two-column grid, staying readable without squashing the numbers.
+ */
+declare function Pipeline({ stages, conversions, className, ...props }: PipelineProps): React$1.JSX.Element;
+/** The conversion pill sitting beside a stage number. */
+declare function PipelineConversion({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+
+interface SegmentedControlOption<T extends string> {
+    value: T;
+    label: React$1.ReactNode;
+}
+interface SegmentedControlProps<T extends string> {
+    /** The currently-selected option value. */
+    value: T;
+    /** Called with the newly-selected value (never with an empty selection). */
+    onValueChange: (value: T) => void;
+    /** The mutually-exclusive options, left to right. */
+    options: SegmentedControlOption<T>[];
+    size?: "sm" | "default" | "lg";
+    variant?: "default" | "outline";
+    className?: string;
+}
+/**
+ * A single-select segmented control — a compact row of mutually-exclusive
+ * options (e.g. a time-range switch: Past month / Past 3 months / Overall).
+ *
+ * A thin, typed wrapper over {@link ToggleGroup} that keeps exactly one option
+ * selected — the active segment can't be toggled off into an empty state — and
+ * hides Base UI's array-value plumbing. Pass `options`, `value`, and
+ * `onValueChange`; the value is a string union you control.
+ */
+declare function SegmentedControl<T extends string>({ value, onValueChange, options, size, variant, className, }: SegmentedControlProps<T>): React$1.JSX.Element;
+
+declare const Select: typeof Select$1.Root;
+declare function SelectTrigger({ className, size, children, ...props }: Select$1.Trigger.Props & {
+    size?: "sm" | "default" | "lg";
+}): React$1.JSX.Element;
+declare function SelectValue({ className, ...props }: Select$1.Value.Props): React$1.JSX.Element;
+declare function SelectPopup({ className, children, sideOffset, alignItemWithTrigger, ...props }: Select$1.Popup.Props & {
+    sideOffset?: Select$1.Positioner.Props["sideOffset"];
+    alignItemWithTrigger?: Select$1.Positioner.Props["alignItemWithTrigger"];
+}): React$1.JSX.Element;
+declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): React$1.JSX.Element;
+declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): React$1.JSX.Element;
+declare function SelectGroup(props: Select$1.Group.Props): React$1.JSX.Element;
+declare function SelectGroupLabel(props: Select$1.GroupLabel.Props): React$1.JSX.Element;
+
+declare const Sheet: typeof Dialog$1.Root;
+declare const SheetPortal: React$1.ForwardRefExoticComponent<Omit<_base_ui_react.DialogPortalProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function SheetTrigger(props: Dialog$1.Trigger.Props): React$1.JSX.Element;
+declare function SheetClose(props: Dialog$1.Close.Props): React$1.JSX.Element;
+declare function SheetBackdrop({ className, ...props }: Dialog$1.Backdrop.Props): React$1.JSX.Element;
+declare const sheetViewportVariants: (props?: ({
+    side?: "top" | "left" | "right" | "bottom" | null | undefined;
+    variant?: "default" | "inset" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function SheetViewport({ className, side, variant, ...props }: Dialog$1.Viewport.Props & {
+    side?: "right" | "left" | "top" | "bottom";
+    variant?: "default" | "inset";
+}): React$1.JSX.Element;
+declare const sheetPopupVariants: (props?: ({
+    side?: "top" | "left" | "right" | "bottom" | null | undefined;
+    variant?: "default" | "inset" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function SheetPopup({ className, children, showCloseButton, side, variant, ...props }: Dialog$1.Popup.Props & {
+    showCloseButton?: boolean;
+    side?: "right" | "left" | "top" | "bottom";
+    variant?: "default" | "inset";
+}): React$1.JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+declare function SheetFooter({ className, variant, ...props }: React.ComponentProps<"div"> & {
+    variant?: "default" | "bare";
+}): React$1.JSX.Element;
+declare function SheetTitle({ className, ...props }: Dialog$1.Title.Props): React$1.JSX.Element;
+declare function SheetDescription({ className, ...props }: Dialog$1.Description.Props): React$1.JSX.Element;
+declare function SheetPanel({ className, scrollFade, ...props }: React.ComponentProps<"div"> & {
+    scrollFade?: boolean;
+}): React$1.JSX.Element;
+
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, persistKey, className, style, children, ...props }: React$1.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Remember the expanded/collapsed state in `localStorage` under this key and
+     * restore it on the next load (desktop rail only; the mobile sheet is always
+     * closed on load). Opt-in — omit to keep the sidebar un-persisted. Ignored in
+     * controlled mode (when `open` is provided). The restore runs before first
+     * paint, so there's no expand→collapse flash.
+     */
+    persistKey?: string;
+}): React$1.JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React$1.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}): React$1.JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React$1.ComponentProps<typeof Button>): React$1.JSX.Element;
+declare function SidebarRail({ className, ...props }: React$1.ComponentProps<"button">): React$1.JSX.Element;
+declare function SidebarInset({ className, ...props }: React$1.ComponentProps<"main">): React$1.JSX.Element;
+declare function SidebarInput({ className, ...props }: React$1.ComponentProps<typeof Input>): React$1.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): React$1.JSX.Element;
+declare function SidebarContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarGroupLabel({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function SidebarGroupAction({ className, render, ...props }: useRender.ComponentProps<"button">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function SidebarGroupContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React$1.ComponentProps<"ul">): React$1.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+    variant?: "default" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ isActive, variant, size, tooltip, className, render, ...props }: useRender.ComponentProps<"button"> & {
+    isActive?: boolean;
+    tooltip?: string | React$1.ComponentProps<typeof TooltipPopup>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): React$1.JSX.Element;
+declare function SidebarMenuAction({ className, showOnHover, render, ...props }: useRender.ComponentProps<"button"> & {
+    showOnHover?: boolean;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function SidebarMenuBadge({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React$1.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): React$1.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React$1.ComponentProps<"ul">): React$1.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+declare function SidebarMenuSubButton({ size, isActive, className, render, ...props }: useRender.ComponentProps<"a"> & {
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): React$1.JSX.Element;
+
+type SliderLabelPosition = "bottom" | "floating";
+declare function Slider({ className, children, defaultValue, value, min, max, labelPosition, formatLabel, ...props }: Slider$1.Root.Props & {
+    /** Render each thumb's value beneath it, or in a floating bubble above it. */
+    labelPosition?: SliderLabelPosition;
+    formatLabel?: (value: number) => React$1.ReactNode;
+}): React$1.JSX.Element;
+declare function SliderValue({ className, ...props }: Slider$1.Value.Props): React$1.JSX.Element;
+
+declare function Spinner({ className, ...props }: React.ComponentProps<typeof Loader2Icon>): React$1.JSX.Element;
+
+declare function SpinnerOnDemand({ className, options, isLoading, icon, ...props }: React.ComponentProps<typeof Loader2Icon> & {
+    isLoading: boolean;
+    options?: Parameters<typeof useSpinDelay>[1];
+    icon?: React.ReactNode;
+}): string | number | bigint | true | React$1.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null;
+
+declare const statVariants: (props?: ({
+    variant?: "default" | "card" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StatProps extends useRender.ComponentProps<"div"> {
+    variant?: VariantProps<typeof statVariants>["variant"];
+}
+/**
+ * A single headline metric (KPI). Compose it from `StatLabel`, `StatValue`,
+ * `StatDescription` and an optional `StatTrend`. Drop bare `Stat`s into a
+ * `StatGroup` for a divided row, or use `variant="muted" | "card"` for a
+ * standalone tile.
+ */
+declare function Stat({ className, variant, render, ...props }: StatProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/** The metric's caption, e.g. "Active members". */
+declare function StatLabel({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/**
+ * The headline number. Sans + tabular so digits stay aligned across a row;
+ * drop `font-sans` from `className` to render it in the serif display face.
+ */
+declare function StatValue({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+/** Supporting copy under the value, e.g. "vs. 1,204 last month". */
+declare function StatDescription({ className, render, ...props }: useRender.ComponentProps<"p">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare const statTrendVariants: (props?: ({
+    direction?: "up" | "down" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StatTrendProps extends React$1.ComponentProps<"span"> {
+    direction?: VariantProps<typeof statTrendVariants>["direction"];
+    /** Show the directional arrow before the children. Defaults to `true`. */
+    showIcon?: boolean;
+}
+/**
+ * A small delta chip — e.g. "+12.5%". Picks an up/down arrow from `direction`
+ * and colors itself success/destructive/neutral.
+ */
+declare function StatTrend({ className, direction, showIcon, children, ...props }: StatTrendProps): React$1.JSX.Element;
+/**
+ * Lays a set of bare `Stat`s out as a divided row (stacked on narrow screens),
+ * wrapped in a bordered card surface with even padding per metric.
+ */
+declare function StatGroup({ className, render, ...props }: useRender.ComponentProps<"div">): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+type SwitchProps = Switch$1.Root.Props & {
+    size?: "sm" | "md" | "lg";
+    slim?: boolean;
+};
+declare function Switch({ className, size, slim, ...props }: SwitchProps): React$1.JSX.Element;
+
+declare function Table({ className, ...props }: React$1.ComponentProps<"table">): React$1.JSX.Element;
+declare function TableHeader({ className, ...props }: React$1.ComponentProps<"thead">): React$1.JSX.Element;
+declare function TableBody({ className, ...props }: React$1.ComponentProps<"tbody">): React$1.JSX.Element;
+declare function TableFooter({ className, ...props }: React$1.ComponentProps<"tfoot">): React$1.JSX.Element;
+declare function TableRow({ className, ...props }: React$1.ComponentProps<"tr">): React$1.JSX.Element;
+declare function TableHead({ className, ...props }: React$1.ComponentProps<"th">): React$1.JSX.Element;
+declare function TableCell({ className, ...props }: React$1.ComponentProps<"td">): React$1.JSX.Element;
+declare function TableCaption({ className, ...props }: React$1.ComponentProps<"caption">): React$1.JSX.Element;
+
+type TabsVariant = "default" | "underline";
+declare function Tabs({ className, ...props }: Tabs$1.Root.Props): React$1.JSX.Element;
+declare function TabsList({ variant, className, children, ...props }: Tabs$1.List.Props & {
+    variant?: TabsVariant;
+}): React$1.JSX.Element;
+declare function TabsTab({ className, ...props }: Tabs$1.Tab.Props): React$1.JSX.Element;
+declare function TabsPanel({ className, ...props }: Tabs$1.Panel.Props): React$1.JSX.Element;
+
+type TagSize = "sm" | "md" | "lg";
+type TagSelectionMode = "none" | "single" | "multiple";
+interface TagGroupProps {
+    size?: TagSize;
+    selectionMode?: TagSelectionMode;
+    defaultSelectedKeys?: Iterable<string>;
+    selectedKeys?: Set<string>;
+    onSelectionChange?: (keys: Set<string>) => void;
+    onRemove?: (key: string) => void;
+    className?: string;
+    children?: React$1.ReactNode;
+}
+declare function TagGroup({ size, selectionMode, defaultSelectedKeys, selectedKeys: controlledKeys, onSelectionChange, onRemove, className, children, }: TagGroupProps): React$1.JSX.Element;
+interface TagProps extends Omit<React$1.ComponentProps<"span">, "children"> {
+    /** Unique value used for selection and removal tracking. */
+    value?: string;
+    size?: TagSize;
+    /** Numeric count displayed as a small pill beside the label. */
+    count?: number;
+    /** Called when the remove button is clicked. Renders the X button. */
+    onRemove?: () => void;
+    disabled?: boolean;
+    children?: React$1.ReactNode;
+}
+declare function Tag({ value, size: sizeProp, count, onRemove: onRemoveProp, disabled, children, className, ...props }: TagProps): React$1.JSX.Element;
+
+declare function TargetCountdown({ target, children, }: {
+    target: Date | number;
+    children: (duration: Duration | null, isFirstRender: boolean) => React.ReactNode;
+}): React$1.ReactNode;
+
+declare function Timeline({ className, ...props }: React$1.ComponentProps<"ol">): React$1.JSX.Element;
+declare function TimelineItem({ className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+/** The marker column: a dot and the connecting line beneath it. */
+declare function TimelineDot({ className, children, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function TimelineContent({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function TimelineTitle({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function TimelineTime({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+declare function TimelineDescription({ className, ...props }: React$1.ComponentProps<"div">): React$1.JSX.Element;
+
+interface TextEditorProps {
+    /** Compact (sm) or standard (md) size */
+    size?: "sm" | "md";
+    /** Placeholder when the editor is empty */
+    placeholder?: string;
+    /** Initial HTML content */
+    content?: string;
+    /** Called with the updated HTML on every change */
+    onChange?: (html: string) => void;
+    /** Show tooltips on every toolbar button */
+    withTooltips?: boolean;
+    /** Replace the fixed toolbar with a selection-triggered floating toolbar */
+    floatingToolbar?: boolean;
+    /** Extra className for the outer wrapper */
+    className?: string;
+}
+declare function TextEditor({ size, placeholder, content, onChange, withTooltips, floatingToolbar, className, }: TextEditorProps): React$1.JSX.Element;
+
+declare const toastManager: _base_ui_react.ToastManager;
+declare const anchoredToastManager: _base_ui_react.ToastManager;
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastProviderProps extends Toast.Provider.Props {
+    position?: ToastPosition;
+}
+declare function ToastProvider({ children, position, ...props }: ToastProviderProps): React$1.JSX.Element;
+declare function AnchoredToastProvider({ children, ...props }: Toast.Provider.Props): React$1.JSX.Element;
+
+declare const toggleVariants: (props?: ({
+    size?: "default" | "lg" | "sm" | null | undefined;
+    variant?: "default" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Toggle$1({ className, variant, size, ...props }: Toggle$2.Props & VariantProps<typeof toggleVariants>): React$1.JSX.Element;
+
+declare function ToggleGroup({ className, variant, size, orientation, children, ...props }: ToggleGroup$1.Props & VariantProps<typeof toggleVariants>): React$1.JSX.Element;
+declare function Toggle({ className, children, variant, size, ...props }: Toggle$2.Props & VariantProps<typeof toggleVariants>): React$1.JSX.Element;
+declare function ToggleGroupSeparator({ className, orientation, ...props }: {
+    className?: string;
+} & React$1.ComponentProps<typeof Separator>): React$1.JSX.Element;
+
+declare function Toolbar({ className, ...props }: Toolbar$1.Root.Props): React$1.JSX.Element;
+declare function ToolbarButton({ className, ...props }: Toolbar$1.Button.Props): React$1.JSX.Element;
+declare function ToolbarLink({ className, ...props }: Toolbar$1.Link.Props): React$1.JSX.Element;
+declare function ToolbarInput({ className, ...props }: Toolbar$1.Input.Props): React$1.JSX.Element;
+declare function ToolbarGroup({ className, ...props }: Toolbar$1.Group.Props): React$1.JSX.Element;
+declare function ToolbarSeparator({ className, ...props }: Toolbar$1.Separator.Props): React$1.JSX.Element;
+
+declare const VerticalScrollFader: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const VerticalScrollFaderContent: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    faderSize?: string;
+    showScrollbar?: boolean;
+} & React__default.RefAttributes<HTMLDivElement>>;
+declare const VerticalScrollFaderTopScroller: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+declare const VerticalScrollFaderBottomScroller: React__default.ForwardRefExoticComponent<{
+    asChild?: boolean;
+    children?: React__default.ReactNode;
+} & Omit<React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const videoPlayerVariants: (props?: ({
+    size?: "lg" | "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface VideoPlayerProps extends Omit<React$1.ComponentProps<"div">, "title">, VariantProps<typeof videoPlayerVariants> {
+    src: string;
+    poster?: string;
+    title?: string;
+    autoPlay?: boolean;
+    loop?: boolean;
+}
+declare function VideoPlayer({ className, size, src, poster, title, autoPlay, loop, ...props }: VideoPlayerProps): React$1.JSX.Element;
+
+interface DashboardHeaderProps extends Omit<AsChildProps<"div">, "title"> {
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    rightActions?: React.ReactNode;
+    breadcrumb?: React.ReactNode;
+}
+declare function DashboardHeader({ title, subtitle, className, children, asChild, rightActions, breadcrumb, ...props }: DashboardHeaderProps): React$1.JSX.Element;
+
+interface DashboardPanelProps extends AsChildProps<"div"> {
+    header?: React.ReactNode;
+}
+declare function DashboardPanel({ className, asChild, children, header, ...props }: DashboardPanelProps): React$1.JSX.Element;
+
+interface DashboardTopbarUser {
+    /** Display name, shown in the account menu and used as the avatar alt text. */
+    name: string;
+    /** Optional email, shown under the name in the account menu. */
+    email?: string;
+    /** Optional avatar image URL. Falls back to initials when omitted. */
+    avatarSrc?: string;
+    /** Initials shown when there is no avatar image. */
+    initials?: string;
+}
+interface DashboardTopbarProps {
+    /** The signed-in user rendered in the account menu + avatar trigger. */
+    user: DashboardTopbarUser;
+    /** Opens the consumer's command palette. The search field is a button. */
+    onSearch?: () => void;
+    /** Placeholder text inside the search affordance. Defaults to "Search". */
+    searchPlaceholder?: string;
+    /**
+     * Trailing shortcut hint inside the search affordance. Defaults to
+     * `<KbdGroup><Kbd>⌘</Kbd><Kbd>K</Kbd></KbdGroup>`. Pass `null` to hide it.
+     */
+    searchShortcut?: React$1.ReactNode;
+    /** Account-menu "Settings" item handler. The item is omitted when undefined. */
+    onSettings?: () => void;
+    /** Account-menu "Log out" item handler. The item is omitted when undefined. */
+    onLogout?: () => void;
+    /** mailto/url for the support icon button. The button renders only when set. */
+    supportHref?: string;
+    /** Whether to render the animated light/dark theme toggle. Defaults to `true`. */
+    showThemeToggle?: boolean;
+    /** Optional extra controls rendered left of the theme toggle. */
+    actions?: React$1.ReactNode;
+    className?: string;
+}
+/**
+ * Dashboard top bar shared by the host and sponsor dashboards.
+ *
+ * Zones: mobile/desktop sidebar trigger · a global search field styled as an
+ * input that calls `onSearch` (the consumer owns the command palette + ⌘K key
+ * handler) · optional extra `actions` · the animated theme toggle · an optional
+ * support link · the account menu (Settings / Log out). The inner row shares a
+ * `max-w-[1280px]` wrapper so the search field and avatar line up with the page.
+ */
+declare function DashboardTopbar({ user, onSearch, searchPlaceholder, searchShortcut, onSettings, onLogout, supportHref, showThemeToggle, actions, className, }: DashboardTopbarProps): React$1.JSX.Element;
+
+interface ValueObject {
+    [themeName: string]: string;
+}
+interface UseThemeProps {
+    /** List of all available theme names */
+    themes: string[];
+    /** Forced theme name for the current page */
+    forcedTheme?: string | undefined;
+    /** Update the theme */
+    setTheme: React.Dispatch<React.SetStateAction<string>>;
+    /** Active theme name */
+    theme?: string | undefined;
+    /** If `enableSystem` is true and the active theme is "system", this returns whether the system preference resolved to "dark" or "light". Otherwise, identical to `theme` */
+    resolvedTheme?: string | undefined;
+    /** If enableSystem is true, returns the System theme preference ("dark" or "light"), regardless what the active theme is */
+    systemTheme?: "dark" | "light" | undefined;
+}
+type Attribute = `data-${string}` | "class";
+interface ThemeProviderProps extends React.PropsWithChildren {
+    /** List of all available theme names */
+    themes?: string[] | undefined;
+    /** Forced theme name for the current page */
+    forcedTheme?: string | undefined;
+    /** Whether to switch between dark and light themes based on prefers-color-scheme */
+    enableSystem?: boolean | undefined;
+    /** Disable all CSS transitions when switching themes */
+    disableTransitionOnChange?: boolean | undefined;
+    /** Whether to indicate to browsers which color scheme is used (dark or light) for built-in UI like inputs and buttons */
+    enableColorScheme?: boolean | undefined;
+    /** Key used to store theme setting in localStorage */
+    storageKey?: string | undefined;
+    /** Default theme name (for v0.0.12 and lower the default was light). If `enableSystem` is false, the default theme is light */
+    defaultTheme?: string | undefined;
+    /** HTML attribute modified based on the active theme. Accepts `class`, `data-*` (meaning any data attribute, `data-mode`, `data-color`, etc.), or an array which could include both */
+    attribute?: Attribute | Attribute[] | undefined;
+    /** Mapping of theme name to HTML attribute value. Object where key is the theme name and value is the attribute value */
+    value?: ValueObject | undefined;
+    /** Nonce string to pass to the inline script for CSP headers */
+    nonce?: string | undefined;
+}
+declare const useTheme: () => UseThemeProps;
+declare const ThemeProvider: (props: ThemeProviderProps) => React.ReactNode;
+declare const ThemeContextOverride: ({ children, value, }: {
+    children: React.ReactNode;
+    value: string;
+}) => string | number | bigint | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;
+declare const script: (...args: any[]) => void;
+
+interface AvatarUploadBaseProps extends Omit<React.ComponentProps<typeof Avatar>, "onDrop" | "children"> {
+    onDrop: (file: File) => void;
+    onDelete?: () => void;
+    disabled?: boolean;
+    loading?: boolean;
+    progress: number;
+    imageUrl: string | undefined;
+    initials: React.ReactNode;
+    alt: string;
+    avatarClassName?: string;
+    mode?: "image" | "image&video";
+}
+declare function AvatarUploadBase({ onDrop, onDelete, disabled, loading, progress, imageUrl, initials, alt, className, avatarClassName, mode, ...props }: AvatarUploadBaseProps): React$1.JSX.Element;
+
+interface ImageUploadBaseProps extends Omit<React.ComponentProps<"div">, "onDrop"> {
+    onDrop: (file: File) => void;
+    onDelete?: () => void;
+    disabled?: boolean;
+    loading?: boolean;
+    progress: number;
+    imageUrl: string | null;
+    alt: string;
+}
+declare function ImageUploadBase({ onDrop, onDelete, disabled, loading, progress, imageUrl, alt, className, ...props }: ImageUploadBaseProps): React$1.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare function useCallbackRef<T extends (...args: Array<any>) => any>(fn: T): T;
+
+declare function useFirstRender(): boolean;
+
+declare function useHover<T extends Element>({ mounted, }?: {
+    mounted?: boolean;
+}): readonly [(node: T | null) => void, boolean];
+
+declare function useIsTabActive(): boolean;
+
+declare function useSubscribeBreakpoints(): void;
+interface UseMediaQueryOptions {
+    ssr?: boolean;
+    defaultSSRValue?: boolean;
+}
+declare function useMediaQuery(query: string, { ssr, defaultSSRValue }?: UseMediaQueryOptions): boolean;
+declare function useIsSm({ ssr, defaultSSRValue, }?: UseMediaQueryOptions): boolean;
+declare function useIsMd({ ssr, defaultSSRValue, }?: UseMediaQueryOptions): boolean;
+declare function useIsLg({ ssr, defaultSSRValue, }?: UseMediaQueryOptions): boolean;
+declare function useIsXl({ ssr, defaultSSRValue, }?: UseMediaQueryOptions): boolean;
+declare function useIs2xl({ ssr, defaultSSRValue, }?: UseMediaQueryOptions): boolean;
+
+export { Accordion, AccordionPanel as AccordionContent, AccordionItem, AccordionPanel, AccordionTrigger, Alert, AlertAction, AlertDescription, AlertDialog, AlertDialogBackdrop, AlertDialogClose, AlertDialogPopup as AlertDialogContent, AlertDialogCreateHandle, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogBackdrop as AlertDialogOverlay, AlertDialogPopup, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertDialogViewport, AlertTitle, AnchoredToastProvider, AnimatedCounter, type AnimatedCounterProps, AnimatedThemeToggler, AppGalleryLogoIcon, AppStoreButton, type AppStoreButtonStore, AppleLogoIcon, type AsChildProps, AspectRatio, type Attribute, AuroraOrb, type AuroraOrbProps, AuroraText, type AuroraTextProps, Autocomplete, AutocompleteClear, AutocompleteCollection, AutocompleteEmpty, AutocompleteGroup, AutocompleteGroupLabel, AutocompleteInput, AutocompleteItem, AutocompleteList, AutocompletePopup, AutocompleteRow, AutocompleteSeparator, AutocompleteStatus, AutocompleteTrigger, AutocompleteValue, Avatar, AvatarAddButton, AvatarCompanyIcon, AvatarFallback, AvatarGroup, AvatarImage, AvatarLabelGroup, AvatarProfilePhoto, AvatarUploadBase, type AvatarUploadBaseProps, Badge, BadgeAvatar, BadgeCloseButton, BadgeDot, BadgeFlag, BadgeGroup, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, Group as ButtonGroup, GroupSeparator as ButtonGroupSeparator, GroupText as ButtonGroupText, ButtonProps, CONFETTI_COLORS, Calendar, Card, CardAction, CardPanel as CardContent, CardDescription, CardFooter, CardFrame, CardFrameDescription, CardFrameFooter, CardFrameHeader, CardFrameTitle, CardHeader, CardPanel, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Chat, ChatDivider, type ChatDividerProps, type ChatDividerVariant, ChatEmptyState, ChatEmptyStateDescription, ChatEmptyStateIcon, ChatEmptyStateTitle, ChatHeader, ChatHeaderActions, ChatHeaderAvatar, ChatHeaderTitle, ChatInput, type ChatInputProps, ChatMessage, ChatMessageBubble, type ChatMessageBubbleProps, type ChatMessageProps, ChatMessages, ChatSuggestion, type ChatSuggestionProps, ChatSuggestions, ChatToolCard, ChatToolCardActions, ChatToolCardHeader, ChatToolChip, ChatTypingIndicator, Checkbox, CheckboxGroup, Collapsible, CollapsiblePanel as CollapsibleContent, CollapsiblePanel, CollapsibleTrigger, ColorAlphaSlider, ColorArea, ColorEyeDropper, ColorHueSlider, ColorPicker, ColorPickerPanel, ColorPickerProvider, ColorPreview, ColorSavedColors, ColorSwatch, ColorThumb, ColorValueInput, Combobox, ComboboxChip, ComboboxChips, ComboboxClear, ComboboxCollection, ComboboxEmpty, ComboboxGroup, ComboboxGroupLabel, ComboboxInput, ComboboxItem, ComboboxList, ComboboxPopup, ComboboxRow, ComboboxSeparator, ComboboxStatus, ComboboxTrigger, ComboboxValue, Command, CommandCollection, CommandCreateHandle, CommandDialog, CommandDialogPopup, CommandDialogTrigger, CommandEmpty, CommandFooter, CommandGroup, CommandGroupLabel, CommandInput, CommandItem, CommandList, CommandPanel, CommandSeparator, CommandShortcut, Confetti, ConfettiButton, type ConfettiButtonProps, type ConfettiProps, type ConfettiRef, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, ContextMeter, type ContextMeterProps, type ContextMeterState, CreditCard, type CreditCardProps, type CreditCardType, DashboardHeader, DashboardPanel, DashboardTopbar, type DashboardTopbarProps, type DashboardTopbarUser, DataTablePaged, type DataTablePagedColumn, type DataTablePagedProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DateTimePicker, type DateTimePickerProps, Dialog, DialogBackdrop, DialogClose, DialogPopup as DialogContent, DialogCreateHandle, DialogDescription, DialogFooter, DialogHeader, DialogBackdrop as DialogOverlay, DialogPanel, DialogPopup, DialogPortal, DialogTitle, DialogTrigger, DialogViewport, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DribbbleLogoIcon, Menu as DropdownMenu, MenuCheckboxItem as DropdownMenuCheckboxItem, MenuPopup as DropdownMenuContent, MenuCreateHandle as DropdownMenuCreateHandle, MenuGroup as DropdownMenuGroup, MenuItem as DropdownMenuItem, MenuGroupLabel as DropdownMenuLabel, MenuPortal as DropdownMenuPortal, MenuRadioGroup as DropdownMenuRadioGroup, MenuRadioItem as DropdownMenuRadioItem, MenuSeparator as DropdownMenuSeparator, MenuShortcut as DropdownMenuShortcut, MenuSub as DropdownMenuSub, MenuSubPopup as DropdownMenuSubContent, MenuSubTrigger as DropdownMenuSubTrigger, MenuTrigger as DropdownMenuTrigger, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, ErrorOrEmptyState, Fab, type FabProps, FacebookLogoIcon, FeaturedIcon, Field, FieldControl, FieldDescription, FieldError, FieldGroup, FieldItem, FieldLabel, FieldValidity, Fieldset, FieldsetLegend, FigmaLogoIcon, ForbiddenErrorState, Form, Frame, FrameDescription, FrameFooter, FrameHeader, FramePanel, FrameTitle, GalaxyStoreLogoIcon, GeneralErrorState, GoogleLogoIcon, GooglePlayLogoIcon, Group, GroupSeparator, GroupText, HelpTip, type HelpTipProps, HorizontalScrollFader, HorizontalScrollFaderContent, HorizontalScrollFaderLeftScroller, HorizontalScrollFaderRightScroller, PreviewCard as HoverCard, PreviewCardPopup as HoverCardContent, PreviewCardTrigger as HoverCardTrigger, ImageUploadBase, type ImageUploadBaseProps, Input, InputGroup, InputGroupAddon, InputGroupInput, InputGroupText, InputGroupTextarea, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, InputProps, InternalServerErrorState, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Kbd, KbdGroup, Label, LeftScroller, Markdown, type MarkdownProps, Menu, MenuCheckboxItem, MenuCreateHandle, MenuGroup, MenuGroupLabel, MenuItem, MenuPopup, MenuPortal, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuShortcut, MenuSub, MenuSubPopup, MenuSubTrigger, MenuTrigger, Menubar, MenuCheckboxItem as MenubarCheckboxItem, MenubarContent, MenuGroup as MenubarGroup, MenuItem as MenubarItem, MenuGroupLabel as MenubarLabel, MenubarMenu, MenuPortal as MenubarPortal, MenuRadioGroup as MenubarRadioGroup, MenuRadioItem as MenubarRadioItem, MenuSeparator as MenubarSeparator, MenuShortcut as MenubarShortcut, MenuSub as MenubarSub, MenuSubPopup as MenubarSubContent, MenuSubTrigger as MenubarSubTrigger, MenubarTrigger, Meter, MeterIndicator, MeterLabel, MeterTrack, MeterValue, MultiSelect, type MultiSelectItem, type MultiSelectProps, NavigationMenu, NavigationMenuContent, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NotFoundErrorState, type NotNullValues, NumberField, NumberFieldDecrement, NumberFieldGroup, NumberFieldIncrement, NumberFieldInput, NumberFieldScrubArea, OfflineErrorState, type OmitUnknown, Pagination, PaginationContent, PaginationControls, PaginationEllipsis, PaginationItem, PaginationLink, type PaginationLinkProps, PaginationNext, PaginationPrevious, Pipeline, PipelineConversion, type PipelineProps, type PipelineStage, Popover, PopoverClose, PopoverPopup as PopoverContent, PopoverCreateHandle, PopoverDescription, PopoverPopup, PopoverTitle, PopoverTrigger, PreviewCard, PreviewCardPopup, PreviewCardTrigger, Progress, ProgressCircle, ProgressFloatingValue, ProgressHalfCircle, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, QRCode, QRCodeGradientScan, Radio, RadioGroup, Radio as RadioGroupItem, type RequiredSubset, ResizableHandle, ResizablePanel, ResizablePanelGroup, RightScroller, ScrollArea, ScrollBar, SectionHeader, SegmentedControl, type SegmentedControlOption, type SegmentedControlProps, Select, SelectPopup as SelectContent, SelectGroup, SelectGroupLabel, SelectItem, SelectPopup, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetBackdrop, SheetClose, SheetPopup as SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetBackdrop as SheetOverlay, SheetPanel, SheetPopup, SheetPortal, SheetTitle, SheetTrigger, SheetViewport, type SideCannonsOptions, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, Slider, SliderValue, SmoothScroll, type SmoothScrollProps, type SmoothWheelOptions, SocialButton, type SocialButtonProvider, Spinner, SpinnerOnDemand, Stat, StatDescription, StatGroup, StatLabel, StatTrend, StatValue, Stepper, StepperDescription, StepperIndicator, StepperItem, StepperSeparator, StepperTitle, StepperTrigger, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsPanel as TabsContent, TabsList, TabsPanel, TabsTab, TabsTab as TabsTrigger, Tag, TagGroup, type TagGroupProps, type TagProps, type TagSelectionMode, type TagSize, type Tail, type TailOptional, TargetCountdown, TextEditor, type TextEditorProps, Textarea, type TextareaProps, ThemeContextOverride, ThemeProvider, type ThemeProviderProps, type ThemeTogglerVariant, TimePicker, type TimePickerProps, type TimeValue, Timeline, TimelineContent, TimelineDescription, TimelineDot, TimelineItem, TimelineTime, TimelineTitle, type ToastPosition, ToastProvider, Toggle$1 as Toggle, ToggleGroup, Toggle as ToggleGroupItem, ToggleGroupSeparator, Toolbar, ToolbarButton, ToolbarGroup, ToolbarInput, ToolbarLink, ToolbarSeparator, Tooltip, TooltipPopup as TooltipContent, TooltipCreateHandle, TooltipDescription, TooltipPopup, TooltipProvider, TooltipTitle, TooltipTrigger, UnauthorizedErrorState, type UseThemeProps, VerticalScrollFader, VerticalScrollFaderBottomScroller, VerticalScrollFaderContent, VerticalScrollFaderTopScroller, VideoPlayer, XLogoIcon, anchoredToastManager, appStoreButtonVariants, avatarGroupVariants, avatarVariants, badgeGroupVariants, badgeVariants, chatMessageBubbleVariants, chatMessageVariants, cn, fabVariants, featuredIconVariants, groupVariants, itemVariants, navigationMenuTriggerStyle, qrCodeVariants, script, sectionHeaderDescriptionVariants, sectionHeaderTitleVariants, sheetPopupVariants, sheetViewportVariants, sideCannons, socialButtonVariants, statTrendVariants, statVariants, toastManager, toggleVariants, useAutocompleteFilter, useCallbackRef, useCarousel, useColorPicker, useComboboxFilter, useConfetti, useFirstRender, useHover, useIs2xl, useIsLg, useIsMd, useIsSm, useIsTabActive, useIsXl, useMediaQuery, useSidebar, useSmoothWheel, useSubscribeBreakpoints, useTheme, videoPlayerVariants };