@l3mpire/ui 2.5.1

package/dist/index.d.mts

@@ -0,0 +1,584 @@
+import { ClassValue } from 'clsx';
+import * as React from 'react';
+import { IconDefinition } from '@l3mpire/icons';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as ToastPrimitive from '@radix-ui/react-toast';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ColumnDef, SortingState, OnChangeFn, ColumnFiltersState, PaginationState, RowSelectionState, VisibilityState, ColumnOrderState, ColumnPinningState, Table as Table$1 } from '@tanstack/react-table';
+export { ColumnDef, ColumnFiltersState, RowSelectionState, SortingState, flexRender } from '@tanstack/react-table';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+interface BrowserTabItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    icon?: IconDefinition;
+    label: string;
+    badge?: string;
+    isActive?: boolean;
+    onClose?: (e: React.MouseEvent) => void;
+    /** Called with the new label after double-click rename. Omit to disable rename. */
+    onRename?: (newLabel: string) => void;
+}
+declare const BrowserTabItem: React.ForwardRefExoticComponent<BrowserTabItemProps & React.RefAttributes<HTMLDivElement>>;
+interface BrowserTabProps extends React.HTMLAttributes<HTMLDivElement> {
+    onAddTab?: () => void;
+    /** Enable drag-to-reorder on tab items. */
+    draggable?: boolean;
+    /** Called when a tab is dragged to a new position. */
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    /** Called when a hidden tab is selected from the overflow menu. Swaps it with the last visible tab. */
+    onOverflowSelect?: (hiddenIndex: number, lastVisibleIndex: number) => void;
+}
+declare const BrowserTab: React.ForwardRefExoticComponent<BrowserTabProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const buttonVariants: (props?: ({
+    appearance?: "solid" | "outlined" | "ghost" | null | undefined;
+    intent?: "alert" | "brand" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+    leftIcon?: IconDefinition;
+    rightIcon?: IconDefinition;
+    iconOnly?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const tooltipContentVariants: (props?: ({
+    type?: "invert" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>, VariantProps<typeof tooltipContentVariants> {
+    hasArrow?: boolean;
+}
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const linkVariants: (props?: ({
+    intent?: "success" | "warning" | "neutral" | "alert" | "brand" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement>, VariantProps<typeof linkVariants> {
+    asChild?: boolean;
+    disabled?: boolean;
+    leftIcon?: IconDefinition;
+    rightIcon?: IconDefinition;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+
+interface InputLabelProps extends React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> {
+    type?: "default" | "optional" | "mandatory" | "info";
+    disabled?: boolean;
+    infoIcon?: IconDefinition;
+}
+declare const InputLabel: React.ForwardRefExoticComponent<InputLabelProps & React.RefAttributes<HTMLLabelElement>>;
+
+declare const infoMessageVariants: (props?: ({
+    type?: "success" | "warning" | "alert" | "info" | "empty" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface InfoMessageProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof infoMessageVariants> {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    onClose?: () => void;
+    action?: React.ReactNode;
+    /** Render a semantically-colored link below the description. */
+    linkLabel?: string;
+    linkHref?: string;
+    onLinkClick?: () => void;
+}
+declare const InfoMessage: React.ForwardRefExoticComponent<InfoMessageProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const toastVariants: (props?: ({
+    type?: "success" | "warning" | "alert" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToastProps extends Omit<React.ComponentPropsWithoutRef<typeof ToastPrimitive.Root>, "title" | "type">, VariantProps<typeof toastVariants> {
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    onClose?: () => void;
+    actions?: React.ReactNode;
+}
+declare const ToastProvider: React.FC<ToastPrimitive.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLLIElement>>;
+
+interface SwitchProps extends React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root> {
+    label?: string;
+}
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+
+declare const searchBarVariants: (props?: ({
+    variant?: "white" | "grey" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SearchBarProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof searchBarVariants> {
+    onClear?: () => void;
+    hasShortcut?: boolean;
+}
+declare const SearchBar: React.ForwardRefExoticComponent<SearchBarProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    shape?: "rounded" | "squared" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
+    src?: string;
+    alt?: string;
+    initials?: string;
+    badge?: React.ReactNode;
+    shape?: "rounded" | "squared";
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "solid" | "light" | "outlined" | null | undefined;
+    type?: "primary" | "success" | "critical" | "warning" | "neutral" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "type">, VariantProps<typeof badgeVariants> {
+    icon?: IconDefinition;
+}
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
+    label?: string;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface DropdownMenuProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const DropdownMenu: React.ForwardRefExoticComponent<DropdownMenuProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRoot: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuListProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const DropdownMenuList: React.ForwardRefExoticComponent<DropdownMenuListProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    icon?: IconDefinition;
+    avatar?: React.ReactNode;
+    flag?: React.ReactNode;
+    label: string;
+    description?: string;
+    badge?: React.ReactNode;
+    action?: React.ReactNode;
+    isActive?: boolean;
+}
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuRadixItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    icon?: IconDefinition;
+    avatar?: React.ReactNode;
+    flag?: React.ReactNode;
+    label: string;
+    description?: string;
+    badge?: React.ReactNode;
+    action?: React.ReactNode;
+}
+declare const DropdownMenuRadixItem: React.ForwardRefExoticComponent<DropdownMenuRadixItemProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuHeadingProps extends React.HTMLAttributes<HTMLDivElement> {
+    action?: React.ReactNode;
+}
+declare const DropdownMenuHeading: React.ForwardRefExoticComponent<DropdownMenuHeadingProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuClearProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare const DropdownMenuClear: React.ForwardRefExoticComponent<DropdownMenuClearProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface SidebarContextValue {
+    isCollapsed: boolean;
+    isHovered: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare function useSidebarContext(): SidebarContextValue;
+interface SidebarProps extends React.HTMLAttributes<HTMLElement> {
+    isCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+}
+interface SidebarSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface SidebarFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SidebarHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React.ForwardRefExoticComponent<SidebarProps & React.RefAttributes<HTMLElement>>;
+declare const SidebarSection: React.ForwardRefExoticComponent<SidebarSectionProps & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React.ForwardRefExoticComponent<SidebarFooterProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SidebarHeadingItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    label: string;
+}
+declare const SidebarHeadingItem: React.ForwardRefExoticComponent<SidebarHeadingItemProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const sidebarItemVariants: (props?: ({
+    state?: "default" | "hover" | "active" | null | undefined;
+    type?: "default" | "collapsed" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SidebarItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "type">, VariantProps<typeof sidebarItemVariants> {
+    icon?: IconDefinition;
+    solidIcon?: IconDefinition;
+    avatar?: React.ReactNode;
+    label?: string;
+    hasBadge?: boolean;
+    badgeCount?: string;
+    hasSubItems?: boolean;
+    isNew?: boolean;
+}
+declare const SidebarItem: React.ForwardRefExoticComponent<SidebarItemProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const selectVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SelectProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type">, VariantProps<typeof selectVariants> {
+    error?: boolean;
+    errorMessage?: string;
+    placeholder?: string;
+    value?: string;
+    multiCount?: number;
+    icon?: IconDefinition;
+    avatar?: React.ReactNode;
+    flag?: React.ReactNode;
+    label?: string;
+    labelType?: InputLabelProps["type"];
+    isOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface TabsProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root> {
+}
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+interface TabListProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.List> {
+    /** Add horizontal padding (px-lg) when used inline within a page section. */
+    hasOffset?: boolean;
+}
+declare const TabList: React.ForwardRefExoticComponent<TabListProps & React.RefAttributes<HTMLDivElement>>;
+interface TabTriggerProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger> {
+    badge?: string;
+}
+declare const TabTrigger: React.ForwardRefExoticComponent<TabTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface TabContentProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content> {
+}
+declare const TabContent: React.ForwardRefExoticComponent<TabContentProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const tagVariants: (props?: ({
+    variant?: "neutral" | "brand" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TagProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "type">, VariantProps<typeof tagVariants> {
+    icon?: IconDefinition;
+    onClose?: () => void;
+}
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface TextAreaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "type"> {
+    label?: string;
+    labelType?: InputLabelProps["type"];
+    error?: boolean;
+    errorMessage?: string;
+    success?: boolean;
+    characterLimit?: string;
+}
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+declare const textInputVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size">, VariantProps<typeof textInputVariants> {
+    type?: "text" | "email" | "password" | "number" | "tel" | "url" | "search";
+    label?: string;
+    labelType?: InputLabelProps["type"];
+    error?: boolean;
+    errorMessage?: string;
+    success?: boolean;
+    iconLeft?: IconDefinition;
+    iconRight?: IconDefinition;
+    onClear?: () => void;
+    hasButton?: boolean;
+    buttonIcon?: IconDefinition;
+    onButtonClick?: () => void;
+}
+declare const TextInput: React.ForwardRefExoticComponent<TextInputProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const typographyVariants: (props?: ({
+    variant?: "xs" | "sm" | "md" | "lg" | "h2" | "h3" | "h1" | null | undefined;
+    weight?: "bold" | "regular" | "medium" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TypographyProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof typographyVariants> {
+    as?: React.ElementType;
+    asChild?: boolean;
+}
+declare const Typography: React.ForwardRefExoticComponent<TypographyProps & React.RefAttributes<HTMLElement>>;
+
+interface UserMenuProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const UserMenu: React.ForwardRefExoticComponent<UserMenuProps & React.RefAttributes<HTMLDivElement>>;
+interface UserMenuInfoRowProps extends React.HTMLAttributes<HTMLDivElement> {
+    avatar: React.ReactNode;
+    name: React.ReactNode;
+    subtitle?: React.ReactNode;
+    action?: React.ReactNode;
+}
+declare const UserMenuInfoRow: React.ForwardRefExoticComponent<UserMenuInfoRowProps & React.RefAttributes<HTMLDivElement>>;
+interface UserMenuSectionProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const UserMenuSection: React.ForwardRefExoticComponent<UserMenuSectionProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const productLogoVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type Product = "lemlist" | "lemwarm" | "lemcal";
+interface ProductLogoProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof productLogoVariants> {
+    product?: Product;
+    hasText?: boolean;
+}
+declare const ProductLogo: React.ForwardRefExoticComponent<ProductLogoProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const modalVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Modal: React.FC<DialogPrimitive.DialogProps>;
+declare const ModalTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ModalClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ModalOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ModalContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof modalVariants> {
+}
+declare const ModalContent: React.ForwardRefExoticComponent<ModalContentProps & React.RefAttributes<HTMLDivElement>>;
+interface ModalHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Whether to show the bottom border. Defaults to true. */
+    showBorder?: boolean;
+    /** Called when the close button is clicked. If omitted, no close button is shown. */
+    onClose?: () => void;
+}
+declare const ModalHeader: React.ForwardRefExoticComponent<ModalHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const ModalTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ModalBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+interface ModalFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Whether to show the top border. Defaults to true. */
+    showBorder?: boolean;
+    /** Optional info message to show on the left side of the footer. */
+    infoMessage?: string;
+}
+declare const ModalFooter: React.ForwardRefExoticComponent<ModalFooterProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DialogProps {
+    /** Controls whether the dialog is open. */
+    open?: boolean;
+    /** Called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** The dialog title. */
+    title: string;
+    /** Optional description below the title. */
+    description?: string;
+    /** Intent controls the primary action button color. */
+    intent?: "brand" | "alert";
+    /** Label for the primary action button. */
+    primaryLabel?: string;
+    /** Callback when the primary action is clicked. */
+    onPrimaryAction?: () => void;
+    /** Whether the primary action is disabled. */
+    primaryDisabled?: boolean;
+    /** Label for the cancel button. Defaults to "Cancel". */
+    cancelLabel?: string;
+    /** Callback when cancel is clicked. Defaults to closing the dialog. */
+    onCancel?: () => void;
+    /** Optional secondary action (rendered between cancel and primary). */
+    secondaryLabel?: string;
+    /** Callback for the secondary action. */
+    onSecondaryAction?: () => void;
+    /** Additional className for the content container. */
+    className?: string;
+}
+declare const Dialog: React.ForwardRefExoticComponent<DialogProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const emptyStateVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
+    /** FontAwesome icon to display */
+    icon?: IconDefinition;
+    /** Title text */
+    title: string;
+    /** Optional description text */
+    description?: string;
+    /** Primary action button props */
+    primaryAction?: ButtonProps & {
+        label: string;
+    };
+    /** Secondary action button props */
+    secondaryAction?: ButtonProps & {
+        label: string;
+    };
+}
+declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AvatarCellProps {
+    name: string;
+    subtitle?: string;
+    src?: string;
+    className?: string;
+}
+declare const AvatarCell: React.FC<AvatarCellProps>;
+interface StatusCellProps {
+    label: string;
+    variant?: BadgeProps["variant"];
+    type?: BadgeProps["type"];
+    size?: BadgeProps["size"];
+    className?: string;
+}
+declare const StatusCell: React.FC<StatusCellProps>;
+interface NumberCellProps {
+    value: number | string;
+    /** Optional secondary stat (e.g., "+12%") */
+    secondaryStat?: string;
+    /** Color intent for the secondary stat */
+    secondaryIntent?: "success" | "warning" | "critical" | "neutral";
+    /** Number formatting options */
+    formatOptions?: Intl.NumberFormatOptions;
+    locale?: string;
+    align?: "left" | "right";
+    className?: string;
+}
+declare const NumberCell: React.FC<NumberCellProps>;
+interface DateCellProps {
+    date: Date | string;
+    format?: Intl.DateTimeFormatOptions;
+    locale?: string;
+    className?: string;
+}
+declare const DateCell: React.FC<DateCellProps>;
+interface EmailCellProps {
+    email: string;
+    className?: string;
+}
+declare const EmailCell: React.FC<EmailCellProps>;
+interface LinkCellProps {
+    href: string;
+    label?: string;
+    target?: string;
+    className?: string;
+}
+declare const LinkCell: React.FC<LinkCellProps>;
+interface TextCellProps {
+    value: string;
+    secondary?: boolean;
+    className?: string;
+}
+declare const TextCell: React.FC<TextCellProps>;
+interface ButtonCellProps extends ButtonProps {
+    className?: string;
+}
+declare const ButtonCell: React.FC<ButtonCellProps>;
+interface EditableCellProps {
+    value: string;
+    onSave: (value: string) => void;
+    className?: string;
+}
+declare const EditableCell: React.FC<EditableCellProps>;
+interface RowActionsProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare const RowActions: React.FC<RowActionsProps>;
+
+interface DataTableProps<TData, TValue> {
+    /** Column definitions — see TanStack Table docs */
+    columns: ColumnDef<TData, TValue>[];
+    /** Row data array */
+    data: TData[];
+    /** Enable client-side sorting */
+    enableSorting?: boolean;
+    /** Enable client-side column filtering */
+    enableFiltering?: boolean;
+    /** Enable client-side pagination */
+    enablePagination?: boolean;
+    /** Enable row selection via checkbox */
+    enableRowSelection?: boolean;
+    /** Enable column visibility toggling */
+    enableColumnVisibility?: boolean;
+    /** Enable column pinning */
+    enableColumnPinning?: boolean;
+    /** Enable column resizing */
+    enableColumnResizing?: boolean;
+    /** Enable column drag reordering */
+    enableColumnDrag?: boolean;
+    /** Controlled sorting state */
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
+    /** Controlled column filters state */
+    columnFilters?: ColumnFiltersState;
+    onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;
+    /** Controlled pagination state */
+    pagination?: PaginationState;
+    onPaginationChange?: OnChangeFn<PaginationState>;
+    /** Controlled row selection state */
+    rowSelection?: RowSelectionState;
+    onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+    /** Controlled column visibility state */
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    /** Controlled column order state */
+    columnOrder?: ColumnOrderState;
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+    /** Controlled column pinning state */
+    columnPinning?: ColumnPinningState;
+    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+    /** Render prop to access the table instance for external controls */
+    children?: (table: Table$1<TData>) => React.ReactNode;
+    /** className for the table wrapper */
+    className?: string;
+    /** Custom empty state (renders inside a full-width cell) */
+    emptyState?: React.ReactNode;
+    /** Simple empty message string (fallback if emptyState not provided) */
+    emptyMessage?: React.ReactNode;
+    /** Add border-top to the header (useful in full-width / no container layouts) */
+    bordered?: boolean;
+}
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData extends unknown, TValue> {
+        icon?: IconDefinition;
+        enableDrag?: boolean;
+        filterType?: "string" | "number" | "date" | "select";
+        filterOptions?: string[];
+    }
+}
+type FilterOperator = "contains" | "does_not_contain" | "is" | "is_not" | "starts_with" | "ends_with" | "is_empty" | "is_not_empty" | "equals" | "not_equals" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "between" | "is_before" | "is_after" | "is_between" | "is_any_of" | "is_none_of";
+declare function DataTableInner<TData, TValue>({ columns, data, enableSorting, enableFiltering, enablePagination, enableRowSelection, enableColumnVisibility, enableColumnPinning, enableColumnResizing, enableColumnDrag, sorting: sortingProp, onSortingChange, columnFilters: columnFiltersProp, onColumnFiltersChange, pagination: paginationProp, onPaginationChange, rowSelection: rowSelectionProp, onRowSelectionChange, columnVisibility: columnVisibilityProp, onColumnVisibilityChange, columnOrder: columnOrderProp, onColumnOrderChange, columnPinning: columnPinningProp, onColumnPinningChange, children, className, emptyState, emptyMessage, bordered, }: DataTableProps<TData, TValue>): react_jsx_runtime.JSX.Element;
+interface DataTablePaginationProps<TData> {
+    table: Table$1<TData>;
+    pageSizeOptions?: number[];
+    className?: string;
+}
+declare function DataTablePagination<TData>({ table, pageSizeOptions, className, }: DataTablePaginationProps<TData>): react_jsx_runtime.JSX.Element;
+declare const DataTable: typeof DataTableInner & {
+    displayName: string;
+};
+
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const SidePanel: React.FC<DialogPrimitive.DialogProps>;
+declare const SidePanelTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SidePanelClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+interface SidePanelContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    /** Whether to show the overlay behind the panel. Defaults to true. */
+    overlay?: boolean;
+}
+declare const SidePanelContent: React.ForwardRefExoticComponent<SidePanelContentProps & React.RefAttributes<HTMLDivElement>>;
+
+export { Avatar, AvatarCell, type AvatarCellProps, type AvatarProps, Badge, type BadgeProps, BrowserTab, BrowserTabItem, type BrowserTabItemProps, type BrowserTabProps, Button, ButtonCell, type ButtonCellProps, type ButtonProps, Checkbox, type CheckboxProps, DataTable, DataTablePagination, type DataTablePaginationProps, type DataTableProps, DateCell, type DateCellProps, Dialog, type DialogProps, DropdownMenu, DropdownMenuClear, type DropdownMenuClearProps, DropdownMenuContent, DropdownMenuHeading, type DropdownMenuHeadingProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuList, type DropdownMenuListProps, type DropdownMenuProps, DropdownMenuRadixItem, type DropdownMenuRadixItemProps, DropdownMenuRoot, DropdownMenuTrigger, EditableCell, type EditableCellProps, EmailCell, type EmailCellProps, EmptyState, type EmptyStateProps, type FilterOperator, InfoMessage, type InfoMessageProps, InputLabel, type InputLabelProps, Link, LinkCell, type LinkCellProps, type LinkProps, Modal, ModalBody, ModalClose, ModalContent, type ModalContentProps, ModalDescription, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, ModalOverlay, ModalTitle, ModalTrigger, NumberCell, type NumberCellProps, type Product, ProductLogo, type ProductLogoProps, RowActions, type RowActionsProps, SearchBar, type SearchBarProps, Select, type SelectProps, SidePanel, SidePanelClose, SidePanelContent, type SidePanelContentProps, SidePanelTrigger, Sidebar, SidebarFooter, type SidebarFooterProps, SidebarHeader, SidebarHeadingItem, type SidebarHeadingItemProps, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarSection, type SidebarSectionProps, StatusCell, type StatusCellProps, Switch, type SwitchProps, TabContent, type TabContentProps, TabList, type TabListProps, TabTrigger, type TabTriggerProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, type TabsProps, Tag, type TagProps, TextArea, type TextAreaProps, TextCell, type TextCellProps, TextInput, type TextInputProps, Toast, type ToastProps, ToastProvider, ToastViewport, Tooltip, TooltipContent, type TooltipContentProps, TooltipProvider, TooltipTrigger, Typography, type TypographyProps, UserMenu, UserMenuInfoRow, type UserMenuInfoRowProps, type UserMenuProps, UserMenuSection, type UserMenuSectionProps, avatarVariants, badgeVariants, buttonVariants, cn, emptyStateVariants, infoMessageVariants, linkVariants, modalVariants, productLogoVariants, searchBarVariants, selectVariants, sidebarItemVariants, tagVariants, textInputVariants, toastVariants, tooltipContentVariants, typographyVariants, useSidebarContext };