@kismet-ux/constellation 1.9.0 → 1.11.1

package/dist/index-DunP9qIK.d.ts

@@ -0,0 +1,537 @@
+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-B56sWYK0.js';
+import { e as TypographyVariant } from './typography-DOZHFR5A.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?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "default" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | null | undefined;
+    variant?: "soft" | "outline" | "solid" | null | undefined;
+    size?: "sm" | "md" | "2xs" | "xs" | 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>>;
+
+declare const codeBlockVariants: (props?: ({
+    theme?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "default" | 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, ...props }: React.HTMLAttributes<HTMLDivElement>): 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;
+};
+declare function DialogContent({ className, children, width, origin, measure, 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?: "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | "default" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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;
+}
+declare const StatCard: React.ForwardRefExoticComponent<StatCardProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const statusDotVariants: (props?: ({
+    theme?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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?: "inherit" | "primary" | "secondary" | "info" | "success" | "warning" | "destructive" | "slate" | 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 { DialogHeader as B, Chip as C, DevIndicator as D, DialogOverlay as E, DialogPortal as F, DialogTitle as H, DialogTrigger as I, EmptyState as K, Icon as M, List as O, ListItem as P, Pagination as T, ProgressBar as V, Separator as Y, Alert as a, StatCard as a0, StatusDot as a6, StepProgress as a9, Switch as ab, Table as ad, TableActionCell as ae, TableBody as ah, TableCard as aj, TableCell as ak, TableFooter as al, TableHead as am, TableHeader as an, TableRow as ao, TableSortableHeader as ap, TableToolbar as ar, Toggle as at, ToggleGroup as au, persistAlert as ay, statusDotVariants as az, AlertBanner as b, AlertDescription as d, AlertProvider as g, AlertTitle as i, Avatar as j, AvatarFallback as k, AvatarImage as m, CodeBlock as q, Dialog as t, DialogClose as u, DialogContent as w, DialogDescription as y, DialogFooter as z };
+export type { SortDirection as $, AlertContextValue as A, DialogProps as G, DialogTriggerProps as J, EmptyStateProps as L, IconProps as N, ListItemProps as Q, ListProps as R, SortState as S, PaginationProps as U, ProgressBarProps as W, PushAlertInput as X, SeparatorProps as Z, SortContextValue as _, StatCardDirection as a1, StatCardProps as a2, StatCardSize as a3, StatCardTheme as a4, StatCardVariant as a5, StatusDotProps as a7, Step as a8, StepProgressProps as aa, SwitchProps as ac, TableActionCellProps as af, TableActionItem as ag, TableBodyProps as ai, TableSortableHeaderProps as aq, TableToolbarProps as as, ToggleGroupProps as av, ToggleProps as aw, TrendDirection as ax, AlertBannerProps as c, AlertMessage as e, AlertProps as f, AlertTheme as h, AvatarFallbackProps as l, AvatarImageProps as n, AvatarProps as o, ChipProps as p, CodeBlockProps as r, DevIndicatorProps as s, DialogCloseProps as v, DialogContentProps as x };