@sentropic/design-system-react 0.1.0

package/dist/catalog.d.ts

@@ -0,0 +1,716 @@
+import React from "react";
+export type Size = "sm" | "md" | "lg";
+export type Tone = "neutral" | "info" | "success" | "warning" | "error";
+export type DataTone = "category1" | "category2" | "category3" | "category4" | "category5" | "category6" | "category7" | "category8";
+type ActionItem = {
+    id?: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+    variant?: "default" | "danger";
+    onClick?: () => void;
+};
+type OptionItem = {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+};
+export type AccordionItem = {
+    id?: string;
+    title: React.ReactNode;
+    content: React.ReactNode;
+    disabled?: boolean;
+};
+export type AccordionProps = React.HTMLAttributes<HTMLDivElement> & {
+    items: AccordionItem[];
+    openIds?: string[];
+    defaultOpenIds?: string[];
+    allowMultiple?: boolean;
+    onChange?: (openIds: string[]) => void;
+};
+export declare function Accordion({ items, openIds, defaultOpenIds, allowMultiple, onChange, className, ...rest }: AccordionProps): import("react/jsx-runtime").JSX.Element;
+export type AlertProps = React.HTMLAttributes<HTMLElement> & {
+    tone?: Exclude<Tone, "neutral">;
+    title: React.ReactNode;
+    message?: React.ReactNode;
+    actions?: React.ReactNode;
+};
+export declare function Alert({ tone, title, message, actions, children, className, ...rest }: AlertProps): import("react/jsx-runtime").JSX.Element;
+export type ChartDatum = {
+    label?: string;
+    x?: string | number;
+    y?: number;
+    value?: number;
+    tone?: DataTone;
+};
+export type AreaChartDatum = ChartDatum;
+export type AreaChartTone = DataTone;
+export type BarChartDatum = ChartDatum;
+export type BarChartTone = DataTone;
+export type LineChartDatum = ChartDatum;
+export type LineChartTone = DataTone;
+export type DonutChartDatum = ChartDatum;
+export type DonutChartTone = DataTone;
+export type ScatterPlotDatum = {
+    x: number;
+    y: number;
+    label?: string;
+    tone?: DataTone;
+};
+export type ScatterPlotTone = DataTone;
+export type StackedBarSegment = {
+    label: string;
+    value: number;
+    tone?: DataTone;
+};
+export type StackedBarDatum = {
+    label: string;
+    segments: StackedBarSegment[];
+};
+export type StackedBarTone = DataTone;
+type ChartProps<T> = React.HTMLAttributes<HTMLElement> & {
+    data: T[];
+    label?: string;
+    width?: number;
+    height?: number;
+};
+export type AreaChartProps = ChartProps<AreaChartDatum>;
+export type BarChartProps = ChartProps<BarChartDatum>;
+export type DonutChartProps = ChartProps<DonutChartDatum>;
+export type LineChartProps = ChartProps<LineChartDatum>;
+export type ScatterPlotProps = ChartProps<ScatterPlotDatum>;
+export type StackedBarChartProps = ChartProps<StackedBarDatum>;
+export declare function AreaChart(props: ChartProps<AreaChartDatum>): import("react/jsx-runtime").JSX.Element;
+export declare function LineChart(props: ChartProps<LineChartDatum>): import("react/jsx-runtime").JSX.Element;
+export declare function BarChart({ data, label, width, height, className, ...rest }: ChartProps<BarChartDatum>): import("react/jsx-runtime").JSX.Element;
+export declare function DonutChart({ data, label, className, ...rest }: ChartProps<DonutChartDatum>): import("react/jsx-runtime").JSX.Element;
+export declare function ScatterPlot({ data, label, className, ...rest }: ChartProps<ScatterPlotDatum>): import("react/jsx-runtime").JSX.Element;
+export declare function StackedBarChart({ data, label, className, ...rest }: ChartProps<StackedBarDatum>): import("react/jsx-runtime").JSX.Element;
+export type AspectRatioProps = React.HTMLAttributes<HTMLDivElement> & {
+    ratio?: number | string;
+};
+export declare function AspectRatio({ ratio, className, style, children, ...rest }: AspectRatioProps): import("react/jsx-runtime").JSX.Element;
+export interface BreadcrumbItem {
+    label: React.ReactNode;
+    href?: string;
+    current?: boolean;
+}
+export type BreadcrumbProps = React.HTMLAttributes<HTMLElement> & {
+    items: BreadcrumbItem[];
+    label?: string;
+};
+export declare function Breadcrumb({ items, label, className, ...rest }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+export type ChatMessageRole = "user" | "assistant" | "system" | "tool";
+export type ChatMessageStatus = "pending" | "processing" | "completed" | "failed" | "idle" | "streaming" | "error" | "sent";
+export type ChatMessageProps = Omit<React.HTMLAttributes<HTMLElement>, "content" | "role"> & {
+    role?: ChatMessageRole;
+    status?: ChatMessageStatus;
+    content?: React.ReactNode;
+    timestamp?: React.ReactNode;
+    actions?: React.ReactNode;
+};
+export declare function ChatMessage({ role, status, content, timestamp, actions, children, className, ...rest }: ChatMessageProps): import("react/jsx-runtime").JSX.Element;
+export type ChatThreadProps = React.HTMLAttributes<HTMLElement> & {
+    messages?: Array<{
+        id: string;
+        role?: ChatMessageRole;
+        content: React.ReactNode;
+        status?: ChatMessageStatus;
+    }>;
+    emptyLabel?: React.ReactNode;
+};
+export declare function ChatThread({ messages, emptyLabel, children, className, ...rest }: ChatThreadProps): import("react/jsx-runtime").JSX.Element;
+export type ChatComposerProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> & {
+    value?: string;
+    placeholder?: string;
+    submitLabel?: React.ReactNode;
+    onSubmit?: (payload: {
+        value: string;
+    }) => void;
+};
+export declare function ChatComposer({ value, placeholder, submitLabel, onSubmit, className, children, ...rest }: ChatComposerProps): import("react/jsx-runtime").JSX.Element;
+export type ChoiceProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    label: React.ReactNode;
+    helperText?: React.ReactNode;
+    invalid?: boolean;
+};
+export type CheckboxProps = ChoiceProps;
+export type RadioProps = ChoiceProps;
+export declare function Checkbox(props: ChoiceProps): import("react/jsx-runtime").JSX.Element;
+export declare function Radio(props: ChoiceProps): import("react/jsx-runtime").JSX.Element;
+export type CodeSnippetProps = React.HTMLAttributes<HTMLPreElement> & {
+    code: string;
+    inline?: boolean;
+};
+export declare function CodeSnippet({ code, inline, className, ...rest }: CodeSnippetProps): import("react/jsx-runtime").JSX.Element;
+export interface ComboboxOption extends OptionItem {
+}
+export type ComboboxProps = Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    label?: React.ReactNode;
+    options: ComboboxOption[];
+    value?: string;
+    size?: Size;
+    placeholder?: string;
+    open?: boolean;
+    allowCustomValue?: boolean;
+    noResultsLabel?: React.ReactNode;
+    onChange?: (value: string) => void;
+    onSelect?: (value: string) => void;
+};
+export declare function Combobox({ label, options, value, size, placeholder, open: controlledOpen, allowCustomValue, noResultsLabel, onChange, onSelect, className, ...rest }: ComboboxProps): import("react/jsx-runtime").JSX.Element;
+export type ContentSwitcherItem = {
+    id?: string;
+    value?: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+};
+export type ContentSwitcherProps = React.HTMLAttributes<HTMLDivElement> & {
+    items: ContentSwitcherItem[];
+    value?: string;
+    activeId?: string;
+    onChange?: (value: string) => void;
+    size?: Size;
+};
+export declare function ContentSwitcher({ items, value, activeId, onChange, size, className, ...rest }: ContentSwitcherProps): import("react/jsx-runtime").JSX.Element;
+export type CopyButtonProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value"> & {
+    text?: string;
+    value?: string;
+    label?: React.ReactNode;
+    copiedLabel?: React.ReactNode;
+    size?: Size;
+};
+export declare function CopyButton({ text: copyText, value, label, copiedLabel, size, className, onClick, ...rest }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;
+export interface DataTableColumn<R = DataTableRow> {
+    key: string;
+    label: React.ReactNode;
+    sortable?: boolean;
+    align?: "start" | "center" | "end";
+    width?: string;
+    render?: (row: R, column: DataTableColumn<R>) => React.ReactNode;
+}
+export interface DataTableRow {
+    id: string;
+    [key: string]: unknown;
+}
+export type DataTableSelectMode = "none" | "single" | "multiple";
+export interface DataTableSort {
+    key: string;
+    direction: "asc" | "desc";
+}
+export type DataTableProps<R extends DataTableRow = DataTableRow> = React.TableHTMLAttributes<HTMLTableElement> & {
+    columns: Array<DataTableColumn<R>>;
+    rows: R[];
+    caption?: React.ReactNode;
+    size?: Size;
+    pageSize?: number;
+    page?: number;
+    totalItems?: number;
+};
+export declare function DataTable<R extends DataTableRow = DataTableRow>({ columns, rows, caption, size, className, pageSize, page, totalItems, ...rest }: DataTableProps<R>): import("react/jsx-runtime").JSX.Element;
+export type DatePickerRange = {
+    start?: string | Date | null;
+    end?: string | Date | null;
+};
+export type DatePickerProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    value?: string;
+    range?: DatePickerRange;
+    size?: Size;
+};
+export declare function DatePicker({ label, value, size, className, ...rest }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export type DrawerProps = React.HTMLAttributes<HTMLElement> & {
+    open?: boolean;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    placement?: "left" | "right";
+    onClose?: () => void;
+};
+export declare function Drawer({ open, title, description, footer, placement, onClose, children, className, ...rest }: DrawerProps): import("react/jsx-runtime").JSX.Element | null;
+export interface DropdownOption extends OptionItem {
+}
+export type DropdownProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    options: DropdownOption[];
+    value?: string;
+    open?: boolean;
+    placeholder?: React.ReactNode;
+    onSelect?: (value: string) => void;
+};
+export declare function Dropdown({ label, options, value, open: controlledOpen, placeholder, onSelect, className, ...rest }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+export type EmptyStateProps = React.HTMLAttributes<HTMLElement> & {
+    title: React.ReactNode;
+    message?: React.ReactNode;
+    action?: React.ReactNode;
+};
+export declare function EmptyState({ title, message, action, children, className, ...rest }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export type FileUploadStatus = "idle" | "uploading" | "complete" | "error";
+export type FileUploadItem = {
+    id?: string;
+    name: string;
+    size?: number;
+    status?: FileUploadStatus;
+    error?: React.ReactNode;
+};
+export type FileUploaderProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    items?: FileUploadItem[];
+    disabled?: boolean;
+};
+export declare function FileUploader({ label, items, disabled, className, ...rest }: FileUploaderProps): import("react/jsx-runtime").JSX.Element;
+export type FooterProps = React.HTMLAttributes<HTMLElement> & {
+    brand?: React.ReactNode;
+    columns?: Array<{
+        title?: React.ReactNode;
+        links: Array<{
+            label: React.ReactNode;
+            href: string;
+        }>;
+    }>;
+    links?: Array<{
+        label: React.ReactNode;
+        href: string;
+    }>;
+    copyright?: React.ReactNode;
+};
+export declare function Footer({ brand, columns, links, copyright, className, ...rest }: FooterProps): import("react/jsx-runtime").JSX.Element;
+export type ForceGraphTone = DataTone;
+export type ForceGraphNode = {
+    id: string;
+    label?: string;
+    group?: string | number;
+    tone?: ForceGraphTone;
+    weight?: number;
+    fx?: number;
+    fy?: number;
+};
+export type ForceGraphEdge = {
+    source: string;
+    target: string;
+    relation?: string;
+    weak?: boolean;
+};
+export type ForceGraphProps = React.HTMLAttributes<HTMLElement> & {
+    nodes: ForceGraphNode[];
+    edges: ForceGraphEdge[];
+    label?: string;
+    selectedIds?: string[];
+    focusId?: string | null;
+    onSelect?: (id: string) => void;
+    onOpenEntity?: (id: string) => void;
+};
+export declare function ForceGraph({ nodes, edges, label, selectedIds, focusId, onSelect, onOpenEntity, className, ...rest }: ForceGraphProps): import("react/jsx-runtime").JSX.Element;
+export type FormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> & {
+    status?: "idle" | "submitting" | "submitted" | "error";
+    message?: React.ReactNode;
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+};
+export declare function Form({ status, message, children, className, ...rest }: FormProps): import("react/jsx-runtime").JSX.Element;
+export type FormGroupProps = React.FieldsetHTMLAttributes<HTMLFieldSetElement> & {
+    legend: React.ReactNode;
+    helperText?: React.ReactNode;
+};
+export declare function FormGroup({ legend, helperText, children, className, ...rest }: FormGroupProps): import("react/jsx-runtime").JSX.Element;
+export type HeaderAccount = {
+    name?: string;
+    email?: string;
+    avatarUrl?: string;
+};
+export declare function deriveInitials(name?: string): string;
+export type HeaderProps = React.HTMLAttributes<HTMLElement> & {
+    brand?: React.ReactNode;
+    title?: React.ReactNode;
+    navigation?: Array<{
+        label: React.ReactNode;
+        href: string;
+    }>;
+    navItems?: Array<{
+        label: React.ReactNode;
+        href: string;
+    }>;
+    account?: HeaderAccount;
+    sticky?: boolean;
+};
+export declare function Header({ brand, title, navigation, navItems, account, sticky, className, ...rest }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export type HighlightTone = Tone;
+export type HighlightProps = React.HTMLAttributes<HTMLElement> & {
+    tone?: HighlightTone;
+    title?: React.ReactNode;
+};
+export declare function Highlight({ tone, title, children, className, ...rest }: HighlightProps): import("react/jsx-runtime").JSX.Element;
+export type IconButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    size?: Size;
+    variant?: "secondary" | "danger" | "ghost";
+};
+export declare function IconButton({ size, variant, type, className, children, ...rest }: IconButtonProps): import("react/jsx-runtime").JSX.Element;
+export type InlineLoadingProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    status?: "active" | "inactive" | "success" | "error";
+};
+export declare function InlineLoading({ label, status, className, ...rest }: InlineLoadingProps): import("react/jsx-runtime").JSX.Element;
+export type LanguageOption = {
+    value: string;
+    label: React.ReactNode;
+};
+export type LanguageSelectorProps = React.HTMLAttributes<HTMLDivElement> & {
+    options: LanguageOption[];
+    value?: string;
+    onChange?: (value: string) => void;
+    open?: boolean;
+};
+export declare function LanguageSelector({ options, value, onChange, open, className, ...rest }: LanguageSelectorProps): import("react/jsx-runtime").JSX.Element;
+export type LinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    muted?: boolean;
+    standalone?: boolean;
+    disabled?: boolean;
+};
+export declare function Link({ muted, standalone, disabled, className, children, ...rest }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export type LoadingStateProps = React.HTMLAttributes<HTMLElement> & {
+    label?: React.ReactNode;
+    title?: React.ReactNode;
+    variant?: "spinner" | "skeleton";
+};
+export declare function LoadingState({ label, title, variant, className, ...rest }: LoadingStateProps): import("react/jsx-runtime").JSX.Element;
+export type MenuActionItem = ActionItem;
+export type MenuDividerItem = {
+    type: "divider";
+    id?: string;
+};
+export type MenuGroupItem = {
+    type: "group";
+    id?: string;
+    label: React.ReactNode;
+    items: MenuActionItem[];
+};
+export type MenuItem = MenuActionItem | MenuDividerItem | MenuGroupItem;
+export type MenuProps = React.HTMLAttributes<HTMLDivElement> & {
+    items: MenuItem[];
+    dense?: boolean;
+    onSelect?: (item: MenuActionItem) => void;
+};
+export declare function Menu({ items, dense, onSelect, className, role, ...rest }: MenuProps): import("react/jsx-runtime").JSX.Element;
+export type MenuPopoverProps = React.HTMLAttributes<HTMLDivElement> & {
+    trigger?: React.ReactNode;
+    items?: MenuItem[];
+    open?: boolean;
+    placement?: "top-start" | "top-end" | "bottom-start" | "bottom-end";
+};
+export declare function MenuPopover({ trigger, items, open, placement, children, className, ...rest }: MenuPopoverProps): import("react/jsx-runtime").JSX.Element;
+export type MenuTriggerButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    open?: boolean;
+};
+export declare function MenuTriggerButton({ open, type, className, children, ...rest }: MenuTriggerButtonProps): import("react/jsx-runtime").JSX.Element;
+export type MessageActionVariant = "default" | "danger";
+export type MessageAction = ActionItem & {
+    variant?: MessageActionVariant;
+};
+export type MessageActionsProps = React.HTMLAttributes<HTMLElement> & {
+    actions: MessageAction[];
+    visibility?: "always" | "hover";
+};
+export declare function MessageActions({ actions, visibility, className, ...rest }: MessageActionsProps): import("react/jsx-runtime").JSX.Element;
+export type MessageStatusBadgeProps = React.HTMLAttributes<HTMLSpanElement> & {
+    status: ChatMessageStatus;
+    tone?: Tone;
+    labels?: Partial<Record<ChatMessageStatus, React.ReactNode>>;
+};
+export declare function MessageStatusBadge({ status, tone, labels, className, ...rest }: MessageStatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+export type ModalProps = React.HTMLAttributes<HTMLElement> & {
+    open?: boolean;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footer?: React.ReactNode;
+    onClose?: () => void;
+};
+export declare function Modal({ open, title, description, footer, onClose, children, className, ...rest }: ModalProps): import("react/jsx-runtime").JSX.Element | null;
+export interface MultiSelectOption extends OptionItem {
+}
+export type MultiSelectProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    options: MultiSelectOption[];
+    value?: string[];
+    values?: string[];
+    size?: Size;
+    open?: boolean;
+    onChange?: (values: string[]) => void;
+};
+export declare function MultiSelect({ label, options, value, values, size, open: controlledOpen, onChange, className, ...rest }: MultiSelectProps): import("react/jsx-runtime").JSX.Element;
+export type NumberInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    errorText?: React.ReactNode;
+    size?: Size;
+};
+export declare function NumberInput({ label, helperText, errorText, size, className, ...rest }: NumberInputProps): import("react/jsx-runtime").JSX.Element;
+export type OrderedListItem = {
+    label: React.ReactNode;
+    children?: OrderedListInput[];
+};
+export type OrderedListInput = React.ReactNode | OrderedListItem;
+export type OrderedListProps = React.OlHTMLAttributes<HTMLOListElement> & {
+    items: OrderedListInput[];
+};
+export declare function OrderedList({ items, className, ...rest }: OrderedListProps): import("react/jsx-runtime").JSX.Element;
+export type OverflowMenuItem = MenuItem;
+export type OverflowMenuProps = React.HTMLAttributes<HTMLDivElement> & {
+    items: OverflowMenuItem[];
+    label?: React.ReactNode;
+    open?: boolean;
+    dense?: boolean;
+    placement?: "top-start" | "top-end" | "bottom-start" | "bottom-end";
+};
+export declare function OverflowMenu({ items, label, open: controlledOpen, dense, placement, className, ...rest }: OverflowMenuProps): import("react/jsx-runtime").JSX.Element;
+export type PaginationProps = React.HTMLAttributes<HTMLElement> & {
+    page: number;
+    pageSize?: number;
+    totalItems?: number;
+    totalPages?: number;
+    pageCount?: number;
+    onPageChange?: (page: number) => void;
+};
+export declare function Pagination({ page, pageSize, totalItems, totalPages, pageCount, onPageChange, className, ...rest }: PaginationProps): import("react/jsx-runtime").JSX.Element;
+export type PaginationNavProps = React.HTMLAttributes<HTMLElement> & {
+    page?: number;
+    totalPages?: number;
+    previousHref?: string;
+    nextHref?: string;
+};
+export declare function PaginationNav({ page, totalPages, previousHref, nextHref, className, ...rest }: PaginationNavProps): import("react/jsx-runtime").JSX.Element;
+export type PasswordInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    errorText?: React.ReactNode;
+    size?: Size;
+};
+export declare function PasswordInput({ label, helperText, errorText, size, className, ...rest }: PasswordInputProps): import("react/jsx-runtime").JSX.Element;
+export type PopoverProps = Omit<React.HTMLAttributes<HTMLElement>, "content"> & {
+    trigger?: React.ReactNode;
+    content?: React.ReactNode;
+    open?: boolean;
+    placement?: "top" | "right" | "bottom" | "left";
+};
+export declare function Popover({ trigger, content, open: controlledOpen, placement, children, className, ...rest }: PopoverProps): import("react/jsx-runtime").JSX.Element;
+export type ProgressBarProps = React.HTMLAttributes<HTMLDivElement> & {
+    label?: React.ReactNode;
+    value?: number;
+    max?: number;
+    tone?: Tone;
+    size?: Size;
+    indeterminate?: boolean;
+};
+export declare function ProgressBar({ label, value, max, tone, size, indeterminate, className, ...rest }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;
+export type ProgressIndicatorStatus = "complete" | "current" | "disabled" | "invalid" | "incomplete";
+export interface ProgressIndicatorItem {
+    id?: string;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    status?: ProgressIndicatorStatus;
+}
+export type ProgressIndicatorProps = React.OlHTMLAttributes<HTMLOListElement> & {
+    items: ProgressIndicatorItem[];
+    orientation?: "horizontal" | "vertical";
+};
+export declare function ProgressIndicator({ items, orientation, className, ...rest }: ProgressIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export type QuoteProps = React.BlockquoteHTMLAttributes<HTMLQuoteElement> & {
+    author?: React.ReactNode;
+    source?: React.ReactNode;
+};
+export declare function Quote({ author, source, children, className, ...rest }: QuoteProps): import("react/jsx-runtime").JSX.Element;
+export type SearchProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & {
+    label?: React.ReactNode;
+    size?: Size;
+    onClear?: () => void;
+};
+export declare function Search({ label, size, onClear, className, ...rest }: SearchProps): import("react/jsx-runtime").JSX.Element;
+export type SelectProps = Omit<React.SelectHTMLAttributes<HTMLSelectElement>, "size"> & {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    errorText?: React.ReactNode;
+    invalid?: boolean;
+    size?: Size;
+    options?: OptionItem[];
+};
+export declare function Select({ label, helperText, errorText, invalid, size, options, className, children, ...rest }: SelectProps): import("react/jsx-runtime").JSX.Element;
+export interface SideNavItem {
+    label: React.ReactNode;
+    href: string;
+    active?: boolean;
+    children?: SideNavItem[];
+}
+export type SideNavProps = React.HTMLAttributes<HTMLElement> & {
+    items: SideNavItem[];
+    label?: string;
+};
+export declare function SideNav({ items, label, className, ...rest }: SideNavProps): import("react/jsx-runtime").JSX.Element;
+export type SkeletonTextProps = React.HTMLAttributes<HTMLDivElement> & {
+    lines?: number;
+    label?: string;
+};
+export declare function SkeletonText({ lines, label, className, ...rest }: SkeletonTextProps): import("react/jsx-runtime").JSX.Element;
+export type SkipLinkProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href?: string;
+};
+export declare function SkipLink({ href, className, children, ...rest }: SkipLinkProps): import("react/jsx-runtime").JSX.Element;
+export type SliderProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & {
+    label?: React.ReactNode;
+    size?: Size;
+};
+export declare function Slider({ label, size, value, defaultValue, min, max, className, ...rest }: SliderProps): import("react/jsx-runtime").JSX.Element;
+export type SparklineProps = React.HTMLAttributes<HTMLElement> & {
+    data: number[];
+    label?: string;
+    tone?: "neutral" | "success" | "warning" | "error";
+};
+export declare function Sparkline({ data, label, tone, className, ...rest }: SparklineProps): import("react/jsx-runtime").JSX.Element;
+export type StreamingMessageEvent = {
+    id: string;
+    label: React.ReactNode;
+    text?: React.ReactNode;
+    status?: ChatMessageStatus;
+};
+export type StreamingMessageMode = "live" | "passive";
+export type StreamingMessageProps = React.HTMLAttributes<HTMLElement> & {
+    text?: React.ReactNode;
+    events?: StreamingMessageEvent[];
+    mode?: StreamingMessageMode;
+};
+export declare function StreamingMessage({ text: messageText, events, mode, className, ...rest }: StreamingMessageProps): import("react/jsx-runtime").JSX.Element;
+export interface StructuredListItem {
+    term?: React.ReactNode;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    value?: React.ReactNode;
+}
+export type StructuredListProps = React.HTMLAttributes<HTMLDListElement> & {
+    items: StructuredListItem[];
+    bordered?: boolean;
+};
+export declare function StructuredList({ items, bordered, className, ...rest }: StructuredListProps): import("react/jsx-runtime").JSX.Element;
+export type SwitchProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    label: React.ReactNode;
+    helperText?: React.ReactNode;
+};
+export declare function Switch({ label, helperText, className, ...rest }: SwitchProps): import("react/jsx-runtime").JSX.Element;
+export interface TableColumn {
+    key: string;
+    label: React.ReactNode;
+    align?: "left" | "center" | "right" | "start" | "end";
+}
+export type TableRow = Record<string, unknown>;
+export type TableProps = React.TableHTMLAttributes<HTMLTableElement> & {
+    columns: TableColumn[];
+    rows: TableRow[];
+    caption?: React.ReactNode;
+};
+export declare function Table({ columns, rows, caption, className, ...rest }: TableProps): import("react/jsx-runtime").JSX.Element;
+export interface TabItem {
+    id?: string;
+    value?: string;
+    label: React.ReactNode;
+    content?: React.ReactNode;
+    disabled?: boolean;
+}
+export type TabsProps = React.HTMLAttributes<HTMLElement> & {
+    items: TabItem[];
+    activeValue?: string;
+    activeId?: string;
+    label?: string;
+    onChange?: (value: string) => void;
+};
+export declare function Tabs({ items, activeValue, activeId, label, onChange, className, ...rest }: TabsProps): import("react/jsx-runtime").JSX.Element;
+export type TagProps = React.HTMLAttributes<HTMLSpanElement> & {
+    tone?: Tone;
+    size?: "sm" | "md";
+    disabled?: boolean;
+    onDismiss?: () => void;
+};
+export declare function Tag({ tone, size, disabled, onDismiss, className, children, ...rest }: TagProps): import("react/jsx-runtime").JSX.Element;
+export type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    errorText?: React.ReactNode;
+    invalid?: boolean;
+};
+export declare function Textarea({ label, helperText, errorText, invalid, className, ...rest }: TextareaProps): import("react/jsx-runtime").JSX.Element;
+export type TileVariant = "static" | "clickable" | "selectable";
+export type TileProps = React.HTMLAttributes<HTMLElement> & {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    variant?: TileVariant;
+    selected?: boolean;
+    disabled?: boolean;
+};
+export declare function Tile({ title, description, variant, selected, disabled, children, className, ...rest }: TileProps): import("react/jsx-runtime").JSX.Element;
+export interface TileGroupItem {
+    value: string;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+}
+export type TileGroupProps = React.HTMLAttributes<HTMLFieldSetElement> & {
+    legend?: React.ReactNode;
+    items: TileGroupItem[];
+    value?: string;
+    disabled?: boolean;
+};
+export declare function TileGroup({ legend, items, value, disabled, className, ...rest }: TileGroupProps): import("react/jsx-runtime").JSX.Element;
+export type ToastItem = {
+    id: string;
+    tone?: Exclude<Tone, "neutral">;
+    title: React.ReactNode;
+    message?: React.ReactNode;
+    actions?: React.ReactNode;
+};
+export type ToastProps = React.HTMLAttributes<HTMLElement> & {
+    tone?: Exclude<Tone, "neutral">;
+    title: React.ReactNode;
+    message?: React.ReactNode;
+    actions?: React.ReactNode;
+    onClose?: () => void;
+    items?: ToastItem[];
+    autoDismiss?: boolean;
+    duration?: number;
+    onDismiss?: (id: string) => void;
+};
+export declare function Toast({ tone, title, message, actions, onClose, items, autoDismiss, duration, onDismiss, children, className, ...rest }: ToastProps): import("react/jsx-runtime").JSX.Element;
+export type ToggleProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+    label: React.ReactNode;
+    helperText?: React.ReactNode;
+    size?: "sm" | "md";
+};
+export declare function Toggle({ label, helperText, size, className, ...rest }: ToggleProps): import("react/jsx-runtime").JSX.Element;
+export type ToggletipProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "content"> & {
+    label: React.ReactNode;
+    content?: React.ReactNode;
+    open?: boolean;
+    placement?: "top" | "bottom" | "start" | "end";
+};
+export declare function Toggletip({ label, content, open: controlledOpen, placement, children, className, ...rest }: ToggletipProps): import("react/jsx-runtime").JSX.Element;
+export type TooltipProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "content"> & {
+    content: React.ReactNode;
+    placement?: "top" | "bottom";
+};
+export declare function Tooltip({ content, placement, children, className, ...rest }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export interface TreeNode {
+    id: string;
+    label: React.ReactNode;
+    children?: TreeNode[];
+    disabled?: boolean;
+}
+export type TreeViewProps = React.HTMLAttributes<HTMLDivElement> & {
+    nodes: TreeNode[];
+    selectedId?: string;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+};
+export declare function TreeView({ nodes, selectedId, expandedIds, defaultExpandedIds, className, ...rest }: TreeViewProps): import("react/jsx-runtime").JSX.Element;
+export type UnorderedListItem = {
+    label: React.ReactNode;
+    children?: UnorderedListInput[];
+};
+export type UnorderedListInput = React.ReactNode | UnorderedListItem;
+export type UnorderedListProps = React.HTMLAttributes<HTMLUListElement> & {
+    items: UnorderedListInput[];
+};
+export declare function UnorderedList({ items, className, ...rest }: UnorderedListProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=catalog.d.ts.map