@synertech/ui 0.39.0

package/dist/index.d.ts

@@ -0,0 +1,2433 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import react__default, { ReactNode, ReactElement, ComponentPropsWithoutRef, ChangeEvent, MouseEvent, RefObject, Dispatch, SetStateAction, HTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes } from 'react';
+
+type AccordionType = "single" | "multiple";
+type AccordionVariant = "default" | "bordered" | "separated" | "ghost";
+type AccordionSize = "sm" | "md" | "lg";
+interface AccordionProps {
+    /** Allow single or multiple items open at once */
+    type?: AccordionType;
+    /** Controlled open item(s) */
+    value?: string | string[];
+    /** Default open item(s) for uncontrolled mode */
+    defaultValue?: string | string[];
+    /** Change callback */
+    onValueChange?: (value: string | string[]) => void;
+    /** Allow collapsing all items (only for type="single") */
+    collapsible?: boolean;
+    /** Visual variant */
+    variant?: AccordionVariant;
+    /** Size */
+    size?: AccordionSize;
+    /** Disable all items */
+    disabled?: boolean;
+    /** Icon position */
+    iconPosition?: "left" | "right";
+    /** Custom chevron icon */
+    icon?: ReactNode;
+    /** Hide the chevron icon */
+    hideIcon?: boolean;
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface AccordionItemProps {
+    /** Unique value for this item */
+    value: string;
+    /** Disable this item */
+    disabled?: boolean;
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface AccordionTriggerProps {
+    /** Additional class names */
+    className?: string;
+    /** Custom icon override for this trigger */
+    icon?: ReactNode;
+    children: ReactNode;
+}
+interface AccordionContentProps {
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+declare function Accordion({ type, value: valueProp, defaultValue, onValueChange, collapsible, variant, size, disabled, iconPosition, icon, hideIcon, className, children, }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ value, disabled: disabledProp, className, children, }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ className, icon: iconOverride, children, }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ className, children, }: AccordionContentProps): react_jsx_runtime.JSX.Element;
+
+interface AdvanceDetachableRenderContext {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    detached: boolean;
+    windowRef: Window | null;
+}
+interface AdvanceDetachableProps<T = unknown> {
+    mode: "detach" | "clone";
+    id: string;
+    title?: string;
+    children: ReactNode | ((ctx: AdvanceDetachableRenderContext) => ReactNode);
+    value?: T;
+    defaultValue?: T;
+    onValueChange?: (next: T) => void;
+    isDetached?: boolean;
+    defaultDetached?: boolean;
+    onDetachedChange?: (detached: boolean) => void;
+    features?: string;
+    target?: string;
+    autoFocus?: boolean;
+    className?: string;
+    placeholderClassName?: string;
+    detachedBodyClassName?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    closeOnMainWindowUnload?: boolean;
+    name?: string;
+    serialize?: (value: T) => string;
+    deserialize?: (raw: string) => T;
+}
+interface AdvanceDetachableRef {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    readonly isDetached: boolean;
+    readonly window: Window | null;
+}
+interface AdvanceDetachableComponent {
+    <T = unknown>(props: AdvanceDetachableProps<T> & React.RefAttributes<AdvanceDetachableRef>): ReactElement | null;
+    displayName?: string;
+}
+declare const AdvanceDetachable: AdvanceDetachableComponent;
+
+interface AvatarProps extends ComponentPropsWithoutRef<"div"> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    variant?: "circle" | "square" | "rounded";
+    border?: boolean;
+}
+declare function Avatar({ src, alt, fallback, size, variant, border, className, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+type BadgeColor = "default" | "primary" | "success" | "warning" | "error" | "info" | "purple" | "indigo" | "teal";
+type BadgeSize = "sm" | "md" | "lg";
+type BadgeVariant = "solid" | "soft" | "outlined" | "subtle";
+interface BadgeProps extends Omit<ComponentPropsWithoutRef<"span">, "color"> {
+    children?: ReactNode;
+    color?: BadgeColor;
+    size?: BadgeSize;
+    variant?: BadgeVariant;
+    dot?: boolean;
+    icon?: ReactNode;
+    pill?: boolean;
+}
+declare function Badge({ children, color, size, variant, dot, icon, pill, className, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace Badge {
+    var displayName: string;
+}
+
+type BannerVariant = "notification" | "hero" | "promotion";
+type BannerType = "info" | "success" | "warning" | "error" | "default";
+interface BannerProps extends Omit<ComponentPropsWithoutRef<"div">, "title"> {
+    children?: ReactNode;
+    variant?: BannerVariant;
+    type?: BannerType;
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    action?: ReactNode;
+    closable?: boolean;
+    onClose?: () => void;
+    backgroundImage?: string;
+    badge?: string;
+    fullWidth?: boolean;
+}
+declare function Banner({ variant, ...props }: BannerProps): react_jsx_runtime.JSX.Element;
+declare namespace Banner {
+    var displayName: string;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    icon?: ReactNode;
+    onClick?: () => void;
+}
+interface BreadcrumbProps extends ComponentPropsWithoutRef<"nav"> {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+    size?: "sm" | "md" | "lg";
+    maxItems?: number;
+    itemColor?: string;
+    activeColor?: string;
+    separatorColor?: string;
+}
+declare function Breadcrumb({ items, separator, size, maxItems, itemColor, activeColor, separatorColor, className, ...props }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
+    label?: string;
+    children?: ReactNode;
+    type?: "button" | "submit" | "reset";
+    size?: "sm" | "md" | "lg" | "xl";
+    loading?: boolean;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    icon?: ReactNode;
+    fullWidth?: boolean;
+    rounded?: "none" | "sm" | "md" | "lg" | "full";
+    bgColor?: string;
+    textColor?: string;
+    focusColor?: string;
+    selected?: boolean;
+    value?: string;
+    showFocusOnClick?: boolean;
+}
+declare function Button({ label, children, onClick, disabled, className, type, size, loading, leftIcon, rightIcon, icon, fullWidth, rounded, bgColor, textColor, focusColor, selected, value, showFocusOnClick, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonGroupProps {
+    children: react__default.ReactNode;
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md" | "lg" | "xl";
+    fullWidth?: boolean;
+    selectedValue?: string;
+    onChange?: (value: string) => void;
+    className?: string;
+}
+declare function ButtonGroup({ children, orientation, size, fullWidth, selectedValue, onChange, className, }: ButtonGroupProps): react_jsx_runtime.JSX.Element;
+
+type CalendarSize = "sm" | "md" | "lg";
+type CalendarColor = "primary" | "success" | "warning" | "error" | "info" | "neutral";
+type CalendarMode = "single" | "multiple" | "range";
+type CalendarWeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+interface CalendarDateRange {
+    from: Date | null;
+    to: Date | null;
+}
+/** Visual/semantic state of a day cell, handed to `renderDay`. */
+interface CalendarDayState {
+    selected: boolean;
+    today: boolean;
+    outside: boolean;
+    disabled: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+}
+interface CalendarLabels {
+    previousMonth?: string;
+    nextMonth?: string;
+    today?: string;
+    clear?: string;
+    monthSelect?: string;
+    yearSelect?: string;
+    weekNumber?: string;
+}
+interface CalendarBaseProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange" | "value" | "defaultValue"> {
+    /** Controlled displayed month (any date within it). */
+    month?: Date;
+    /** Uncontrolled initial displayed month. */
+    defaultMonth?: Date;
+    /** Called with the first day of the new displayed month. */
+    onMonthChange?: (month: Date) => void;
+    /** Number of consecutive months rendered side by side. */
+    numberOfMonths?: number;
+    /** First day of the week — 0 = Sunday … 6 = Saturday. */
+    weekStartsOn?: CalendarWeekStart;
+    /** BCP 47 locale used for month/weekday names. */
+    locale?: string;
+    size?: CalendarSize;
+    color?: CalendarColor;
+    /** Earliest selectable date (inclusive). */
+    minDate?: Date;
+    /** Latest selectable date (inclusive). */
+    maxDate?: Date;
+    /** Extra non-selectable dates, as a list or a predicate. */
+    disabledDates?: Date[] | ((date: Date) => boolean);
+    /** Disable the whole calendar. */
+    disabled?: boolean;
+    /** Render the leading/trailing days of the adjacent months. */
+    showOutsideDays?: boolean;
+    /** Render an ISO week-number column. */
+    showWeekNumbers?: boolean;
+    /** Always render 6 week rows so the height never shifts. */
+    fixedWeeks?: boolean;
+    /** Caption as plain text or as month/year dropdowns. */
+    captionLayout?: "label" | "dropdown";
+    /** First year offered by the year dropdown. */
+    fromYear?: number;
+    /** Last year offered by the year dropdown. */
+    toYear?: number;
+    /** Show a "Today" shortcut in the footer. */
+    todayButton?: boolean;
+    /** Show a "Clear" shortcut in the footer. */
+    clearButton?: boolean;
+    /** Extra footer content, rendered below the grid. */
+    footer?: ReactNode;
+    /** Wrap the calendar in a bordered, rounded surface. */
+    bordered?: boolean;
+    /** Override the content of a day cell. */
+    renderDay?: (date: Date, state: CalendarDayState) => ReactNode;
+    /** Accessible labels for the navigation and footer controls. */
+    labels?: CalendarLabels;
+}
+interface CalendarSingleProps {
+    mode?: "single";
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null) => void;
+}
+interface CalendarMultipleProps {
+    mode: "multiple";
+    value?: Date[];
+    defaultValue?: Date[];
+    onChange?: (dates: Date[]) => void;
+    /** Maximum number of selectable dates. */
+    max?: number;
+}
+interface CalendarRangeProps {
+    mode: "range";
+    value?: CalendarDateRange | null;
+    defaultValue?: CalendarDateRange | null;
+    onChange?: (range: CalendarDateRange) => void;
+}
+type CalendarProps = CalendarBaseProps & (CalendarSingleProps | CalendarMultipleProps | CalendarRangeProps);
+declare function Calendar(props: CalendarProps): react_jsx_runtime.JSX.Element;
+
+interface CardProps extends ComponentPropsWithoutRef<"div"> {
+    variant?: "default" | "outlined" | "elevated" | "filled";
+    size?: "sm" | "md" | "lg";
+    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "full";
+    padding?: "none" | "sm" | "md" | "lg";
+    bgColor?: string;
+    borderColor?: string;
+    shadowColor?: string;
+    hoverable?: boolean;
+    clickable?: boolean;
+    as?: "article" | "section" | "div";
+    children?: ReactNode;
+}
+declare function Card({ variant, size, rounded, padding, bgColor, borderColor, shadowColor, hoverable, clickable, as, className, children, onClick, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var displayName: string;
+}
+
+interface CardHeaderProps extends ComponentPropsWithoutRef<"div"> {
+    actions?: ReactNode;
+    divider?: boolean;
+    padding?: "none" | "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+declare function CardHeader({ actions, divider, padding, className, children, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace CardHeader {
+    var displayName: string;
+}
+
+interface CardBodyProps extends ComponentPropsWithoutRef<"div"> {
+    padding?: "none" | "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+declare function CardBody({ padding, className, children, ...props }: CardBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace CardBody {
+    var displayName: string;
+}
+
+interface CardFooterProps extends ComponentPropsWithoutRef<"div"> {
+    divider?: boolean;
+    align?: "left" | "center" | "right" | "between";
+    padding?: "none" | "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+declare function CardFooter({ divider, align, padding, className, children, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace CardFooter {
+    var displayName: string;
+}
+
+interface CardImageProps extends ComponentPropsWithoutRef<"img"> {
+    position?: "top" | "bottom";
+    aspectRatio?: "auto" | "square" | "video" | "wide";
+    objectFit?: "cover" | "contain" | "fill" | "none";
+    src: string;
+    alt: string;
+}
+declare function CardImage({ position, aspectRatio, objectFit, src, alt, className, ...props }: CardImageProps): react_jsx_runtime.JSX.Element;
+declare namespace CardImage {
+    var displayName: string;
+}
+
+interface CardTitleProps extends ComponentPropsWithoutRef<"h3"> {
+    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    size?: "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+declare function CardTitle({ as, size, className, children, ...props }: CardTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace CardTitle {
+    var displayName: string;
+}
+
+interface CardDescriptionProps extends ComponentPropsWithoutRef<"p"> {
+    size?: "sm" | "md" | "lg";
+    children?: ReactNode;
+}
+declare function CardDescription({ size, className, children, ...props }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
+declare namespace CardDescription {
+    var displayName: string;
+}
+
+interface CheckboxProps extends Omit<ComponentPropsWithoutRef<"input">, "size" | "onChange" | "type"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    label?: ReactNode;
+    description?: string;
+    error?: boolean | string;
+    size?: "sm" | "md" | "lg";
+    labelPosition?: "left" | "right";
+    checkedColor?: string;
+    uncheckedColor?: string;
+    borderColor?: string;
+    labelColor?: string;
+    errorColor?: string;
+    checkmarkColor?: string;
+    hoverColor?: string;
+    focusRingColor?: string;
+    indeterminate?: boolean;
+    icon?: ReactNode;
+    variant?: "default" | "filled" | "outlined";
+    shape?: "square" | "rounded" | "circle";
+    animation?: boolean;
+    showFocusRing?: boolean;
+    className?: string;
+    containerClassName?: string;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface CheckboxGroupProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    label?: ReactNode;
+    description?: string;
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (values: string[]) => void;
+    orientation?: "horizontal" | "vertical";
+    spacing?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    error?: boolean | string;
+    required?: boolean;
+    children: ReactNode;
+    className?: string;
+    labelClassName?: string;
+}
+declare const CheckboxGroup: {
+    ({ label, description, value: controlledValue, defaultValue, onChange, orientation, spacing, disabled, size, error, required, children, className, labelClassName, ...rest }: CheckboxGroupProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface CheckboxGroupItemProps extends Omit<CheckboxProps, "checked" | "onChange"> {
+    value: string;
+}
+declare const CheckboxGroupItem: {
+    ({ value, disabled: itemDisabled, size: itemSize, ...props }: CheckboxGroupItemProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type SortDirection = "asc" | "desc" | null;
+interface SortState {
+    key: string;
+    direction: SortDirection;
+}
+interface FilterValue {
+    column: string;
+    operator: FilterOperator;
+    value: string;
+}
+type FilterOperator = "contains" | "equals" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte" | "between" | "isEmpty" | "isNotEmpty";
+type FilterType = "text" | "number" | "select" | "date";
+type AggregateFunction = "sum" | "avg" | "count" | "min" | "max";
+type Density = "compact" | "default" | "comfortable";
+type SelectionMode = "single" | "multiple";
+type DataGridMode = "client" | "server";
+interface PaginationConfig {
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showPageSizeSelector?: boolean;
+    showTotalItems?: boolean;
+}
+interface ColumnDef<T = unknown> {
+    /** Unique key matching a property in the data object */
+    key: string;
+    /** Header text or ReactNode */
+    header: ReactNode;
+    /** Column width (CSS value) */
+    width?: string | number;
+    /** Minimum column width for resizing */
+    minWidth?: number;
+    /** Maximum column width for resizing */
+    maxWidth?: number;
+    /** Text alignment */
+    align?: "left" | "center" | "right";
+    /** Enable sorting on this column */
+    sortable?: boolean;
+    /** Custom sort comparator */
+    sortComparator?: (a: T, b: T) => number;
+    /** Enable filtering on this column */
+    filterable?: boolean;
+    /** Filter type */
+    filterType?: FilterType;
+    /** Options for select filter */
+    filterOptions?: string[];
+    /** Custom cell renderer */
+    render?: (value: unknown, row: T, rowIndex: number) => ReactNode;
+    /** Custom header renderer */
+    renderHeader?: (column: ColumnDef<T>) => ReactNode;
+    /** Column is resizable */
+    resizable?: boolean;
+    /** Sticky column position */
+    sticky?: "left" | "right";
+    /** Column is hidden */
+    hidden?: boolean;
+    /** Column is editable */
+    editable?: boolean;
+    /** Column type for special behavior */
+    type?: "data" | "actions" | "selection" | "expand";
+    /** Aggregate function for footer */
+    aggregate?: AggregateFunction;
+    /** Custom aggregate renderer */
+    renderAggregate?: (value: number, data: T[]) => ReactNode;
+    /** Custom class for cells in this column */
+    cellClassName?: string;
+    /** Custom class for the header cell */
+    headerClassName?: string;
+    /** Column span function */
+    colSpan?: (row: T, rowIndex: number) => number;
+}
+interface DataGridProps<T = unknown> {
+    /** Column definitions */
+    columns: ColumnDef<T>[];
+    /** Data array */
+    data: T[];
+    /** Unique key extractor for rows */
+    rowKey?: string | ((row: T, index: number) => string);
+    /** Data processing mode */
+    mode?: DataGridMode;
+    /** Enable sorting */
+    sortable?: boolean;
+    /** Enable multi-column sorting */
+    multiSort?: boolean;
+    /** Controlled sort state */
+    sort?: SortState[];
+    /** Default sort state */
+    defaultSort?: SortState[];
+    /** Sort change callback */
+    onSort?: (sort: SortState[]) => void;
+    /** Enable pagination */
+    pagination?: boolean | PaginationConfig;
+    /** Current page (controlled, 1-based) */
+    page?: number;
+    /** Page change callback */
+    onPageChange?: (page: number) => void;
+    /** Page size change callback */
+    onPageSizeChange?: (pageSize: number) => void;
+    /** Total items for server-mode pagination */
+    totalItems?: number;
+    /** Enable row selection */
+    selectable?: boolean;
+    /** Selection mode */
+    selectionMode?: SelectionMode;
+    /** Selected row keys (controlled) */
+    selectedRows?: string[];
+    /** Selection change callback */
+    onSelectionChange?: (selectedKeys: string[]) => void;
+    /** Enable global search */
+    searchable?: boolean;
+    /** Search placeholder */
+    searchPlaceholder?: string;
+    /** Controlled search value */
+    searchValue?: string;
+    /** Search change callback */
+    onSearch?: (value: string) => void;
+    /** Active column filters (controlled) */
+    filters?: FilterValue[];
+    /** Column filter change callback */
+    onFilterChange?: (filters: FilterValue[]) => void;
+    /** Enable expandable rows */
+    expandable?: boolean;
+    /** Render expanded row content */
+    expandedContent?: (row: T, index: number) => ReactNode;
+    /** Controlled expanded row keys */
+    expandedRows?: string[];
+    /** Expand change callback */
+    onExpandChange?: (expandedKeys: string[]) => void;
+    /** Enable inline cell editing */
+    editable?: boolean;
+    /** Cell edit callback */
+    onCellEdit?: (rowKey: string, columnKey: string, value: unknown) => void;
+    /** Enable row drag & drop reorder */
+    reorderable?: boolean;
+    /** Reorder callback */
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    /** Enable column drag & drop reorder */
+    columnReorderable?: boolean;
+    /** Column reorder callback */
+    onColumnReorder?: (fromKey: string, toKey: string) => void;
+    /** Enable column visibility toggle */
+    columnToggle?: boolean;
+    /** Hidden column keys (controlled) */
+    hiddenColumns?: string[];
+    /** Column visibility change callback */
+    onColumnVisibilityChange?: (hiddenKeys: string[]) => void;
+    /** Group rows by column key(s) */
+    groupBy?: string | string[];
+    /** Render custom group header */
+    renderGroupHeader?: (groupKey: string, groupValue: unknown, rows: T[]) => ReactNode;
+    /** Enable export functionality */
+    exportable?: boolean;
+    /** Supported export formats */
+    exportFormats?: ("csv" | "json")[];
+    /** Custom export filename */
+    exportFilename?: string;
+    /** Enable virtual scrolling for large datasets */
+    virtualized?: boolean;
+    /** Row height for virtualization (px) */
+    rowHeight?: number;
+    /** Visible area height for virtualization (px) */
+    virtualHeight?: number;
+    /** Density / padding */
+    density?: Density;
+    /** Striped rows */
+    striped?: boolean;
+    /** Show borders between cells */
+    bordered?: boolean;
+    /** Borderless style */
+    borderless?: boolean;
+    /** Sticky header on vertical scroll */
+    stickyHeader?: boolean;
+    /** Max height with scroll (CSS value) */
+    maxHeight?: string | number;
+    /** Loading state */
+    loading?: boolean;
+    /** Number of skeleton rows to show when loading */
+    loadingRows?: number;
+    /** Custom empty state */
+    emptyState?: ReactNode;
+    /** Show footer with aggregates */
+    showFooter?: boolean;
+    /** Row click callback */
+    onRowClick?: (row: T, index: number) => void;
+    /** Row double-click callback */
+    onRowDoubleClick?: (row: T, index: number) => void;
+    /** Row context menu callback */
+    onRowContextMenu?: (row: T, index: number, event: MouseEvent) => void;
+    /** Additional class names for the wrapper */
+    className?: string;
+    /** Custom row class name */
+    rowClassName?: string | ((row: T, index: number) => string);
+    /** Custom cell class name */
+    cellClassName?: string;
+    /** Custom header class name */
+    headerClassName?: string;
+}
+interface DataGridRef {
+    /** Get currently visible data (after sort/filter/pagination) */
+    getVisibleData: () => unknown[];
+    /** Reset all filters and search */
+    resetFilters: () => void;
+    /** Reset sort state */
+    resetSort: () => void;
+    /** Select all visible rows */
+    selectAll: () => void;
+    /** Deselect all rows */
+    deselectAll: () => void;
+    /** Export data */
+    exportData: (format: "csv" | "json") => void;
+    /** Scroll to a specific row by index */
+    scrollToRow: (index: number) => void;
+}
+declare function DataGridInner<T>(props: DataGridProps<T>, ref: react__default.ForwardedRef<DataGridRef>): react_jsx_runtime.JSX.Element;
+declare const DataGrid: <T = unknown>(props: DataGridProps<T> & {
+    ref?: react__default.Ref<DataGridRef>;
+}) => ReturnType<typeof DataGridInner>;
+
+type ChipVariant = "solid" | "outlined" | "soft" | "dot";
+type ChipSize = "sm" | "md" | "lg";
+type ChipColor = "default" | "primary" | "success" | "warning" | "error" | "info";
+interface ChipProps extends Omit<ComponentPropsWithoutRef<"span">, "color"> {
+    label?: string;
+    children?: ReactNode;
+    variant?: ChipVariant;
+    size?: ChipSize;
+    color?: ChipColor;
+    bgColor?: string;
+    textColor?: string;
+    borderColor?: string;
+    rounded?: "none" | "sm" | "md" | "lg" | "full";
+    icon?: ReactNode;
+    endIcon?: ReactNode;
+    avatar?: ReactNode;
+    onClose?: () => void;
+    closable?: boolean;
+    clickable?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    as?: "span" | "div" | "button";
+}
+declare function Chip({ label, children, variant, size, color, bgColor, textColor, borderColor, rounded, icon, endIcon, avatar, onClose, closable, clickable, selected, disabled, as, className, onClick, ...props }: ChipProps): react_jsx_runtime.JSX.Element;
+declare namespace Chip {
+    var displayName: string;
+}
+
+interface DetachableProps {
+    children: ReactNode;
+    detached?: boolean;
+    defaultDetached?: boolean;
+    onClose?: () => void;
+    onDetach?: () => void;
+    title?: string;
+    width?: number;
+    height?: number;
+    left?: number;
+    top?: number;
+    center?: boolean;
+    copyStyles?: boolean;
+    closeOnParentUnmount?: boolean;
+    className?: string;
+    windowClassName?: string;
+    onPopupBlocked?: () => void;
+}
+interface DetachableRef {
+    detach: () => void;
+    attach: () => void;
+    isDetached: boolean;
+    window: Window | null;
+}
+declare const Detachable: react.ForwardRefExoticComponent<DetachableProps & react.RefAttributes<DetachableRef>>;
+
+type DeviceType = "phone" | "android" | "tablet" | "laptop" | "desktop" | "watch" | "browser";
+type DeviceOrientation = "portrait" | "landscape";
+type DeviceTheme = "light" | "dark";
+type DeviceSize = "sm" | "md" | "lg";
+interface DeviceMockupProps {
+    /** Device type to render */
+    device?: DeviceType;
+    /** Image source to display inside the device screen */
+    src?: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** React content to display inside the device screen */
+    children?: ReactNode;
+    /** Device orientation */
+    orientation?: DeviceOrientation;
+    /** Device frame theme */
+    theme?: DeviceTheme;
+    /** Device size */
+    size?: DeviceSize;
+    /** Show simulated status bar (phone, android, tablet) */
+    showStatusBar?: boolean;
+    /** Time displayed in the status bar */
+    statusBarTime?: string;
+    /** Enable auto-scroll animation for content */
+    animated?: boolean;
+    /** Scroll animation speed in pixels per second */
+    scrollSpeed?: number;
+    /** Frame color override (CSS color value) */
+    frameColor?: string;
+    /** Additional class names for the wrapper */
+    className?: string;
+    /** Additional class names for the screen/content area */
+    contentClassName?: string;
+}
+declare function DeviceMockup({ device, src, alt, children, orientation, theme, size, showStatusBar, statusBarTime, animated, scrollSpeed, frameColor, className, contentClassName, }: DeviceMockupProps): react_jsx_runtime.JSX.Element;
+
+type CircularProgressSize = "xs" | "sm" | "md" | "lg" | "xl";
+type CircularProgressThickness = "thin" | "normal" | "thick";
+type CircularProgressColor = "default" | "primary" | "success" | "warning" | "error" | "info";
+interface CircularProgressProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    value?: number;
+    indeterminate?: boolean;
+    size?: CircularProgressSize;
+    thickness?: CircularProgressThickness;
+    color?: CircularProgressColor;
+    progressColor?: string;
+    trackColor?: string;
+    showValue?: boolean;
+    children?: ReactNode;
+    valueFormat?: (value: number) => string;
+    animated?: boolean;
+}
+declare function CircularProgress({ value, indeterminate, size, thickness, color, progressColor, trackColor, showValue, children, valueFormat, animated, className, ...props }: CircularProgressProps): react_jsx_runtime.JSX.Element;
+declare namespace CircularProgress {
+    var displayName: string;
+}
+
+type DividerOrientation = "horizontal" | "vertical";
+type DividerVariant = "solid" | "dashed" | "dotted";
+type DividerTextAlign = "left" | "center" | "right";
+interface DividerProps extends ComponentPropsWithoutRef<"hr"> {
+    orientation?: DividerOrientation;
+    variant?: DividerVariant;
+    label?: string;
+    textAlign?: DividerTextAlign;
+    thickness?: number;
+    color?: string;
+    spacing?: string;
+}
+declare function Divider({ orientation, variant, label, textAlign, thickness, color, spacing, className, ...props }: DividerProps): react_jsx_runtime.JSX.Element;
+declare namespace Divider {
+    var displayName: string;
+}
+
+/**
+ * Where the focus goes when the dialog opens.
+ *
+ * - `"dialog"` (default): the dialog container itself, so screen readers
+ *   announce its name and description before the content.
+ * - `"first"`: the first focusable element inside the dialog.
+ * - `"none"`: the focus is left untouched.
+ * - a ref: that specific element (falls back to the dialog if unmounted).
+ */
+type DialogInitialFocus = "dialog" | "first" | "none" | RefObject<HTMLElement | null>;
+/**
+ * Where the focus goes when the dialog closes.
+ *
+ * - `true` (default): back to the element that was focused before opening.
+ * - `false`: nothing is restored.
+ * - a ref: that specific element.
+ */
+type DialogReturnFocus = boolean | RefObject<HTMLElement | null>;
+interface UseDialogA11yOptions {
+    /** Whether the dialog is currently rendered. */
+    open: boolean;
+    /** Called when Escape is pressed on the topmost dialog. */
+    onClose?: () => void;
+    /** Close the dialog on Escape. Default `true`. */
+    closeOnEscape?: boolean;
+    /** Keep Tab / Shift+Tab inside the dialog. Default `true`. */
+    trapFocus?: boolean;
+    /** Element focused when the dialog opens. Default `"dialog"`. */
+    initialFocus?: DialogInitialFocus;
+    /** Element focused when the dialog closes. Default `true` (the trigger). */
+    returnFocus?: DialogReturnFocus;
+    /** Mark the rest of the page `inert` + `aria-hidden`. Default `true`. */
+    hideBackground?: boolean;
+    /**
+     * Elements outside the dialog that must stay interactive while it is open
+     * (a clickable overlay, a portalled popover, ...).
+     */
+    keepInteractive?: Array<RefObject<HTMLElement | null> | HTMLElement | null | undefined>;
+    /** Prevent the page behind the dialog from scrolling. Default `true`. */
+    lockScroll?: boolean;
+}
+/** Props to spread on the dialog container. */
+interface DialogA11yProps {
+    role: "dialog";
+    "aria-modal": true;
+    /** Required so the container itself can receive the initial focus. */
+    tabIndex: -1;
+}
+interface UseDialogA11yResult<T extends HTMLElement> {
+    /** Attach to the dialog container (the element holding `dialogProps`). */
+    dialogRef: RefObject<T | null>;
+    dialogProps: DialogA11yProps;
+}
+/**
+ * Turns any container into an accessible modal dialog:
+ * `role="dialog"` + `aria-modal`, initial focus, Tab / Shift+Tab containment,
+ * Escape, focus returned to the trigger, inert background and nested dialog
+ * support (only the topmost one reacts to the keyboard).
+ *
+ * ```tsx
+ * const { dialogRef, dialogProps } = useDialogA11y({ open, onClose });
+ * return open ? <div ref={dialogRef} {...dialogProps} aria-labelledby={titleId}>…</div> : null;
+ * ```
+ */
+declare function useDialogA11y<T extends HTMLElement = HTMLDivElement>(options: UseDialogA11yOptions): UseDialogA11yResult<T>;
+
+type DrawerPosition = "left" | "right" | "top" | "bottom";
+type DrawerSize = "sm" | "md" | "lg" | "xl" | "full" | "half";
+interface DrawerProps {
+    open: boolean;
+    onClose: () => void;
+    children: ReactNode;
+    position?: DrawerPosition;
+    size?: DrawerSize;
+    /** Largeur personnalisée du drawer (ex: "400px", "25rem", "40%"). Prioritaire sur `size` pour les positions left/right. */
+    customWidth?: string;
+    /** Hauteur personnalisée du drawer (ex: "400px", "25rem", "40%"). Prioritaire sur `size` pour les positions top/bottom. */
+    customHeight?: string;
+    showOverlay?: boolean;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    title?: string;
+    footer?: ReactNode;
+    className?: string;
+    overlayClassName?: string;
+    /**
+     * Accessible name of the close button. Defaults to the `closeDrawer` label of
+     * the nearest `UILabelsProvider`.
+     */
+    closeLabel?: string;
+    /**
+     * Accessible name of the drawer when no `title` is rendered. A dialog without
+     * a name is announced as "dialog" only, so provide one of the two.
+     */
+    "aria-label"?: string;
+    /** Keep Tab / Shift+Tab inside the drawer. Default `true`. */
+    trapFocus?: boolean;
+    /** Element focused when the drawer opens. Default `"dialog"`. */
+    initialFocus?: DialogInitialFocus;
+    /** Element focused when the drawer closes. Default `true` (the trigger). */
+    returnFocus?: DialogReturnFocus;
+    /** Prevent the page behind the drawer from scrolling. Default `true`. */
+    lockScroll?: boolean;
+}
+declare function Drawer({ open, onClose, children, position, size, customWidth, customHeight, showOverlay, closeOnOverlayClick, closeOnEscape, title, footer, className, overlayClassName, closeLabel, "aria-label": ariaLabel, trapFocus, initialFocus, returnFocus, lockScroll, }: DrawerProps): react_jsx_runtime.JSX.Element | null;
+declare namespace Drawer {
+    var displayName: string;
+}
+
+interface SelectedFile {
+    file: File;
+    id: string;
+    error?: string;
+}
+interface FileSelectorProps {
+    /** Currently selected files (controlled mode) */
+    value?: File[];
+    /** Callback when files change */
+    onChange?: (files: File[]) => void;
+    /** Accepted file types (MIME types or extensions, e.g. "image/*,.pdf,.docx") */
+    accept?: string;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Maximum file size in bytes (default: 10MB) */
+    maxSize?: number;
+    /** Maximum number of files (only when multiple=true) */
+    maxFiles?: number;
+    /** Selection mode: file only, directory only, or both */
+    mode?: "file" | "directory" | "both";
+    /** Visual variant */
+    variant?: "dropzone" | "button";
+    /** Component size */
+    size?: "sm" | "md" | "lg";
+    /** Disabled state */
+    disabled?: boolean;
+    /** Read-only state (shows files but can't change) */
+    readOnly?: boolean;
+    /** Label text */
+    label?: string;
+    /** Helper text below the component */
+    helperText?: string;
+    /** Error message */
+    error?: string;
+    /** Show file list below the selector */
+    showFileList?: boolean;
+    /** Custom placeholder text for dropzone */
+    placeholder?: string;
+    /** Custom text for the browse button */
+    browseLabel?: string;
+    /** Custom text for the browse folder button (used in "directory" and "both" modes) */
+    browseFolderLabel?: string;
+    /** Custom icon for the dropzone */
+    icon?: ReactNode;
+    /** Callback when a file is rejected (size, type, etc.) */
+    onReject?: (file: File, reason: string) => void;
+    /** Additional class names */
+    className?: string;
+}
+declare function FileSelector({ value, onChange, accept, multiple, maxSize, maxFiles, mode, variant, size, disabled, readOnly, label, helperText, error, showFileList, placeholder, browseLabel, browseFolderLabel, icon, onReject, className, }: FileSelectorProps): react_jsx_runtime.JSX.Element;
+
+type Side$1 = "top" | "right" | "bottom" | "left";
+type Align$1 = "start" | "center" | "end";
+interface DropdownProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnSelect?: boolean;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    modal?: boolean;
+    children: ReactNode;
+}
+interface DropdownContextValue {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    contentRef: RefObject<HTMLDivElement | null>;
+    closeOnSelect: boolean;
+    closeOnClickOutside: boolean;
+    closeOnEscape: boolean;
+    modal: boolean;
+    focusedIndex: number;
+    setFocusedIndex: Dispatch<SetStateAction<number>>;
+    itemsRef: RefObject<(HTMLElement | null)[]>;
+    registerItem: (index: number, element: HTMLElement | null) => void;
+    getNextItemIndex: () => number;
+    triggerId: string;
+    contentId: string;
+}
+declare function useDropdownContext(): DropdownContextValue;
+declare function Dropdown({ open, defaultOpen, onOpenChange, closeOnSelect, closeOnClickOutside, closeOnEscape, modal, children, }: DropdownProps): react_jsx_runtime.JSX.Element;
+declare namespace Dropdown {
+    var displayName: string;
+}
+
+interface DropdownTriggerProps {
+    asChild?: boolean;
+    disabled?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+declare function DropdownTrigger({ asChild, disabled, children, className, }: DropdownTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+
+interface DropdownContentProps {
+    side?: Side$1;
+    align?: Align$1;
+    sideOffset?: number;
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    animation?: "fade" | "scale" | "slide" | "none";
+    portal?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+declare function DropdownContent({ side, align, sideOffset, alignOffset, avoidCollisions, collisionPadding, minWidth, maxWidth, maxHeight, animation, portal, children, className, }: DropdownContentProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownContent {
+    var displayName: string;
+}
+
+interface DropdownItemProps extends Omit<ComponentPropsWithoutRef<"button">, "children"> {
+    children: ReactNode;
+    icon?: ReactNode;
+    iconPosition?: "left" | "right";
+    description?: string;
+    shortcut?: string;
+    variant?: "default" | "danger" | "success";
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+    disabled?: boolean;
+    index?: number;
+}
+declare function DropdownItem({ children, icon, iconPosition, description, shortcut, variant, closeOnSelect: closeOnSelectProp, onSelect, disabled, className, onClick, index: providedIndex, ...rest }: DropdownItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownItem {
+    var displayName: string;
+}
+
+interface DropdownSeparatorProps {
+    className?: string;
+}
+declare function DropdownSeparator({ className }: DropdownSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSeparator {
+    var displayName: string;
+}
+interface DropdownLabelProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function DropdownLabel({ children, className }: DropdownLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownLabel {
+    var displayName: string;
+}
+
+interface DropdownCheckboxItemProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    children: ReactNode;
+    icon?: ReactNode;
+    description?: string;
+    disabled?: boolean;
+    closeOnChange?: boolean;
+    className?: string;
+    index?: number;
+}
+declare function DropdownCheckboxItem({ checked: controlledChecked, defaultChecked, onCheckedChange, children, icon, description, disabled, closeOnChange, className, index: providedIndex, }: DropdownCheckboxItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownCheckboxItem {
+    var displayName: string;
+}
+
+interface DropdownRadioGroupProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    children: ReactNode;
+    className?: string;
+}
+declare function DropdownRadioGroup({ value: controlledValue, defaultValue, onValueChange, children, className, }: DropdownRadioGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownRadioGroup {
+    var displayName: string;
+}
+interface DropdownRadioItemProps {
+    value: string;
+    children: ReactNode;
+    icon?: ReactNode;
+    description?: string;
+    disabled?: boolean;
+    closeOnChange?: boolean;
+    className?: string;
+    index?: number;
+}
+declare function DropdownRadioItem({ value, children, icon, description, disabled, closeOnChange, className, index: providedIndex, }: DropdownRadioItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownRadioItem {
+    var displayName: string;
+}
+
+interface DropdownSubMenuProps {
+    children: ReactNode;
+}
+declare function DropdownSubMenu({ children }: DropdownSubMenuProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSubMenu {
+    var displayName: string;
+}
+interface DropdownSubMenuTriggerProps {
+    children: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+    index?: number;
+}
+declare function DropdownSubMenuTrigger({ children, icon, disabled, className, index: providedIndex, }: DropdownSubMenuTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSubMenuTrigger {
+    var displayName: string;
+}
+interface DropdownSubMenuContentProps {
+    children: ReactNode;
+    sideOffset?: number;
+    className?: string;
+}
+declare function DropdownSubMenuContent({ children, sideOffset, className, }: DropdownSubMenuContentProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSubMenuContent {
+    var displayName: string;
+}
+
+declare function useClickOutside(ref: RefObject<HTMLElement | null>, handler: () => void, enabled?: boolean): void;
+
+interface UseKeyboardNavigationOptions {
+    isOpen: boolean;
+    onClose: () => void;
+    itemsCount: number;
+    focusedIndex: number;
+    setFocusedIndex: Dispatch<SetStateAction<number>>;
+    onSelect?: (index: number) => void;
+    loop?: boolean;
+}
+declare function useKeyboardNavigation({ isOpen, onClose, itemsCount, focusedIndex, setFocusedIndex, onSelect, loop, }: UseKeyboardNavigationOptions): {
+    focusedIndex: number;
+};
+declare function useFocusItem(itemsRef: RefObject<(HTMLElement | null)[]>, focusedIndex: number, isOpen: boolean): void;
+
+type Side = "top" | "right" | "bottom" | "left";
+type Align = "start" | "center" | "end";
+interface UsePositioningOptions {
+    triggerRef: RefObject<HTMLElement | null>;
+    contentRef: RefObject<HTMLElement | null>;
+    isOpen: boolean;
+    side?: Side;
+    align?: Align;
+    sideOffset?: number;
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionPadding?: number;
+}
+interface Position {
+    top: number;
+    left: number;
+    actualSide: Side;
+    actualAlign: Align;
+    isReady: boolean;
+}
+declare function usePositioning({ triggerRef, contentRef, isOpen, side, align, sideOffset, alignOffset, avoidCollisions, collisionPadding, }: UsePositioningOptions): Position;
+
+interface InputStyleProps {
+    size?: "sm" | "md" | "lg";
+    error?: boolean;
+    borderColor?: string;
+    textColor?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    icon?: React.ReactNode;
+    iconPosition?: "left" | "right";
+}
+
+interface InputProps extends Omit<ComponentPropsWithoutRef<"input"> & ComponentPropsWithoutRef<"textarea">, "size">, InputStyleProps {
+    label?: string;
+    inline?: boolean;
+    labelColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    helperText?: string;
+    error?: boolean;
+    hideLabel?: boolean;
+    multiline?: boolean;
+    rows?: number;
+    focused?: boolean;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement | HTMLTextAreaElement>>;
+
+interface MentionSuggestion {
+    id: string;
+    label: string;
+    avatar?: string;
+    data?: Record<string, unknown>;
+}
+interface MentionData {
+    trigger: string;
+    suggestion: MentionSuggestion;
+    startIndex: number;
+    endIndex: number;
+}
+interface MentionInputValue {
+    text: string;
+    mentions: MentionData[];
+}
+
+interface MentionInputProps extends InputStyleProps {
+    label?: string;
+    inline?: boolean;
+    labelColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    helperText?: string;
+    error?: boolean;
+    hideLabel?: boolean;
+    mentionTrigger?: string;
+    suggestions?: MentionSuggestion[];
+    onMentionSearch?: (query: string) => void;
+    onMentionSelect?: (mention: MentionSuggestion) => void;
+    onMentionRemove?: (mention: MentionSuggestion) => void;
+    renderSuggestion?: (suggestion: MentionSuggestion) => React.ReactNode;
+    value?: MentionInputValue;
+    onChange?: (value: MentionInputValue) => void;
+    placeholder?: string;
+    loading?: boolean;
+    maxSuggestions?: number;
+    chipVariant?: ChipVariant;
+    chipColor?: ChipColor;
+    chipSize?: ChipSize;
+}
+declare const MentionInput: react.ForwardRefExoticComponent<MentionInputProps & react.RefAttributes<HTMLDivElement>>;
+
+interface NumberInputProps extends Omit<React.ComponentPropsWithoutRef<"input">, "size" | "type" | "onChange" | "value">, InputStyleProps {
+    label?: string;
+    inline?: boolean;
+    labelColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    helperText?: string;
+    error?: boolean;
+    hideLabel?: boolean;
+    value?: number | null;
+    onChange?: (value: number | null) => void;
+    format?: "number" | "currency" | "percentage" | "decimal";
+    currency?: string;
+    locale?: string;
+    decimals?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    prefix?: string;
+    suffix?: string;
+    thousandSeparator?: boolean;
+    allowNegative?: boolean;
+}
+declare const NumberInput: react.ForwardRefExoticComponent<NumberInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface NavItem {
+    label: string;
+    href?: string;
+    icon?: ReactNode;
+    badge?: string | number;
+    children?: NavItem[];
+    onClick?: () => void;
+    external?: boolean;
+    active?: boolean;
+}
+interface HeaderProps {
+    logo?: ReactNode;
+    logoHref?: string;
+    onLogoClick?: () => void;
+    navItems?: NavItem[];
+    actions?: ReactNode;
+    rightContent?: ReactNode;
+    variant?: "default" | "transparent" | "bordered" | "shadow";
+    size?: "sm" | "md" | "lg";
+    backgroundColor?: string;
+    textColor?: string;
+    hoverColor?: string;
+    navItemTextColor?: string;
+    navItemHoverColor?: string;
+    navItemBgHover?: string;
+    navItemActiveColor?: string;
+    sticky?: boolean;
+    fixed?: boolean;
+    showSearch?: boolean;
+    onSearch?: (query: string) => void;
+    searchPlaceholder?: string;
+    className?: string;
+    containerClassName?: string;
+}
+declare function Header({ logo, logoHref, onLogoClick, navItems, actions, rightContent, variant, size, backgroundColor, textColor, hoverColor, navItemTextColor, navItemHoverColor, navItemBgHover, navItemActiveColor, sticky, fixed, showSearch, onSearch, searchPlaceholder, className, containerClassName, }: HeaderProps): react_jsx_runtime.JSX.Element;
+
+interface HelpButtonProps {
+    content: string | ReactNode;
+    markdown?: boolean;
+    position?: "top" | "bottom" | "left" | "right";
+    size?: "xs" | "sm" | "md" | "lg";
+    className?: string;
+    visible?: boolean;
+    editable?: boolean;
+    onSave?: (content: string) => Promise<boolean> | boolean;
+    onReset?: () => Promise<boolean> | boolean;
+    width?: "sm" | "md" | "lg" | "xl";
+    title?: string;
+}
+interface WithHelpButtonProps extends HelpButtonProps {
+    children: ReactNode;
+}
+declare function HelpButton({ content, markdown, position, size, className, visible, editable, onSave, onReset, width, title }: HelpButtonProps): react_jsx_runtime.JSX.Element | null;
+declare function WithHelpButton({ children, content, markdown, position, size, visible, editable, onSave, onReset, width, title, className }: WithHelpButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ImageUploaderProps {
+    value?: string;
+    onChange: (url: string) => void;
+    onUpload?: (file: File) => Promise<string>;
+    label?: string;
+    maxSize?: number;
+    accept?: string;
+    helpText?: string;
+    disabled?: boolean;
+    className?: string;
+    showUrlInput?: boolean;
+    urlPlaceholder?: string;
+    aspectRatio?: "16/9" | "4/3" | "1/1" | "auto";
+}
+declare function ImageUploader({ value, onChange, onUpload, label, maxSize, accept, helpText, disabled, className, showUrlInput, urlPlaceholder, aspectRatio }: ImageUploaderProps): react_jsx_runtime.JSX.Element;
+
+type IndicatorColor = "default" | "primary" | "success" | "warning" | "error" | "info" | "dark" | "purple" | "indigo" | "teal";
+type IndicatorSize = "xs" | "sm" | "md" | "lg" | "xl";
+type IndicatorPlacement = "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
+type IndicatorVariant = "dot" | "count" | "status" | "legend";
+interface IndicatorProps extends Omit<ComponentPropsWithoutRef<"div">, "color"> {
+    children?: ReactNode;
+    variant?: IndicatorVariant;
+    color?: IndicatorColor;
+    size?: IndicatorSize;
+    placement?: IndicatorPlacement;
+    count?: number;
+    maxCount?: number;
+    label?: string;
+    bordered?: boolean;
+    borderColor?: string;
+    pulse?: boolean;
+    offset?: boolean;
+}
+declare function Indicator({ variant, children, ...props }: IndicatorProps): react_jsx_runtime.JSX.Element;
+declare namespace Indicator {
+    var displayName: string;
+}
+
+type LabelSize = "xs" | "sm" | "md" | "lg" | "xl";
+type LabelColor = "default" | "primary" | "secondary" | "success" | "warning" | "error" | "info" | "muted";
+type LabelVariant = "default" | "light" | "strong";
+type LabelWeight = "normal" | "medium" | "semibold" | "bold";
+interface LabelProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+    size?: LabelSize;
+    color?: LabelColor;
+    variant?: LabelVariant;
+    weight?: LabelWeight;
+    textColor?: string;
+    htmlFor?: string;
+    required?: boolean;
+    requiredIndicator?: ReactNode;
+    optional?: boolean;
+    optionalText?: string;
+    tooltip?: string;
+    icon?: ReactNode;
+    endIcon?: ReactNode;
+    disabled?: boolean;
+    truncate?: boolean;
+    as?: "label" | "span" | "p";
+}
+declare function Label({ children, size, color, variant, weight, textColor, required, requiredIndicator, optional, optionalText, tooltip, icon, endIcon, disabled, truncate, as, className, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
+declare namespace Label {
+    var displayName: string;
+}
+
+interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    children?: ReactNode;
+    buttonLabel?: string;
+    onButtonClick?: () => void | Promise<void>;
+    className?: string;
+    allowFullScreen?: boolean;
+    showSubmit?: boolean;
+    submitLabel?: string;
+    onSubmitClick?: () => void | Promise<void>;
+    showCancel?: boolean;
+    cancelLabel?: string;
+    onCancelClick?: () => void | Promise<void>;
+    buttonsPosition?: "left" | "center" | "right";
+    showHeaderDivider?: boolean;
+    showFooterDivider?: boolean;
+    description?: string;
+    icon?: ReactNode;
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    reverseButtons?: boolean;
+    headerClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    submitClassName?: string;
+    cancelClassName?: string;
+    /**
+     * Accessible name of the close button (also used as its `sr-only` text).
+     * Defaults to the `closeModal` label of the nearest `UILabelsProvider`.
+     */
+    closeLabel?: string;
+    /** Accessible name of the "expand" button. Defaults to the `enterFullScreen` label. */
+    enterFullScreenLabel?: string;
+    /** Accessible name of the "collapse" button. Defaults to the `exitFullScreen` label. */
+    exitFullScreenLabel?: string;
+    /**
+     * Accessible name of the dialog when no visible `title` is rendered
+     * (`title=""`). Ignored otherwise: the title labels the dialog.
+     */
+    "aria-label"?: string;
+    /** Close the modal when Escape is pressed. Default `true`. */
+    closeOnEscape?: boolean;
+    /** Keep Tab / Shift+Tab inside the modal. Default `true`. */
+    trapFocus?: boolean;
+    /** Element focused when the modal opens. Default `"dialog"`. */
+    initialFocus?: DialogInitialFocus;
+    /** Element focused when the modal closes. Default `true` (the trigger). */
+    returnFocus?: DialogReturnFocus;
+    /** Prevent the page behind the modal from scrolling. Default `true`. */
+    lockScroll?: boolean;
+}
+declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PaginationProps extends Omit<ComponentPropsWithoutRef<"nav">, "onChange"> {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    size?: "sm" | "md" | "lg";
+    variant?: "default" | "outlined" | "minimal";
+    showFirstLast?: boolean;
+    siblings?: number;
+    boundaries?: number;
+    disabled?: boolean;
+    labels?: {
+        first?: string;
+        previous?: string;
+        next?: string;
+        last?: string;
+    };
+    totalItems?: number;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (size: number) => void;
+}
+declare function Pagination({ page, totalPages, onPageChange, size, variant, showFirstLast, siblings, boundaries, disabled, labels, totalItems, pageSize, pageSizeOptions, onPageSizeChange, className, ...props }: PaginationProps): react_jsx_runtime.JSX.Element;
+
+type ProgressBarSize = "xs" | "sm" | "md" | "lg" | "xl";
+type ProgressBarColor = "default" | "primary" | "success" | "warning" | "error" | "info";
+type ProgressBarVariant = "default" | "striped" | "gradient";
+interface ProgressBarProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    value?: number;
+    indeterminate?: boolean;
+    size?: ProgressBarSize;
+    color?: ProgressBarColor;
+    variant?: ProgressBarVariant;
+    showValue?: boolean;
+    valueFormat?: (value: number) => string;
+    label?: string;
+    animated?: boolean;
+}
+declare function ProgressBar({ value, indeterminate, size, color, variant, showValue, valueFormat, label, animated, className, ...props }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+declare namespace ProgressBar {
+    var displayName: string;
+}
+
+interface RadioButtonProps extends Omit<ComponentPropsWithoutRef<"input">, "type" | "size" | "onChange"> {
+    label?: string;
+    description?: string;
+    value: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    size?: "sm" | "md" | "lg";
+    variant?: "default" | "filled" | "outlined";
+    labelPosition?: "left" | "right";
+    error?: boolean | string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    checkedColor?: string;
+    uncheckedColor?: string;
+    borderColor?: string;
+    labelColor?: string;
+    errorColor?: string;
+    dotColor?: string;
+    hoverColor?: string;
+    focusRingColor?: string;
+    showFocusRing?: boolean;
+    containerClassName?: string;
+}
+declare const RadioButton: react.ForwardRefExoticComponent<RadioButtonProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    description?: string;
+    disabled?: boolean;
+    keywords?: string[];
+}
+interface SelectProps {
+    options: SelectOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    searchable?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    variant?: "default" | "outlined" | "filled";
+    placeholder?: string;
+    label?: string;
+    description?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    noOptionsText?: string;
+    onSearchChange?: (query: string) => void;
+    name?: string;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    maxHeight?: number;
+}
+declare function Select({ options, value, defaultValue, onValueChange, searchable, clearable, disabled, readOnly, loading, size, variant, placeholder, label, description, helperText, error, required, noOptionsText, onSearchChange, name, className, triggerClassName, contentClassName, maxHeight, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+type SidebarVariant = "default" | "bordered" | "floating";
+type SidebarPosition = "left" | "right";
+interface SidebarProps {
+    /** Controlled collapsed state */
+    collapsed?: boolean;
+    /** Default collapsed state (uncontrolled) */
+    defaultCollapsed?: boolean;
+    /** Collapse change callback */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Width when expanded (px) */
+    expandedWidth?: number;
+    /** Width when collapsed (px) */
+    collapsedWidth?: number;
+    /** Sidebar position */
+    position?: SidebarPosition;
+    /** Visual variant */
+    variant?: SidebarVariant;
+    /** Breakpoint for mobile drawer mode (px) */
+    mobileBreakpoint?: number;
+    /** Controlled mobile open state */
+    mobileOpen?: boolean;
+    /** Mobile open change callback */
+    onMobileOpenChange?: (open: boolean) => void;
+    /** Additional class names */
+    className?: string;
+    /**
+     * Accessible name of the mobile drawer. Defaults to the `sidebar` label of the
+     * nearest `UILabelsProvider`.
+     */
+    "aria-label"?: string;
+    /**
+     * Accessible name of the mobile close button. Defaults to the `closeSidebar`
+     * label of the nearest `UILabelsProvider`.
+     */
+    closeLabel?: string;
+    /** Keep Tab / Shift+Tab inside the mobile drawer. Default `true`. */
+    trapFocus?: boolean;
+    /** Element focused when the mobile drawer opens. Default `"dialog"`. */
+    initialFocus?: DialogInitialFocus;
+    /** Element focused when the mobile drawer closes. Default `true` (the trigger). */
+    returnFocus?: DialogReturnFocus;
+    /** Prevent the page behind the mobile drawer from scrolling. Default `true`. */
+    lockScroll?: boolean;
+    children: ReactNode;
+}
+interface SidebarHeaderProps {
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface SidebarContentProps {
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface SidebarFooterProps {
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface SidebarGroupProps {
+    /** Group label (hidden when collapsed) */
+    label?: string;
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface SidebarItemProps {
+    /** Icon element (always visible) */
+    icon?: ReactNode;
+    /** Item label */
+    label: string;
+    /** Badge content (number, string, or ReactNode) */
+    badge?: ReactNode;
+    /** Badge color */
+    badgeColor?: string;
+    /** Active/selected state */
+    active?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Link href (renders as <a>) */
+    href?: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Tooltip text (shown in collapsed mode, defaults to label) */
+    tooltip?: string;
+    /** Additional class names */
+    className?: string;
+}
+interface SidebarSubMenuProps {
+    /** Icon for the submenu trigger */
+    icon?: ReactNode;
+    /** Submenu label */
+    label: string;
+    /** Badge on the submenu trigger */
+    badge?: ReactNode;
+    /** Default open state */
+    defaultOpen?: boolean;
+    /** Additional class names */
+    className?: string;
+    children: ReactNode;
+}
+interface SidebarToggleProps {
+    /** Additional class names */
+    className?: string;
+}
+interface SidebarContextValue {
+    collapsed: boolean;
+    isMobile: boolean;
+    mobileOpen: boolean;
+    position: SidebarPosition;
+    variant: SidebarVariant;
+    expandedWidth: number;
+    collapsedWidth: number;
+    toggle: () => void;
+    closeMobile: () => void;
+    closeLabel?: string;
+}
+/** Hook to access sidebar state from outside the component tree */
+declare function useSidebar(): SidebarContextValue;
+declare function Sidebar({ collapsed: collapsedProp, defaultCollapsed, onCollapsedChange, expandedWidth, collapsedWidth, position, variant, mobileBreakpoint, mobileOpen: mobileOpenProp, onMobileOpenChange, className, "aria-label": ariaLabel, closeLabel, trapFocus, initialFocus, returnFocus, lockScroll, children, }: SidebarProps): react_jsx_runtime.JSX.Element;
+declare function SidebarHeader({ className, children }: SidebarHeaderProps): react_jsx_runtime.JSX.Element;
+declare function SidebarContent({ className, children }: SidebarContentProps): react_jsx_runtime.JSX.Element;
+declare function SidebarFooter({ className, children }: SidebarFooterProps): react_jsx_runtime.JSX.Element;
+declare function SidebarGroup({ label, className, children, }: SidebarGroupProps): react_jsx_runtime.JSX.Element;
+declare function SidebarItem({ icon, label, badge, badgeColor, active, disabled, href, onClick, tooltip, className, }: SidebarItemProps): react_jsx_runtime.JSX.Element;
+declare function SidebarSubMenu({ icon, label, badge, defaultOpen, className, children, }: SidebarSubMenuProps): react_jsx_runtime.JSX.Element;
+declare function SidebarToggle({ className }: SidebarToggleProps): react_jsx_runtime.JSX.Element;
+
+type SkeletonVariant = "text" | "circular" | "rectangular" | "rounded";
+type SkeletonAnimation = "pulse" | "wave" | "none";
+interface SkeletonProps extends ComponentPropsWithoutRef<"div"> {
+    variant?: SkeletonVariant;
+    animation?: SkeletonAnimation;
+    width?: string | number;
+    height?: string | number;
+    count?: number;
+}
+declare function Skeleton({ variant, animation, width, height, count, className, style, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+declare namespace Skeleton {
+    var displayName: string;
+}
+
+type SliderSize = "sm" | "md" | "lg";
+type SliderColor = "primary" | "success" | "warning" | "error" | "info" | "neutral";
+interface SliderMark {
+    value: number;
+    label?: ReactNode;
+}
+interface SliderProps extends Omit<ComponentPropsWithoutRef<"input">, "type" | "size" | "value" | "defaultValue" | "onChange"> {
+    /** Controlled value. */
+    value?: number;
+    /** Uncontrolled initial value. */
+    defaultValue?: number;
+    /** Called with the new numeric value whenever it changes. */
+    onValueChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: SliderSize;
+    color?: SliderColor;
+    disabled?: boolean;
+    readOnly?: boolean;
+    /** Field label rendered above the track. */
+    label?: string;
+    /** Helper text rendered below the track. */
+    description?: string;
+    /** Error state — `true` for styling only, or a string to display a message. */
+    error?: boolean | string;
+    /** Display the current value next to the label. */
+    showValue?: boolean;
+    /** Display a value bubble above the thumb on hover/focus. */
+    showTooltip?: boolean;
+    /** Format the displayed value (for `showValue` and `showTooltip`). */
+    valueFormat?: (value: number) => string;
+    /** Tick marks — an array of marks, or `true` to auto-generate from the step. */
+    marks?: boolean | SliderMark[];
+    /** Override the track (rail) background color. */
+    trackColor?: string;
+    /** Override the filled portion color. */
+    fillColor?: string;
+    /** Override the thumb color. */
+    thumbColor?: string;
+    /** className applied to the outer container. */
+    containerClassName?: string;
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
+    children: ReactNode;
+}
+declare function Table({ children, className, ...props }: TableProps): react_jsx_runtime.JSX.Element;
+
+interface TableHeaderProps extends HTMLAttributes<HTMLTableSectionElement> {
+    children: ReactNode;
+}
+declare function TableHeader({ children, className, ...props }: TableHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface TableHeaderCellProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+    sortable?: boolean;
+}
+declare function TableHeaderCell({ children, onClick, hidden, className, sortable, ...props }: TableHeaderCellProps): react_jsx_runtime.JSX.Element;
+
+interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    children: ReactNode;
+}
+declare function TableBody({ children, className, ...props }: TableBodyProps): react_jsx_runtime.JSX.Element;
+
+interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    children: ReactNode;
+    clickable?: boolean;
+}
+declare function TableRow({ children, onClick, clickable, className, ...props }: TableRowProps): react_jsx_runtime.JSX.Element;
+
+interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+}
+declare function TableCell({ children, onClick, hidden, className, ...props }: TableCellProps): react_jsx_runtime.JSX.Element;
+
+type TabsVariant = "underline" | "pills" | "enclosed" | "soft";
+type TabsSize = "sm" | "md" | "lg";
+type TabsColor = "default" | "primary" | "secondary" | "success" | "warning" | "error";
+type TabsOrientation = "horizontal" | "vertical";
+
+interface TabsProps {
+    children: ReactNode;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    color?: TabsColor;
+    fullWidth?: boolean;
+    orientation?: TabsOrientation;
+    className?: string;
+}
+declare function Tabs({ children, defaultValue, value: controlledValue, onValueChange, variant, size, color, fullWidth, orientation, className, }: TabsProps): react_jsx_runtime.JSX.Element;
+declare namespace Tabs {
+    var displayName: string;
+}
+
+interface TabsListProps {
+    children: ReactNode;
+    className?: string;
+    bgColor?: string;
+    gap?: "none" | "sm" | "md" | "lg";
+}
+declare function TabsList({ children, className, bgColor, gap }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsList {
+    var displayName: string;
+}
+
+interface TabsTriggerProps {
+    value: string;
+    children: ReactNode;
+    disabled?: boolean;
+    icon?: ReactNode;
+    endIcon?: ReactNode;
+    className?: string;
+    activeClassName?: string;
+    inactiveClassName?: string;
+}
+declare function TabsTrigger({ value, children, disabled, icon, endIcon, className, activeClassName, inactiveClassName, }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsTrigger {
+    var displayName: string;
+}
+
+interface TabsContentProps {
+    value: string;
+    children: ReactNode;
+    className?: string;
+    forceMount?: boolean;
+}
+declare function TabsContent({ value, children, className, forceMount }: TabsContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace TabsContent {
+    var displayName: string;
+}
+
+type ToastVariant = "solid" | "outlined" | "soft";
+type ToastType = "success" | "error" | "warning" | "info" | "default";
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastProps extends Omit<ComponentPropsWithoutRef<"div">, "type"> {
+    children?: ReactNode;
+    title?: string;
+    description?: string;
+    type?: ToastType;
+    variant?: ToastVariant;
+    position?: ToastPosition;
+    icon?: ReactNode;
+    action?: ReactNode;
+    onClose?: () => void;
+    closable?: boolean;
+    duration?: number;
+}
+declare function Toast({ children, title, description, type, variant, icon, action, onClose, closable, className, ...props }: ToastProps): react_jsx_runtime.JSX.Element;
+declare namespace Toast {
+    var displayName: string;
+}
+
+type TooltipPosition = "top" | "bottom" | "left" | "right";
+type TooltipVariant = "default" | "light" | "error" | "success" | "warning" | "info";
+type TooltipSize = "sm" | "md" | "lg";
+type TooltipTrigger = "hover" | "click" | "manual";
+interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "content"> {
+    children: ReactNode;
+    content: ReactNode;
+    position?: TooltipPosition;
+    variant?: TooltipVariant;
+    size?: TooltipSize;
+    trigger?: TooltipTrigger;
+    open?: boolean;
+    delay?: number;
+    showArrow?: boolean;
+    maxWidth?: string;
+    contentClassName?: string;
+    disabled?: boolean;
+    offset?: number;
+}
+declare function Tooltip({ children, content, position, variant, size, trigger, open, delay, showArrow, maxWidth, className, contentClassName, disabled, ...props }: TooltipProps): react_jsx_runtime.JSX.Element;
+declare namespace Tooltip {
+    var displayName: string;
+}
+
+interface FooterProps extends ComponentPropsWithoutRef<"footer"> {
+    variant?: "default" | "bordered" | "minimal" | "dark";
+    size?: "sm" | "md" | "lg";
+    sticky?: boolean;
+    children?: ReactNode;
+}
+declare function Footer({ variant, size, sticky, className, children, ...props }: FooterProps): react_jsx_runtime.JSX.Element;
+declare namespace Footer {
+    var displayName: string;
+}
+
+interface FooterSectionProps extends ComponentPropsWithoutRef<"div"> {
+    title?: string;
+    titleClassName?: string;
+    columns?: 1 | 2 | 3 | 4 | 5 | 6;
+    children?: ReactNode;
+}
+declare function FooterSection({ title, titleClassName, columns, className, children, ...props }: FooterSectionProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterSection {
+    var displayName: string;
+}
+
+interface FooterColumnProps extends ComponentPropsWithoutRef<"div"> {
+    title?: string;
+    titleClassName?: string;
+    children?: ReactNode;
+}
+declare function FooterColumn({ title, titleClassName, className, children, ...props }: FooterColumnProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterColumn {
+    var displayName: string;
+}
+
+interface FooterLinkProps extends ComponentPropsWithoutRef<"a"> {
+    external?: boolean;
+}
+declare function FooterLink({ external, className, children, ...props }: FooterLinkProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterLink {
+    var displayName: string;
+}
+
+interface FooterBottomProps extends ComponentPropsWithoutRef<"div"> {
+    copyright?: string;
+    children?: ReactNode;
+}
+declare function FooterBottom({ copyright, className, children, ...props }: FooterBottomProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterBottom {
+    var displayName: string;
+}
+
+interface FooterSocialProps extends ComponentPropsWithoutRef<"div"> {
+    children?: ReactNode;
+}
+interface FooterSocialLinkProps extends ComponentPropsWithoutRef<"a"> {
+    icon: ReactNode;
+    label: string;
+}
+declare function FooterSocial({ className, children, ...props }: FooterSocialProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterSocial {
+    var displayName: string;
+}
+declare function FooterSocialLink({ icon, label, className, ...props }: FooterSocialLinkProps): react_jsx_runtime.JSX.Element;
+declare namespace FooterSocialLink {
+    var displayName: string;
+}
+
+type SchemaFieldType = "text" | "varchar" | "char" | "int2" | "int4" | "int8" | "serial" | "bigserial" | "float4" | "float8" | "numeric" | "decimal" | "bool" | "date" | "time" | "timestamp" | "timestamptz" | "uuid" | "json" | "jsonb" | "bytea" | (string & {});
+type SchemaField = {
+    id: string;
+    name: string;
+    type: SchemaFieldType;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    defaultValue?: string;
+    foreignKey?: {
+        tableId: string;
+        fieldId: string;
+    } | null;
+};
+type SchemaTable = {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    fields: SchemaField[];
+    collapsed?: boolean;
+    locked?: boolean;
+    color?: string;
+    notes?: string;
+};
+type SchemaRelationCardinality = "1:1" | "1:n" | "n:1" | "n:n";
+type SchemaRelation = {
+    id: string;
+    from: {
+        tableId: string;
+        fieldId: string;
+    };
+    to: {
+        tableId: string;
+        fieldId: string;
+    };
+    cardinality?: SchemaRelationCardinality;
+    label?: string;
+};
+type SchemaViewport = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+type SchemaValue = {
+    tables: SchemaTable[];
+    relations: SchemaRelation[];
+    viewport?: SchemaViewport;
+};
+type SchemaTableEvent = {
+    table: SchemaTable;
+    nativeEvent: globalThis.MouseEvent;
+};
+type SchemaFieldEvent = {
+    table: SchemaTable;
+    field: SchemaField;
+    nativeEvent: globalThis.MouseEvent;
+};
+type SchemaEditorProps = {
+    value?: SchemaValue;
+    defaultValue?: SchemaValue;
+    onValueChange?: (next: SchemaValue) => void;
+    fieldTypes?: SchemaFieldType[];
+    onTableClick?: (event: SchemaTableEvent) => void;
+    onTableDoubleClick?: (event: SchemaTableEvent) => void;
+    onTableContextMenu?: (event: SchemaTableEvent) => void;
+    onFieldClick?: (event: SchemaFieldEvent) => void;
+    onFieldDoubleClick?: (event: SchemaFieldEvent) => void;
+    readOnly?: boolean;
+    disabled?: boolean;
+    draggableTables?: boolean;
+    panOnDrag?: boolean;
+    zoomOnWheel?: boolean;
+    editable?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    snapToGrid?: boolean;
+    gridSize?: number;
+    showGrid?: boolean;
+    toolbar?: boolean;
+    legend?: boolean;
+    autoFit?: boolean;
+    className?: string;
+};
+type SchemaEditorRef = {
+    zoomIn(): void;
+    zoomOut(): void;
+    resetView(): void;
+    fitToContent(): void;
+    addTable(table: SchemaTable): void;
+    removeTable(tableId: string): void;
+    addField(tableId: string, field: SchemaField): void;
+    removeField(tableId: string, fieldId: string): void;
+    addRelation(relation: SchemaRelation): void;
+    removeRelation(relationId: string): void;
+    toJSON(): string;
+    loadJSON(json: string): void;
+    toSQL(): string;
+};
+
+declare const SchemaEditor: (props: SchemaEditorProps & {
+    ref?: React.Ref<SchemaEditorRef>;
+}) => React.ReactElement | null;
+
+declare const DEFAULT_FIELD_TYPES: SchemaFieldType[];
+declare function generateTableId(): string;
+declare function generateFieldId(): string;
+declare function generateRelationId(): string;
+declare function createDefaultField(name?: string): SchemaField;
+declare function createDefaultTable(x: number, y: number, name?: string): SchemaTable;
+
+declare function generateSQL(value: SchemaValue): string;
+
+/**
+ * Simple grid-based auto-layout that arranges tables in rows,
+ * placing tables with foreign key dependencies after their referenced tables.
+ */
+declare function autoLayoutTables(tables: SchemaTable[], editable: boolean): SchemaTable[];
+
+type WorkflowPort = {
+    id: string;
+    kind: "in" | "out";
+    side?: "left" | "right" | "top" | "bottom";
+    label?: string;
+    disabled?: boolean;
+};
+type WorkflowNode<TData = unknown> = {
+    id: string;
+    type: string;
+    x: number;
+    y: number;
+    data: TData;
+    ports?: WorkflowPort[];
+    width?: number;
+    height?: number;
+    locked?: boolean;
+};
+type WorkflowEdge = {
+    id: string;
+    from: {
+        nodeId: string;
+        portId: string;
+    };
+    to: {
+        nodeId: string;
+        portId: string;
+    };
+    label?: string;
+    disabled?: boolean;
+};
+type WorkflowViewport = {
+    x: number;
+    y: number;
+    zoom: number;
+};
+type WorkflowValue<TData = unknown> = {
+    nodes: WorkflowNode<TData>[];
+    edges: WorkflowEdge[];
+    viewport?: WorkflowViewport;
+};
+type WorkflowNodeActionPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left";
+type WorkflowNodeAction<TData = unknown> = {
+    id: string;
+    icon: ReactNode;
+    label?: string;
+    position?: WorkflowNodeActionPosition;
+    hidden?: boolean | ((node: WorkflowNode<TData>) => boolean);
+    className?: string;
+};
+type WorkflowNodeActionEvent<TData = unknown> = {
+    node: WorkflowNode<TData>;
+    actionId: string;
+    nativeEvent: globalThis.MouseEvent;
+};
+type NodeRegistryEntry<TData = unknown> = {
+    title?: string;
+    icon?: ReactNode;
+    render: (args: {
+        node: WorkflowNode<TData>;
+        selected: boolean;
+        disabled: boolean;
+    }) => ReactNode;
+    getPorts?: (node: WorkflowNode<TData>) => WorkflowPort[];
+    actions?: WorkflowNodeAction<TData>[] | ((node: WorkflowNode<TData>) => WorkflowNodeAction<TData>[]);
+    canConnect?: (args: {
+        fromNode: WorkflowNode<TData>;
+        toNode: WorkflowNode<TData>;
+        fromPort: WorkflowPort;
+        toPort: WorkflowPort;
+    }) => boolean;
+};
+type WorkflowDirection = "horizontal" | "vertical";
+type WorkflowNodeEvent<TData = unknown> = {
+    node: WorkflowNode<TData>;
+    nativeEvent: globalThis.MouseEvent;
+};
+type WorkflowEditorProps<TData = unknown> = {
+    value?: WorkflowValue<TData>;
+    defaultValue?: WorkflowValue<TData>;
+    onValueChange?: (next: WorkflowValue<TData>) => void;
+    nodeRegistry: Record<string, NodeRegistryEntry<TData>>;
+    direction?: WorkflowDirection;
+    onDirectionChange?: (direction: WorkflowDirection) => void;
+    onNodeClick?: (event: WorkflowNodeEvent<TData>) => void;
+    onNodeDoubleClick?: (event: WorkflowNodeEvent<TData>) => void;
+    onNodeContextMenu?: (event: WorkflowNodeEvent<TData>) => void;
+    onNodeAction?: (event: WorkflowNodeActionEvent<TData>) => void;
+    readOnly?: boolean;
+    disabled?: boolean;
+    draggableNodes?: boolean;
+    connectable?: boolean;
+    selectable?: boolean;
+    multiSelect?: boolean;
+    panOnDrag?: boolean;
+    zoomOnWheel?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    snapToGrid?: boolean;
+    gridSize?: number;
+    showGrid?: boolean;
+    toolbar?: boolean;
+    autoFit?: boolean;
+    className?: string;
+};
+type WorkflowEditorRef = {
+    zoomIn(): void;
+    zoomOut(): void;
+    resetView(): void;
+    fitToContent(): void;
+    addNode(node: WorkflowNode<unknown>): void;
+    removeNode(nodeId: string): void;
+    toJSON(): string;
+    loadJSON(json: string): void;
+};
+
+declare const WorkflowEditor: <TData = unknown>(props: WorkflowEditorProps<TData> & {
+    ref?: React.Ref<WorkflowEditorRef>;
+}) => React.ReactElement | null;
+
+type WizardOrientation = "horizontal" | "vertical";
+type WizardVariant = "default" | "dots" | "simple";
+type WizardSize = "sm" | "md" | "lg";
+type WizardColor = "primary" | "secondary" | "success" | "warning" | "error";
+type WizardStepStatus = "upcoming" | "active" | "completed" | "error";
+type WizardDirection = "forward" | "backward" | "jump";
+interface WizardStepDefinition {
+    /** Stable identifier (used as React key). Falls back to the index. */
+    id?: string;
+    /** Step title shown in the indicator */
+    title: ReactNode;
+    /** Optional secondary line under the title */
+    description?: ReactNode;
+    /** Custom marker content (replaces the step number) */
+    icon?: ReactNode;
+    /** Mark the step as optional (adds an "(optional)" hint) */
+    optional?: boolean;
+    /** Disable navigation to this step */
+    disabled?: boolean;
+    /** Force the error visual state on this step */
+    error?: boolean;
+}
+interface WizardStepChangeMeta {
+    /** The step index we navigated away from */
+    previous: number;
+    /** Navigation direction */
+    direction: WizardDirection;
+}
+interface WizardContextValue {
+    steps: WizardStepDefinition[];
+    activeStep: number;
+    totalSteps: number;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    orientation: WizardOrientation;
+    variant: WizardVariant;
+    size: WizardSize;
+    color: WizardColor;
+    linear: boolean;
+    /** Navigate to a specific step (respects accessibility rules) */
+    goToStep: (index: number) => void;
+    /** Advance to the next step, or call onComplete on the last step */
+    goNext: () => void;
+    /** Go back to the previous step */
+    goBack: () => void;
+    /** Resolve the visual status of a given step */
+    getStepStatus: (index: number) => WizardStepStatus;
+    /** Whether a step can be navigated to via click */
+    isStepAccessible: (index: number) => boolean;
+}
+/**
+ * Access the surrounding Wizard state. Useful for building custom controls.
+ * Throws when used outside of a `<Wizard>` provider.
+ */
+declare function useWizard(): WizardContextValue;
+interface WizardProps {
+    /** Ordered list of steps that drives the indicator and navigation bounds */
+    steps: WizardStepDefinition[];
+    /** Controlled active step index */
+    step?: number;
+    /** Default active step index for uncontrolled mode */
+    defaultStep?: number;
+    /** Called whenever the active step changes */
+    onStepChange?: (step: number, meta: WizardStepChangeMeta) => void;
+    /** Called when "Next" is pressed on the last step */
+    onComplete?: () => void;
+    /** Indicator orientation */
+    orientation?: WizardOrientation;
+    /** Indicator visual variant */
+    variant?: WizardVariant;
+    /** Size */
+    size?: WizardSize;
+    /** Accent color */
+    color?: WizardColor;
+    /** When true (default), only reached steps can be clicked */
+    linear?: boolean;
+    /** Additional class names on the root element */
+    className?: string;
+    children: ReactNode;
+}
+declare function Wizard({ steps, step: stepProp, defaultStep, onStepChange, onComplete, orientation, variant, size, color, linear, className, children, }: WizardProps): react_jsx_runtime.JSX.Element;
+declare namespace Wizard {
+    var displayName: string;
+}
+interface WizardStepsProps {
+    /** Additional class names on the indicator list */
+    className?: string;
+    /** Hide the connector lines between steps */
+    hideConnector?: boolean;
+    /** Hide step titles/descriptions (markers only) */
+    hideLabels?: boolean;
+}
+declare function WizardSteps({ className, hideConnector, hideLabels, }: WizardStepsProps): react_jsx_runtime.JSX.Element;
+declare namespace WizardSteps {
+    var displayName: string;
+}
+interface WizardPanelProps {
+    /** Step index this panel belongs to */
+    index: number;
+    /** Keep the panel mounted (hidden) when inactive instead of unmounting */
+    keepMounted?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+declare function WizardPanel({ index, keepMounted, className, children }: WizardPanelProps): react_jsx_runtime.JSX.Element | null;
+declare namespace WizardPanel {
+    var displayName: string;
+}
+interface WizardContentProps {
+    className?: string;
+    /** Static content or a render-prop receiving the wizard state */
+    children: ReactNode | ((wizard: WizardContextValue) => ReactNode);
+}
+declare function WizardContent({ className, children }: WizardContentProps): react_jsx_runtime.JSX.Element;
+declare namespace WizardContent {
+    var displayName: string;
+}
+interface WizardPreviousProps extends Omit<ComponentPropsWithoutRef<"button">, "children"> {
+    children?: ReactNode;
+    /** Button text (used when no children are provided) */
+    label?: ReactNode;
+}
+declare function WizardPrevious({ children, label, className, onClick, disabled, ...props }: WizardPreviousProps): react_jsx_runtime.JSX.Element;
+declare namespace WizardPrevious {
+    var displayName: string;
+}
+interface WizardNextProps extends Omit<ComponentPropsWithoutRef<"button">, "children"> {
+    children?: ReactNode;
+    /** Button text on non-final steps */
+    label?: ReactNode;
+    /** Button text on the final step */
+    finishLabel?: ReactNode;
+}
+declare function WizardNext({ children, label, finishLabel, className, onClick, ...props }: WizardNextProps): react_jsx_runtime.JSX.Element;
+declare namespace WizardNext {
+    var displayName: string;
+}
+interface WizardActionsProps {
+    className?: string;
+    /** Custom controls. Defaults to Previous + Next when omitted. */
+    children?: ReactNode;
+    /** Horizontal alignment of the controls */
+    align?: "between" | "start" | "center" | "end";
+}
+declare function WizardActions({ className, children, align }: WizardActionsProps): react_jsx_runtime.JSX.Element;
+declare namespace WizardActions {
+    var displayName: string;
+}
+
+/**
+ * Utility to concatenate class names.
+ * Filters out falsy values and joins with space.
+ */
+declare function cn(...classes: (string | undefined | null | false)[]): string;
+
+/**
+ * Every user-facing string the library renders on its own (mostly the
+ * `aria-label` / `sr-only` text of built-in buttons).
+ *
+ * Each component also exposes a matching prop, so a label can be overridden
+ * globally (provider) or per instance (prop wins).
+ */
+interface UILabels {
+    /** Accessible name of the Modal close button. */
+    closeModal: string;
+    /** Accessible name of the Drawer close button. */
+    closeDrawer: string;
+    /** Accessible name of the Sidebar close button (mobile). */
+    closeSidebar: string;
+    /** Accessible name of the Sidebar toggle when it opens the mobile drawer. */
+    openSidebar: string;
+    /** Accessible name of the Sidebar toggle when it expands a collapsed sidebar. */
+    expandSidebar: string;
+    /** Accessible name of the Sidebar toggle when it collapses the sidebar. */
+    collapseSidebar: string;
+    /** Accessible name of the mobile Sidebar dialog when no `aria-label` is given. */
+    sidebar: string;
+    /** Accessible name of the Modal "expand" button. */
+    enterFullScreen: string;
+    /** Accessible name of the Modal "collapse" button. */
+    exitFullScreen: string;
+    /** Default label of the Modal submit button. */
+    confirm: string;
+    /** Default label of the Modal cancel button. */
+    cancel: string;
+    /** Shown while the optional Markdown editor is being loaded. */
+    markdownEditorLoading: string;
+    /** Shown when the optional `@mdxeditor/editor` package is not installed. */
+    markdownEditorUnavailable: string;
+}
+/** English labels, used when no provider is mounted. */
+declare const defaultUILabels: UILabels;
+/** Ready-to-use French translation. */
+declare const frenchUILabels: UILabels;
+interface UILabelsProviderProps {
+    /** Partial overrides merged over the labels inherited from the parent provider. */
+    labels?: Partial<UILabels>;
+    children: ReactNode;
+}
+/**
+ * Translates the strings built into the library.
+ *
+ * ```tsx
+ * <UILabelsProvider labels={locale === "fr" ? frenchUILabels : defaultUILabels}>
+ *   <App />
+ * </UILabelsProvider>
+ * ```
+ *
+ * Providers can be nested: a subtree only needs to override what differs.
+ */
+declare function UILabelsProvider({ labels, children }: UILabelsProviderProps): react_jsx_runtime.JSX.Element;
+/** Reads the current labels (English defaults when no provider is mounted). */
+declare function useUILabels(): UILabels;
+
+/**
+ * Makes everything outside of a dialog inert for both pointer and assistive
+ * technology users.
+ *
+ * The algorithm walks up from the dialog element to `<body>` and marks every
+ * sibling met on the way with `inert` + `aria-hidden="true"`. Ancestors are
+ * never touched, so the dialog itself stays reachable.
+ *
+ * A reference count is kept per element so that nested dialogs restore the
+ * original attributes in the right order.
+ */
+/** Opt-out attribute for elements that must stay live (toasts, aria-live regions). */
+declare const INERT_IGNORE_ATTRIBUTE = "data-synertech-inert-ignore";
+/**
+ * Declares `layer` as a floating layer owned by `getOwner()`.
+ *
+ * The owner is resolved lazily, because a portal is usually mounted before the
+ * trigger it belongs to.
+ *
+ * @returns a function unregistering the layer.
+ */
+declare function registerFloatingLayer(layer: Element, getOwner: () => Element | null): () => void;
+/** Registered layers whose owner lives inside one of `targets`. */
+declare function findOwnedLayers(targets: Element[]): Element[];
+/**
+ * Hides every element that is neither an ancestor nor a descendant of one of
+ * the `targets` (typically the dialog and, when it must stay clickable, its
+ * overlay).
+ *
+ * @returns a function restoring the previous state (idempotent).
+ */
+declare function hideOthers(targets: Element | Element[]): () => void;
+
+/**
+ * Focus helpers shared by the dialog-like components (Modal, Drawer, ...).
+ *
+ * Dependency-free on purpose: the library ships no runtime dependency for
+ * accessibility primitives.
+ */
+/** Selector matching every element that can potentially receive focus. */
+declare const FOCUSABLE_SELECTOR: string;
+/**
+ * Walks up from `element` and returns false as soon as an ancestor hides it
+ * (`hidden`, `inert`, `aria-hidden`, `display: none`, `visibility: hidden`).
+ *
+ * Layout based checks (`offsetParent`, `getClientRects`) are deliberately not
+ * used: they always report "invisible" in jsdom, which would make the focus
+ * trap untestable.
+ */
+declare function isElementVisible(element: HTMLElement): boolean;
+/** True when `element` can be reached with the Tab key. */
+declare function isFocusable(element: HTMLElement): boolean;
+/**
+ * Every focusable descendant of `container`, in DOM order.
+ *
+ * Positive `tabindex` values are not re-ordered: mixing them with the natural
+ * order is an anti-pattern and the sequence stays predictable this way.
+ */
+declare function getFocusableElements(container: HTMLElement): HTMLElement[];
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionType, type AccordionVariant, AdvanceDetachable, type AdvanceDetachableProps, type AdvanceDetachableRef, type AdvanceDetachableRenderContext, type AggregateFunction, type Align, Avatar, type AvatarProps, Badge, type BadgeColor, type BadgeProps, type BadgeSize, type BadgeVariant, Banner, type BannerProps, type BannerType, type BannerVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, Calendar, type CalendarColor, type CalendarDateRange, type CalendarDayState, type CalendarLabels, type CalendarMode, type CalendarProps, type CalendarSize, type CalendarWeekStart, Card, CardBody, type CardBodyProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardImage, type CardImageProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, CheckboxGroup, CheckboxGroupItem, type CheckboxGroupItemProps, type CheckboxGroupProps, type CheckboxProps, Chip, type ChipColor, type ChipProps, type ChipSize, type ChipVariant, CircularProgress, type CircularProgressColor, type CircularProgressProps, type CircularProgressSize, type CircularProgressThickness, type ColumnDef, DEFAULT_FIELD_TYPES, DataGrid, type DataGridMode, type DataGridProps, type DataGridRef, type Density, Detachable, type DetachableProps, type DetachableRef, DeviceMockup, type DeviceMockupProps, type DeviceOrientation, type DeviceSize, type DeviceTheme, type DeviceType, type DialogA11yProps, type DialogInitialFocus, type DialogReturnFocus, Divider, type DividerOrientation, type DividerProps, type DividerTextAlign, type DividerVariant, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, Dropdown, DropdownCheckboxItem, type DropdownCheckboxItemProps, DropdownContent, type DropdownContentProps, type DropdownContextValue, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownLabelProps, type DropdownProps, DropdownRadioGroup, type DropdownRadioGroupProps, DropdownRadioItem, type DropdownRadioItemProps, DropdownSeparator, type DropdownSeparatorProps, DropdownSubMenu, DropdownSubMenuContent, type DropdownSubMenuContentProps, type DropdownSubMenuProps, DropdownSubMenuTrigger, type DropdownSubMenuTriggerProps, DropdownTrigger, type DropdownTriggerProps, FOCUSABLE_SELECTOR, FileSelector, type FileSelectorProps, type FilterOperator, type FilterType, type FilterValue, Footer, FooterBottom, type FooterBottomProps, FooterColumn, type FooterColumnProps, FooterLink, type FooterLinkProps, type FooterProps, FooterSection, type FooterSectionProps, FooterSocial, FooterSocialLink, type FooterSocialLinkProps, type FooterSocialProps, Header, type HeaderProps, HelpButton, type HelpButtonProps, INERT_IGNORE_ATTRIBUTE, ImageUploader, type ImageUploaderProps, Indicator, type IndicatorColor, type IndicatorPlacement, type IndicatorProps, type IndicatorSize, type IndicatorVariant, Input, type InputProps, Label, type LabelColor, type LabelProps, type LabelSize, type LabelVariant, type LabelWeight, type MentionData, MentionInput, type MentionInputProps, type MentionInputValue, type MentionSuggestion, Modal, type ModalProps, type NavItem, type NodeRegistryEntry, NumberInput, type NumberInputProps, Pagination, type PaginationConfig, type PaginationProps, type Position, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarSize, type ProgressBarVariant, RadioButton, type RadioButtonProps, SchemaEditor, type SchemaEditorProps, type SchemaEditorRef, type SchemaField, type SchemaFieldEvent, type SchemaFieldType, type SchemaRelation, type SchemaRelationCardinality, type SchemaTable, type SchemaTableEvent, type SchemaValue, type SchemaViewport, Select, type SelectOption, type SelectProps, type SelectedFile, type SelectionMode, type Side, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarPosition, type SidebarProps, SidebarSubMenu, type SidebarSubMenuProps, SidebarToggle, type SidebarToggleProps, type SidebarVariant, Skeleton, type SkeletonAnimation, type SkeletonProps, type SkeletonVariant, Slider, type SliderColor, type SliderMark, type SliderProps, type SliderSize, type SortDirection, type SortState, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableHeader, TableHeaderCell, type TableHeaderCellProps, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsColor, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsOrientation, type TabsProps, type TabsSize, TabsTrigger, type TabsTriggerProps, type TabsVariant, Toast, type ToastPosition, type ToastProps, type ToastType, type ToastVariant, Tooltip, type TooltipPosition, type TooltipProps, type TooltipSize, type TooltipTrigger, type TooltipVariant, type UILabels, UILabelsProvider, type UILabelsProviderProps, type UseDialogA11yOptions, type UseDialogA11yResult, type UseKeyboardNavigationOptions, type UsePositioningOptions, WithHelpButton, type WithHelpButtonProps, Wizard, WizardActions, type WizardActionsProps, type WizardColor, WizardContent, type WizardContentProps, type WizardContextValue, type WizardDirection, WizardNext, type WizardNextProps, type WizardOrientation, WizardPanel, type WizardPanelProps, WizardPrevious, type WizardPreviousProps, type WizardProps, type WizardSize, type WizardStepChangeMeta, type WizardStepDefinition, type WizardStepStatus, WizardSteps, type WizardStepsProps, type WizardVariant, type WorkflowDirection, type WorkflowEdge, WorkflowEditor, type WorkflowEditorProps, type WorkflowEditorRef, type WorkflowNode, type WorkflowNodeAction, type WorkflowNodeActionEvent, type WorkflowNodeActionPosition, type WorkflowNodeEvent, type WorkflowPort, type WorkflowValue, type WorkflowViewport, autoLayoutTables, cn, createDefaultField, createDefaultTable, defaultUILabels, findOwnedLayers, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, hideOthers, isElementVisible, isFocusable, registerFloatingLayer, useClickOutside, useDialogA11y, useDropdownContext, useFocusItem, useKeyboardNavigation, usePositioning, useSidebar, useUILabels, useWizard };