@kismet-ux/constellation 1.12.0 → 1.13.0

package/dist/index-ClPGArR0.d.ts

@@ -0,0 +1,633 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import './tooltip-Cf_wdeef.js';
+import { f as TypographyVariant } from './typography-CTGVc_Gg.js';
+
+type AlertTheme = 'default' | 'primary' | 'secondary' | 'success' | 'destructive' | 'warning' | 'info' | 'slate';
+type AlertMessage = {
+    id: string;
+    title: string;
+    description?: string;
+    theme: AlertTheme;
+    timeout?: number;
+    persistent?: boolean;
+    closable?: boolean;
+};
+type PushAlertInput = Omit<AlertMessage, 'id'> & {
+    icon?: ReactNode;
+    action?: ReactNode;
+};
+type AlertContextValue = {
+    pushAlert: (alert: PushAlertInput) => void;
+    removeAlert: (id: string) => void;
+};
+
+type PaginationProps = {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (size: number) => void;
+    pageSizeOptions?: number[];
+    className?: string;
+};
+
+type SortDirection = 'asc' | 'desc';
+type SortState = {
+    key: string;
+    direction: SortDirection;
+};
+type SortContextValue = {
+    sortState: SortState | null;
+    setSortState: React__default.Dispatch<React__default.SetStateAction<SortState | null>>;
+};
+
+declare const alertVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface AlertProps extends VariantProps<typeof alertVariants> {
+    className?: string;
+    icon?: React.ReactNode;
+    action?: React.ReactNode;
+    onClose?: () => void;
+    /** A colour outside the theme scale; overrides the theme's colour roles. */
+    color?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+interface AlertBannerProps extends VariantProps<typeof alertVariants> {
+    open: boolean;
+    onClose?: () => void;
+    icon?: boolean | React.ReactNode;
+    action?: React.ReactNode;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare const AlertBanner: React.ForwardRefExoticComponent<AlertBannerProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const persistAlert: (alert: Omit<AlertMessage, "id">) => void;
+
+declare function AlertProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+type AvatarProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+type AvatarImageProps = React.ImgHTMLAttributes<HTMLImageElement>;
+declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+type AvatarFallbackProps = React.HTMLAttributes<HTMLSpanElement>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const chipVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    variant?: "soft" | "outline" | "solid" | null | undefined;
+    size?: "sm" | "md" | "xs" | "2xs" | null | undefined;
+    shape?: "rounded" | "pill" | null | undefined;
+    dashed?: boolean | null | undefined;
+    mono?: boolean | null | undefined;
+    uppercase?: boolean | null | undefined;
+    wrap?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ChipProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof chipVariants> {
+    /**
+     * Any colour outside the theme scale — a category hue, a dietary marker.
+     * Overrides the whole set of colour roles the theme would otherwise supply,
+     * so one value is enough for every `variant`.
+     */
+    color?: string;
+    /**
+     * Render the caller's own element instead of a `<span>`, keeping the chip's
+     * styling.
+     *
+     * A chip is a status marker by default and a span is right for that. But a
+     * row of chips is often a CHOICE — pick a variant, filter a list — and that
+     * needs real button semantics: focusable, keyboard-operable, `aria-pressed`.
+     * Styling a `<span>` to look tappable does not give any of that.
+     *
+     * ```tsx
+     * <Chip asChild variant={'outline'}>
+     *   <button type={'button'} aria-pressed={on} onClick={pick}>Diced</button>
+     * </Chip>
+     * ```
+     */
+    asChild?: boolean;
+}
+/**
+ * A small status marker.
+ *
+ * `variant` chooses how much weight it carries: `soft` (a tinted fill, the
+ * default) reads as ambient, `outline` recedes further, and `solid` is a claim.
+ * `dashed` marks the value as provisional — a guess rather than a reading —
+ * which is a distinction worth drawing without spending a second colour on it.
+ */
+declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface ChipSelectOption {
+    value: string;
+    /** What the chip reads. Defaults to `value`. */
+    label?: React.ReactNode;
+    /** A `title` on the chip — the reckoning behind the option, if there is one. */
+    hint?: string;
+    disabled?: boolean;
+}
+interface ChipSelectProps {
+    options: ChipSelectOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /**
+     * What the anchor shows while nothing is selected — the option the caller
+     * would pick for you. Its chip draws as a suggestion rather than a choice.
+     */
+    placeholder?: string;
+    /** Accessible name for the control. */
+    label: string;
+    /** Per-option chip props — the caller's own vocabulary for what an option IS. */
+    optionProps?: (option: ChipSelectOption, state: {
+        selected: boolean;
+        suggested: boolean;
+    }) => Partial<ChipProps>;
+    /** Chip defaults for every option. */
+    size?: ChipProps['size'];
+    theme?: ChipProps['theme'];
+    variant?: ChipProps['variant'];
+    mono?: boolean;
+    /** Taking the selection off again — off by default; a second tap does nothing. */
+    clearable?: boolean;
+    className?: string;
+}
+/**
+ * ONE CHIP UNTIL ASKED.
+ *
+ * A row of chips is the friendliest way to offer six sizes, four cuts or three
+ * grinds — and the most expensive thing on the card, because it is as tall as
+ * the row wraps to and it is spending that room on options nobody is choosing
+ * right now. Andrew, whose kitchen card this was crowding out: *"Only the
+ * default (if not yet selected) or selected pill should be visible. Hovering on
+ * desktop or tapping on mobile would then fly-out the other options from under
+ * the default pill. That way, the entire area is limited to the space of just
+ * one pill."*
+ *
+ * So: the selection is the control. The rest live under it and come out when
+ * asked — on hover where there is a pointer, on a tap where there is not.
+ *
+ * ⚠️ THE FLYOUT IS PORTALED, and it has to be. A chip select is small enough to
+ * look like it could open in place, but it is used inside cards, sheets and
+ * drawers — and a `Sheet` is `overflow: hidden` while a scrolling body is a
+ * clipping box on both axes. Opening in flow would either be clipped at the
+ * worst moment (an option near the foot of a long sheet) or push the card's own
+ * content around every time somebody moved a mouse over it.
+ *
+ * ⚠️ A TAP IS NOT A HOVER. On a touch screen the first tap must OPEN and select
+ * nothing — a pointer-driven `mouseenter` fires on touch too, and without this
+ * the first tap both opened the flyout and committed whatever the anchor
+ * happened to be showing.
+ *
+ * The options emerge with a stagger, which is the whole point of the gesture:
+ * they should read as having come out from under the anchor rather than
+ * appearing beside it. `prefers-reduced-motion` takes the movement out and
+ * keeps the reveal.
+ */
+declare const ChipSelect: React.ForwardRefExoticComponent<ChipSelectProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const codeBlockVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface CodeBlockProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof codeBlockVariants> {
+    /** The code content to display. */
+    children: string;
+    /** Language label displayed in the header (e.g. "sql", "json", "typescript"). */
+    language?: string;
+    /** Show a copy-to-clipboard button. */
+    copyable?: boolean;
+    /** Enable collapse/expand behavior. When true, content is initially collapsed. */
+    collapsible?: boolean;
+    /** Max height in rem when collapsed. Defaults to 12. */
+    collapsedHeight?: number;
+    /** Whether the code block starts expanded when `collapsible` is true. */
+    defaultExpanded?: boolean;
+}
+declare const CodeBlock: React.ForwardRefExoticComponent<CodeBlockProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DevIndicatorProps {
+    className?: string;
+}
+declare function DevIndicator({ className }: DevIndicatorProps): React.JSX.Element | null;
+
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onAfterClose?: () => void;
+    children?: React.ReactNode;
+}
+declare function Dialog({ open: controlledOpen, defaultOpen, onOpenChange, onAfterClose, children, }: DialogProps): React.JSX.Element;
+interface DialogTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare function DialogTrigger({ asChild, onClick, children, ...props }: DialogTriggerProps): React.JSX.Element;
+interface DialogCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare function DialogClose({ asChild, onClick, children, ...props }: DialogCloseProps): React.JSX.Element;
+declare function DialogOverlay({ className, passThrough, ...props }: React.HTMLAttributes<HTMLDivElement> & {
+    passThrough?: boolean;
+}): React.JSX.Element;
+type DialogContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    width?: 'max' | 'min';
+    /**
+     * Give the panel a real width instead of letting its content decide.
+     *
+     * `width` is `max-content`/`min-content`, which is fine for a confirm but
+     * wrong for anything with a form in it: the panel ends up as narrow as the
+     * longest line allows and every row inside is squashed. Takes the same
+     * vocabulary as `Container` — `text`, `content`, `wide`, or a CSS length —
+     * and stays capped by the viewport either way.
+     */
+    measure?: 'text' | 'content' | 'wide' | (string & {});
+    /**
+     * The element the dialog came from, so it grows out of it and shrinks back
+     * into it rather than fading in over the top of the page.
+     *
+     * Pass the tile, row or card that was clicked. Where a modal has an obvious
+     * origin on screen, morphing from it says "this is that thing, larger" — a
+     * dialog that fades in centre-screen makes the reader find their place
+     * again when it closes.
+     *
+     * A `DOMRect` is accepted too, for the case where the origin has since been
+     * unmounted or moved.
+     */
+    origin?: React.RefObject<HTMLElement | null> | DOMRect | null;
+    /**
+     * Whether the scrim takes the pointer.
+     *
+     * `blocking` (the default) is a modal in the usual sense: the page behind is
+     * dimmed and inert, and a click on the scrim dismisses.
+     *
+     * `pass-through` dims the page but leaves it live, for a panel that is a
+     * DETAIL VIEW of something still on screen — a tile in a grid, a row in a
+     * table. Clicking the next tile should show the next thing, not spend one
+     * click closing and a second one opening. The dialog still dismisses on a
+     * click that lands outside it, so a click on the empty background behaves as
+     * it always did; a handler that calls `stopPropagation()` keeps it open,
+     * which is how the tile says "I am taking this click".
+     *
+     * Scroll is not locked in this mode, for the same reason: the thing you want
+     * to look at next may be further down the page.
+     */
+    overlay?: 'blocking' | 'pass-through';
+};
+declare function DialogContent({ className, children, width, origin, measure, overlay, style, ...props }: DialogContentProps): React.ReactPortal | null;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<'div'>): React.JSX.Element;
+/**
+ * Renders the dialog's heading. Defaults to `<Typography variant='h6'>`
+ * so consumers can write `<DialogTitle>My dialog</DialogTitle>` without
+ * manually wrapping in Typography. Override the variant with the
+ * `variant` prop, or opt out entirely with `asChild` to supply a custom
+ * element (e.g., a Heading component).
+ */
+declare function DialogTitle({ className, asChild, variant, ...props }: React.ComponentProps<'h2'> & {
+    asChild?: boolean;
+    variant?: TypographyVariant;
+}): React.JSX.Element;
+/**
+ * Renders the dialog's supporting description text. Defaults to
+ * `<Typography variant='body2'>`. Override with `variant` or supply a
+ * custom element via `asChild`.
+ */
+declare function DialogDescription({ className, asChild, variant, ...props }: React.ComponentProps<'p'> & {
+    asChild?: boolean;
+    variant?: TypographyVariant;
+}): React.JSX.Element;
+declare function DialogPortal({ children }: {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+
+declare const emptyStateVariants: (props?: ({
+    theme?: "default" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
+    /** Icon displayed above the title. */
+    icon?: React.ReactNode;
+    /** Primary heading text. */
+    title: string;
+    /** Secondary descriptive text below the title. */
+    description?: string;
+    /** Action element (typically a Button) rendered below the text. */
+    action?: React.ReactNode;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const iconVariants: (props?: ({
+    variant?: "outlined" | "contained" | "ghost" | "plain" | null | undefined;
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    rounded?: boolean | "extra" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+type IconVariantSize = NonNullable<VariantProps<typeof iconVariants>['size']>;
+type IconNodeProps = React.SVGProps<SVGSVGElement> & {
+    size?: string | number;
+};
+interface IconProps extends React.HTMLAttributes<HTMLSpanElement>, Omit<VariantProps<typeof iconVariants>, 'size'> {
+    iconNode: React.ComponentType<IconNodeProps>;
+    size?: IconVariantSize | number;
+    /** Apply 1s linear infinite rotation to the inner SVG; also defaults role='status' for a11y. */
+    spin?: boolean;
+}
+/**
+ * Standalone icon with a sized wrapper box (e.g. status indicators, list-item
+ * leaders, themed avatars). Renders `<span><svg/></span>` — the span carries
+ * the `iconVariants` background/border for contained/outlined variants and a
+ * fixed pixel box per `size`.
+ *
+ * **DO NOT** place inside `Button`, `Chip`, `DropdownMenuItem`, or other host
+ * components that already size their SVG children via `:has(> svg)`. The host's
+ * size + padding adjustments only trigger for a direct-child `<svg>`, and
+ * Icon's wrapper span breaks that rule — you end up with the host's default
+ * (wider) padding plus Icon's full-height box (e.g. 1.85rem for `size='sm'`).
+ *
+ * Inside a host that sizes its own svg, pass the raw lucide component directly:
+ *
+ * ```tsx
+ * <Button>
+ *   <CheckIcon />
+ *   Save
+ * </Button>
+ *
+ * <Button>
+ *   <Loader2Icon className={'animate-spin'} />
+ *   Saving…
+ * </Button>
+ * ```
+ *
+ * Use `Icon` only when the wrapper box is desired (standalone use).
+ */
+declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface ListProps extends React.HTMLAttributes<HTMLUListElement | HTMLOListElement> {
+    variant?: 'disc' | 'decimal' | 'none';
+    gap?: number;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    muted?: boolean;
+}
+declare const List: React.ForwardRefExoticComponent<ListProps & React.RefAttributes<HTMLOListElement | HTMLUListElement>>;
+interface ListItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    icon?: React.ReactNode;
+}
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
+
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+
+declare const progressBarVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    rounded?: boolean | null | undefined;
+    animated?: boolean | null | undefined;
+    indeterminate?: boolean | null | undefined;
+    striped?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ProgressBarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof progressBarVariants> {
+    /** Current progress value (0–100). Ignored when `indeterminate` is true. */
+    value?: number;
+    /** Accessible label describing what the progress bar represents. */
+    label?: string;
+}
+declare const ProgressBar: React.ForwardRefExoticComponent<ProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+    decorative?: boolean;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+
+type TrendDirection = 'up' | 'down' | 'neutral';
+type StatCardTheme = 'default' | 'primary' | 'secondary' | 'destructive' | 'warning' | 'success' | 'info' | 'slate';
+type StatCardSize = 'sm' | 'md' | 'lg';
+type StatCardVariant = 'unstyled' | 'outlined' | 'filled';
+type StatCardDirection = 'row' | 'column';
+interface StatCardProps extends React.ComponentPropsWithoutRef<'div'> {
+    /** Text label describing the metric. */
+    label: string;
+    /** The metric value to display. */
+    value?: React.ReactNode;
+    /** Icon displayed beside the metric. */
+    icon?: React.ReactNode;
+    /** Optional description below the value. */
+    description?: string;
+    /** Trend direction indicator. */
+    trend?: TrendDirection;
+    /** Trend label text (e.g. "+12%", "−3.4%"). */
+    trendLabel?: string;
+    /** Visual theme for the card. */
+    theme?: StatCardTheme;
+    /** Card size. */
+    size?: StatCardSize;
+    /** Card Direction. */
+    direction?: StatCardDirection;
+    /** Surface variant. */
+    variant?: StatCardVariant;
+    /**
+     * The element the card renders as.
+     *
+     * A figure that FILTERS the thing it counts is a control, and should be a
+     * real one: `el='button'` makes the whole card the target, so it takes
+     * focus, answers the keyboard, and reads as pressable rather than as a
+     * number that happens to react to a click.
+     */
+    el?: React.ElementType<React.HTMLAttributes<HTMLDivElement>>;
+}
+declare const StatCard: React.ForwardRefExoticComponent<StatCardProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const statusDotVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    glow?: boolean | null | undefined;
+    pulse?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface StatusDotProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color'>, VariantProps<typeof statusDotVariants> {
+    /** A colour outside the theme scale. */
+    color?: string;
+    /** Accessible name. Omit only when adjacent text already says the state. */
+    label?: string;
+}
+/**
+ * The dot that says what state a connection or process is in.
+ *
+ * Deliberately not a `Chip`: a chip is a bordered object that holds a word,
+ * where this is a single mark that usually sits *beside* one. Pairing it with
+ * text is the caller's job, which keeps the wording — and its translation —
+ * out of here.
+ *
+ * `glow` is for the state worth catching in peripheral vision (a save landing);
+ * `pulse` for one that is still in flight.
+ */
+declare const StatusDot: React.ForwardRefExoticComponent<StatusDotProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const stepProgressVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    stretch?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface Step {
+    /** Label displayed next to or below the step indicator. */
+    label: string;
+    /** Optional secondary description below the label. */
+    description?: string;
+    /** Optional icon rendered inside the dot. Defaults to a checkmark for completed steps. */
+    icon?: React.ReactNode;
+}
+interface StepProgressProps extends Omit<React.HTMLAttributes<HTMLOListElement>, 'children'>, VariantProps<typeof stepProgressVariants> {
+    /** Array of step definitions. */
+    steps: Step[];
+    /** Zero-based index of the currently active step. Steps before this are complete. */
+    currentStep: number;
+}
+declare const StepProgress: React.ForwardRefExoticComponent<StepProgressProps & React.RefAttributes<HTMLOListElement>>;
+
+declare const switchVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface SwitchProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'onClick'>, VariantProps<typeof switchVariants> {
+    pressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const TableCard: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Table: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLTableElement> & React.TableHTMLAttributes<HTMLTableElement> & {
+    defaultSort?: SortState;
+}, "ref"> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+interface TableBodyProps extends React.ComponentProps<'tbody'> {
+    showEmptyState?: boolean;
+    emptyState?: React.ReactNode;
+    emptyStateColSpan?: number;
+}
+declare const TableBody: React.ForwardRefExoticComponent<Omit<TableBodyProps, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & React.RefAttributes<HTMLTableRowElement>>;
+type TableHeaderProps = React.ComponentProps<'th'> & {
+    action?: 'sticky';
+};
+declare const TableHeader: React.ForwardRefExoticComponent<Omit<TableHeaderProps, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+type TableCellProps = React.ComponentProps<'td'> & {
+    action?: 'sticky';
+};
+declare const TableCell: React.ForwardRefExoticComponent<Omit<TableCellProps, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+interface TableSortableHeaderProps<Key extends string = string> {
+    label: string;
+    sortKey: Key;
+    defaultSort?: true | SortDirection;
+    action?: 'sticky';
+}
+declare function TableSortableHeader<Key extends string = string>({ label, sortKey, defaultSort, action, }: TableSortableHeaderProps<Key>): React.JSX.Element;
+
+interface TableActionItem {
+    /** Visible label for the action. */
+    label: string;
+    /** Optional icon rendered before the label. */
+    icon?: React.ReactNode;
+    /** Click handler for this action. */
+    onClick?: () => void;
+    /** Whether the action is disabled. */
+    disabled?: boolean;
+    /** Visual variant — `destructive` renders the item in the destructive theme. */
+    variant?: 'default' | 'destructive';
+}
+interface TableActionCellProps extends React.ComponentProps<'div'> {
+    /** Array of actions to display. Renders a single button for one action, or a dropdown for multiple. */
+    actions: TableActionItem[];
+    /** Accessible label for the dropdown trigger button. */
+    dropdownLabel?: string;
+}
+/**
+ * Renders a right-aligned action cell for table rows.
+ *
+ * - **Single action**: renders a visible `<Button>` with the action label and optional icon.
+ * - **Multiple actions**: renders a `...` icon button that opens a `<DropdownMenu>`.
+ */
+declare const TableActionCell: React.ForwardRefExoticComponent<Omit<TableActionCellProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface TableToolbarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /**
+     * Left-aligned controls — typically a search Input plus zero or more
+     * filter SelectFields / DatePickers / Toggles. Children flow horizontally
+     * with `gap` and wrap on narrow screens.
+     */
+    children?: React.ReactNode;
+    /**
+     * Right-aligned slot — for reset / clear / bulk-action buttons. Pushed to
+     * the end of the row via auto-margin; wraps to a new line on narrow
+     * screens if the controls grow too wide.
+     */
+    actions?: React.ReactNode;
+    /**
+     * Render a 1px subtle bottom border to separate the toolbar from the
+     * Table or content below. Default `true`.
+     */
+    divider?: boolean;
+}
+/**
+ * Container for the row of controls (search, filters, actions) that sits
+ * above a `Table` inside a `TableCard`. Presentational only — consumers
+ * own all filter state and search debouncing. The companion to
+ * `TableSearch` for the more common single-search case.
+ */
+declare const TableToolbar: React.ForwardRefExoticComponent<TableToolbarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const toggleVariants: (props?: ({
+    variant?: "outlined" | "contained" | "ghost" | null | undefined;
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "inherit" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+    rounded?: boolean | "extra" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+interface ToggleProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'>, VariantProps<typeof toggleVariants> {
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+    value?: string;
+}
+declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLButtonElement>>;
+
+type ToggleGroupBaseProps = VariantProps<typeof toggleVariants> & {
+    className?: string;
+    children?: React.ReactNode;
+    stretch?: boolean;
+};
+type ToggleGroupSingleProps = ToggleGroupBaseProps & {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type ToggleGroupMultipleProps = ToggleGroupBaseProps & {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type ToggleGroupProps = ToggleGroupSingleProps | ToggleGroupMultipleProps;
+declare const ToggleGroup: React.ForwardRefExoticComponent<ToggleGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Separator as $, Chip as C, DevIndicator as D, DialogDescription as E, DialogFooter as F, DialogHeader as G, DialogOverlay as H, DialogPortal as I, DialogTitle as K, DialogTrigger as L, EmptyState as N, Icon as P, List as R, ListItem as T, Pagination as W, ProgressBar as Y, Alert as a, StatCard as a3, StatusDot as a9, persistAlert as aB, statusDotVariants as aC, StepProgress as ac, Switch as ae, Table as ag, TableActionCell as ah, TableBody as ak, TableCard as am, TableCell as an, TableFooter as ao, TableHead as ap, TableHeader as aq, TableRow as ar, TableSortableHeader as as, TableToolbar as au, Toggle as aw, ToggleGroup as ax, AlertBanner as b, AlertDescription as d, AlertProvider as g, AlertTitle as i, Avatar as j, AvatarFallback as k, AvatarImage as m, ChipSelect as q, CodeBlock as t, Dialog as w, DialogClose as x, DialogContent as z };
+export type { AlertContextValue as A, DialogContentProps as B, DialogProps as J, DialogTriggerProps as M, EmptyStateProps as O, IconProps as Q, SortState as S, ListItemProps as U, ListProps as V, PaginationProps as X, ProgressBarProps as Z, PushAlertInput as _, SeparatorProps as a0, SortContextValue as a1, SortDirection as a2, StatCardDirection as a4, StatCardProps as a5, StatCardSize as a6, StatCardTheme as a7, StatCardVariant as a8, TrendDirection as aA, StatusDotProps as aa, Step as ab, StepProgressProps as ad, SwitchProps as af, TableActionCellProps as ai, TableActionItem as aj, TableBodyProps as al, TableSortableHeaderProps as at, TableToolbarProps as av, ToggleGroupProps as ay, ToggleProps as az, AlertBannerProps as c, AlertMessage as e, AlertProps as f, AlertTheme as h, AvatarFallbackProps as l, AvatarImageProps as n, AvatarProps as o, ChipProps as p, ChipSelectOption as r, ChipSelectProps as s, CodeBlockProps as u, DevIndicatorProps as v, DialogCloseProps as y };