@facter/ds-core 1.1.1 → 1.1.3

package/dist/index.d.ts

@@ -1,52 +1,92 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
-import * as React from 'react';
+import * as React$1 from 'react';
 import { VariantProps } from 'class-variance-authority';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import * as _tanstack_react_table from '@tanstack/react-table';
+import { ColumnDef, Column, SortingState, ColumnFiltersState, VisibilityState, RowSelectionState, PaginationState, Table as Table$1 } from '@tanstack/react-table';
+export { flexRender } from '@tanstack/react-table';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { Toaster as Toaster$1 } from 'sonner';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import { FieldValues, FieldPath, UseFormReturn, SubmitHandler, SubmitErrorHandler } from 'react-hook-form';
+import { LucideIcon } from 'lucide-react';
 import { ClassValue } from 'clsx';
 
 declare const buttonVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
-    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
 }
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 declare const inputVariants: (props?: ({
     variant?: "default" | "error" | null | undefined;
     inputSize?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'>, VariantProps<typeof inputVariants> {
+interface InputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'size'>, VariantProps<typeof inputVariants> {
     label?: string;
     error?: boolean;
-    icon?: React.ComponentType<any>;
+    icon?: React$1.ComponentType<any>;
     containerClassName?: string;
     labelClassName?: string;
 }
-declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
 
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "outline" | "error" | "secondary" | "success" | "warning" | "info" | null | undefined;
+    variant?: "default" | "outline" | "secondary" | "error" | "success" | "warning" | "info" | null | undefined;
     size?: "default" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }
 declare function Badge({ className, variant, size, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
 declare namespace Badge {
     var displayName: string;
 }
 
+declare const selectVariants: (props?: ({
+    variant?: "default" | "error" | null | undefined;
+    selectSize?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SelectProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>, 'size'>, VariantProps<typeof selectVariants> {
+    label?: string;
+    error?: boolean;
+    icon?: React$1.ComponentType<any>;
+    className?: string;
+    containerClassName?: string;
+    labelClassName?: string;
+    placeholder?: string;
+    required?: boolean;
+    children: React$1.ReactNode;
+}
+declare const Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface SelectItemProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    children: React$1.ReactNode;
+}
+declare const SelectItem: React$1.ForwardRefExoticComponent<SelectItemProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
 declare const loaderVariants: (props?: ({
     variant?: "default" | "spinner" | "dots" | "pulse" | "bars" | null | undefined;
-    scope?: "global" | "local" | null | undefined;
+    scope?: "local" | "global" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface LoaderProps extends VariantProps<typeof loaderVariants> {
     message?: string;
     isTransparentBg?: boolean;
     show?: boolean;
 }
-declare const Loader: React.ForwardRefExoticComponent<LoaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const Loader: React$1.ForwardRefExoticComponent<LoaderProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface LoaderContextValue {
     show: (options?: LoaderOptions) => void;
@@ -60,7 +100,7 @@ interface LoaderOptions {
     isTransparentBg?: boolean;
 }
 declare function LoaderProvider({ children }: {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
 }): react_jsx_runtime.JSX.Element;
 declare function useLoader(): LoaderContextValue;
 declare const loader: {
@@ -69,6 +109,1145 @@ declare const loader: {
 };
 declare function GlobalLoaderController(): null;
 
+declare const emptyStateVariants: (props?: ({
+    layout?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface EmptyStateProps extends VariantProps<typeof emptyStateVariants> {
+    message?: string;
+    description?: string;
+    icon?: React$1.ComponentType<any>;
+    actionLabel?: string;
+    onAction?: () => void;
+    hideDescription?: boolean;
+    size?: 'default' | 'sm';
+    className?: string;
+    animated?: boolean;
+}
+declare const EmptyState: React$1.NamedExoticComponent<EmptyStateProps>;
+
+/**
+ * Props do componente root DataTable.
+ *
+ * TData deve ser um objeto (Record<string, unknown>) para garantir
+ * type-safety com o TanStack Table e permitir acesso a propriedades.
+ */
+interface DataTableProps<TData extends Record<string, unknown>> {
+    /** Data array - deve ser memoizado pelo consumer */
+    data: TData[];
+    /** Column definitions - deve ser memoizado pelo consumer */
+    columns: ColumnDef<TData, unknown>[];
+    /** Children usando Compound Component pattern */
+    children: React$1.ReactNode;
+    /** Função para obter ID único da row */
+    getRowId?: (row: TData) => string;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableState {
+    sorting: SortingState;
+    columnFilters: ColumnFiltersState;
+    columnVisibility: VisibilityState;
+    rowSelection: RowSelectionState;
+    pagination: PaginationState;
+    globalFilter: string;
+    density: DataTableDensity;
+}
+type DataTableDensity = 'compact' | 'default' | 'comfortable';
+interface DataTableMeta {
+    isLoading: boolean;
+    isEmpty: boolean;
+    selectedRowCount: number;
+    totalRows: number;
+    density: DataTableDensity;
+}
+interface DataTableLoadingProps {
+    /** Controla visibilidade do loading */
+    visible: boolean;
+    /** Custom skeleton component */
+    skeleton?: React$1.ReactNode;
+    /** Número de rows no skeleton */
+    skeletonRows?: number;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableToolbarProps {
+    /** Children components */
+    children?: React$1.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableSearchProps {
+    /** Placeholder text */
+    placeholder?: string;
+    /** Coluna específica para buscar (se não passar, busca global) */
+    column?: string;
+    /** Debounce delay em ms */
+    debounce?: number;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableFiltersProps {
+    /** Children: Individual filters */
+    children?: React$1.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableFilterOption {
+    label: string;
+    value: string;
+    icon?: React$1.ReactNode;
+}
+interface DataTableFilterProps {
+    /** Coluna para filtrar */
+    column: string;
+    /** Label do filtro */
+    title: string;
+    /** Opções de filtro */
+    options: DataTableFilterOption[];
+    /** Permitir seleção múltipla */
+    multiSelect?: boolean;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableContentProps {
+    /** Header fixo no scroll */
+    stickyHeader?: boolean;
+    /** Linhas alternadas (zebra) */
+    stripedRows?: boolean;
+    /** Highlight no hover */
+    highlightOnHover?: boolean;
+    /** Custom className */
+    className?: string;
+}
+type DataTablePaginationMode = 'client' | 'server';
+interface DataTablePaginationProps {
+    /** Modo de paginação */
+    mode?: DataTablePaginationMode;
+    /** Total de páginas (obrigatório se mode="server") */
+    pageCount?: number;
+    /** Opções de items por página */
+    pageSizes?: number[];
+    /** Mostrar seletor de page size */
+    showPageSize?: boolean;
+    /** Mostrar informação de página atual */
+    showPageInfo?: boolean;
+    /** Mostrar botões primeira/última página */
+    showFirstLast?: boolean;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableEmptyStateProps {
+    /** Título */
+    title?: string;
+    /** Descrição */
+    description?: string;
+    /** Ícone customizado */
+    icon?: React$1.ReactNode;
+    /** Ação (botão, link, etc) */
+    action?: React$1.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableBulkActionsProps<TData = unknown> {
+    /** Render prop que recebe as rows selecionadas */
+    children: (selectedRows: TData[]) => React$1.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableColumnVisibilityProps {
+    /** Custom className */
+    className?: string;
+}
+interface DataTableDensityToggleProps {
+    /** Custom className */
+    className?: string;
+}
+interface DataTableTab {
+    /** Identificador único da tab */
+    value: string;
+    /** Label exibido na tab */
+    label: string;
+    /** Contador opcional (ex: "Todas 85") */
+    count?: number;
+}
+interface DataTableTabsProps {
+    /** Lista de tabs disponíveis */
+    tabs: DataTableTab[];
+    /** Tab ativa (controlled) */
+    value?: string;
+    /** Tab ativa inicial (uncontrolled) */
+    defaultValue?: string;
+    /** Callback quando tab muda */
+    onValueChange?: (value: string) => void;
+    /** Custom className */
+    className?: string;
+}
+type DataTableExportFormat = 'csv' | 'xlsx' | 'pdf';
+interface DataTableExportProps {
+    /** Formatos disponíveis para export */
+    formats?: DataTableExportFormat[];
+    /** Nome do arquivo (sem extensão) */
+    filename?: string;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableColumnHeaderProps<TData = unknown, TValue = unknown> {
+    /** Column instance do TanStack Table */
+    column: Column<TData, TValue>;
+    /** Título do header */
+    title: string;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableRowActionsProps {
+    /** Children (DropdownMenuItems) */
+    children: React$1.ReactNode;
+    /** Custom className */
+    className?: string;
+}
+interface DataTableContextValue<TData = unknown> {
+    table: Table$1<TData>;
+    state: DataTableMeta;
+    density: DataTableDensity;
+    setDensity: (density: DataTableDensity) => void;
+}
+interface UseDataTableConfig<TData extends Record<string, unknown>> {
+    data: TData[];
+    columns: ColumnDef<TData, unknown>[];
+    getRowId?: (row: TData) => string;
+    initialPageSize?: number;
+    initialPageIndex?: number;
+}
+interface PaginationMeta {
+    page: number;
+    perPage: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+interface PaginationParams {
+    page?: number;
+    perPage?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+declare const DENSITY_CONFIG: {
+    readonly compact: {
+        readonly rowHeight: 32;
+        readonly fontSize: "text-xs";
+        readonly padding: "py-1 px-2";
+    };
+    readonly default: {
+        readonly rowHeight: 40;
+        readonly fontSize: "text-sm";
+        readonly padding: "py-2 px-4";
+    };
+    readonly comfortable: {
+        readonly rowHeight: 52;
+        readonly fontSize: "text-sm";
+        readonly padding: "py-3 px-4";
+    };
+};
+
+declare function DataTableRoot<TData extends Record<string, unknown>>({ children, data, columns, getRowId, className, }: DataTableProps<TData>): react_jsx_runtime.JSX.Element;
+declare namespace DataTableRoot {
+    var displayName: string;
+}
+
+/**
+ * DataTable.Loading - Componente de loading state
+ *
+ * Renderiza um skeleton ou overlay quando visible=true.
+ * Não renderiza nada quando visible=false.
+ */
+declare function DataTableLoading({ visible, skeleton, skeletonRows, className, }: DataTableLoadingProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DataTableLoading {
+    var displayName: string;
+}
+
+declare function DataTableColumnHeader({ column, title, className, }: DataTableColumnHeaderProps): react_jsx_runtime.JSX.Element;
+
+declare function DataTableColumnVisibility({ className, }: DataTableColumnVisibilityProps): react_jsx_runtime.JSX.Element;
+declare namespace DataTableColumnVisibility {
+    var displayName: string;
+}
+
+declare function DataTableDensityToggle({ className, }: DataTableDensityToggleProps): react_jsx_runtime.JSX.Element;
+declare namespace DataTableDensityToggle {
+    var displayName: string;
+}
+
+declare function DataTableBulkActions<TData extends Record<string, unknown>>({ children, className, }: DataTableBulkActionsProps<TData>): react_jsx_runtime.JSX.Element | null;
+declare namespace DataTableBulkActions {
+    var displayName: string;
+}
+
+declare function DataTableExport({ formats, filename, className, }: DataTableExportProps): react_jsx_runtime.JSX.Element;
+declare namespace DataTableExport {
+    var displayName: string;
+}
+
+declare function DataTableTabs({ tabs, value, defaultValue, onValueChange, className, }: DataTableTabsProps): react_jsx_runtime.JSX.Element;
+declare namespace DataTableTabs {
+    var displayName: string;
+}
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+
+/**
+ * Context 3: Density
+ * - Muda apenas quando usuário altera densidade
+ * - Separado para não re-renderizar toda tabela
+ */
+interface DensityContextValue {
+    density: DataTableDensity;
+    setDensity: (density: DataTableDensity) => void;
+}
+/**
+ * Hook para acessar a instância da tabela
+ * Não causa re-renders pois a instância é estável
+ */
+declare function useDataTable<TData = unknown>(): Table$1<TData>;
+/**
+ * Hook para acessar o estado meta da tabela
+ * Re-renderiza quando loading, empty, ou selection muda
+ */
+declare function useDataTableMeta(): DataTableMeta;
+/**
+ * Hook para acessar apenas o loading state
+ * Otimizado para componentes que só precisam saber se está carregando
+ */
+declare function useDataTableLoading(): boolean;
+/**
+ * Hook para acessar apenas o empty state
+ * Otimizado para componentes que só precisam saber se está vazio
+ */
+declare function useDataTableEmpty(): boolean;
+/**
+ * Hook para acessar rows selecionadas
+ * Re-renderiza quando seleção muda
+ */
+declare function useDataTableSelection<TData = unknown>(): TData[];
+/**
+ * Hook para acessar densidade
+ * Separado para não re-renderizar componentes que não usam
+ */
+declare function useDataTableDensity(): DensityContextValue;
+/**
+ * Hook para paginação
+ * Retorna informações de paginação memoizadas
+ */
+declare function useDataTablePagination(): {
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+    canPreviousPage: boolean;
+    canNextPage: boolean;
+    setPageIndex: (index: number) => void;
+    setPageSize: (size: number) => void;
+    previousPage: () => void;
+    nextPage: () => void;
+    firstPage: () => void;
+    lastPage: () => void;
+};
+/**
+ * Hook para sorting
+ * Retorna informações de sorting memoizadas
+ */
+declare function useDataTableSorting(): {
+    sorting: _tanstack_react_table.SortingState;
+    setSorting: (updater: _tanstack_react_table.Updater<_tanstack_react_table.SortingState>) => void;
+    clearSorting: () => void;
+    toggleSort: (columnId: string) => void;
+};
+/**
+ * Hook para column visibility
+ * Retorna informações de visibilidade memoizadas
+ */
+declare function useDataTableColumnVisibility(): {
+    columnVisibility: _tanstack_react_table.VisibilityState;
+    setColumnVisibility: (updater: _tanstack_react_table.Updater<_tanstack_react_table.VisibilityState>) => void;
+    toggleColumn: (columnId: string) => void;
+    getAllColumns: () => _tanstack_react_table.Column<unknown, unknown>[];
+};
+declare const useDataTableInstance: typeof useDataTable;
+declare const useDataTableState: typeof useDataTableMeta;
+
+declare function useDebounce<T>(value: T, delay?: number): T;
+declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay?: number): T;
+
+declare const DataTable: typeof DataTableRoot & {
+    Loading: typeof DataTableLoading;
+    EmptyState: React$1.NamedExoticComponent<DataTableEmptyStateProps>;
+    Tabs: typeof DataTableTabs;
+    Toolbar: React$1.NamedExoticComponent<DataTableToolbarProps>;
+    Content: React$1.NamedExoticComponent<DataTableContentProps>;
+    Search: React$1.NamedExoticComponent<DataTableSearchProps>;
+    Filters: React$1.NamedExoticComponent<DataTableFiltersProps>;
+    Filter: React$1.NamedExoticComponent<DataTableFilterProps>;
+    Pagination: React$1.NamedExoticComponent<DataTablePaginationProps>;
+    BulkActions: typeof DataTableBulkActions;
+    ColumnVisibility: typeof DataTableColumnVisibility;
+    DensityToggle: typeof DataTableDensityToggle;
+    Export: typeof DataTableExport;
+    ColumnHeader: typeof DataTableColumnHeader;
+};
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>>;
+declare const dialogContentVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "xl" | "2xl" | "3xl" | "4xl" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DialogContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof dialogContentVariants> {
+    showCloseButton?: boolean;
+}
+declare const DialogContent: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>>;
+declare const DialogHeader: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
+declare const DialogFooter: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
+declare const DialogTitle: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>>;
+declare const DialogDescription: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>>;
+declare const DialogBody: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
+
+interface RippleEffectProps {
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    color?: 'primary' | 'secondary' | 'accent' | 'muted';
+    intensity?: 'light' | 'medium' | 'strong';
+    rings?: number;
+    position?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center';
+    className?: string;
+}
+declare const RippleEffect: React$1.NamedExoticComponent<RippleEffectProps>;
+interface RippleWrapperProps {
+    children: React$1.ReactNode;
+    rippleProps?: RippleEffectProps;
+    className?: string;
+}
+declare const RippleWrapper: React$1.NamedExoticComponent<RippleWrapperProps>;
+interface RippleBackgroundProps extends RippleEffectProps {
+    containerClassName?: string;
+}
+declare const RippleBackground: React$1.NamedExoticComponent<RippleBackgroundProps>;
+
+declare const iconWrapperVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "success" | "accent" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DialogWrapperProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof iconWrapperVariants> {
+    children?: React$1.ReactNode;
+    icon?: React$1.ElementType<{
+        className?: string;
+    }>;
+    status?: 'active' | 'inactive' | 'warning' | 'error' | null;
+    showRipple?: boolean;
+    rippleProps?: Partial<RippleEffectProps>;
+    iconSize?: 'sm' | 'md' | 'lg';
+}
+declare const DialogWrapper: React$1.NamedExoticComponent<DialogWrapperProps>;
+
+type ToasterProps = React$1.ComponentProps<typeof Toaster$1>;
+declare const toastVariants: {
+    default: {
+        bg: string;
+        border: string;
+        barColor: string;
+        icon: react_jsx_runtime.JSX.Element;
+        textColor: string;
+    };
+    success: {
+        bg: string;
+        border: string;
+        barColor: string;
+        icon: react_jsx_runtime.JSX.Element;
+        textColor: string;
+    };
+    error: {
+        bg: string;
+        border: string;
+        barColor: string;
+        icon: react_jsx_runtime.JSX.Element;
+        textColor: string;
+    };
+    warning: {
+        bg: string;
+        border: string;
+        barColor: string;
+        icon: react_jsx_runtime.JSX.Element;
+        textColor: string;
+    };
+    info: {
+        bg: string;
+        border: string;
+        barColor: string;
+        icon: react_jsx_runtime.JSX.Element;
+        textColor: string;
+    };
+};
+declare const Toaster: ({ ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;
+interface ToastProps {
+    title: string;
+    description?: string;
+    variant?: keyof typeof toastVariants;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    onClose?: () => void;
+}
+declare const toast: ((message: string) => string | number) & {
+    success: (message: string | ToastProps) => string | number;
+    error: (message: string | ToastProps) => string | number;
+    warning: (message: string | ToastProps) => string | number;
+    info: (message: string | ToastProps) => string | number;
+    custom: (component: (id: string | number) => React$1.ReactElement, options?: any) => string | number;
+    dismiss: (id?: string | number) => string | number;
+    promise: <T>(promise: Promise<T> | (() => Promise<T>), options: {
+        loading: string;
+        success: string | ((data: T) => string);
+        error: string | ((error: any) => string);
+    }) => (string & {
+        unwrap: () => Promise<T>;
+    }) | (number & {
+        unwrap: () => Promise<T>;
+    }) | {
+        unwrap: () => Promise<T>;
+    };
+};
+
+declare const checkboxVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CheckboxProps extends React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof checkboxVariants> {
+}
+declare const Checkbox: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>>;
+
+declare const switchVariants: (props?: ({
+    variant?: "default" | "secondary" | "success" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SwitchProps extends React$1.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>, VariantProps<typeof switchVariants> {
+}
+declare const Switch: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>>;
+
+declare const textareaVariants: (props?: ({
+    variant?: "default" | "error" | null | undefined;
+    textareaSize?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextareaProps extends Omit<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, 'size'>, VariantProps<typeof textareaVariants> {
+    label?: string;
+    error?: boolean;
+    icon?: React$1.ComponentType<any>;
+    containerClassName?: string;
+    labelClassName?: string;
+    autoResize?: boolean;
+}
+declare const Textarea: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>>;
+
+interface FormLabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
+    required?: boolean;
+}
+declare const FormLabel: React$1.ForwardRefExoticComponent<FormLabelProps & React$1.RefAttributes<HTMLLabelElement>>;
+interface FormDescriptionProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+}
+declare const FormDescription: React$1.ForwardRefExoticComponent<FormDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+interface FormErrorProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+    message?: string;
+}
+declare const FormError: React$1.ForwardRefExoticComponent<FormErrorProps & React$1.RefAttributes<HTMLParagraphElement>>;
+interface FormFieldWrapperProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    description?: string;
+    required?: boolean;
+    error?: string;
+}
+declare const FormFieldWrapper: React$1.ForwardRefExoticComponent<FormFieldWrapperProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FormContextValue<T extends FieldValues = FieldValues> {
+    form: UseFormReturn<T>;
+}
+interface FormFieldContextValue {
+    name: string;
+    id: string;
+    error?: string;
+    isRequired?: boolean;
+}
+interface BaseFieldProps<T extends FieldValues = FieldValues> {
+    name: FieldPath<T>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+type MaskType = 'phone' | 'cpf' | 'cnpj' | 'cep' | 'money' | 'percent' | 'plate' | 'date' | 'time' | 'datetime';
+interface FormInputProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T>, Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'name' | 'size'> {
+    mask?: MaskType;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+    showPasswordToggle?: boolean;
+    inputSize?: 'sm' | 'default' | 'lg';
+    hideError?: boolean;
+}
+interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+    disabled?: boolean;
+}
+interface FormSelectProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    options: SelectOption[];
+    placeholder?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    loading?: boolean;
+    emptyText?: string;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+    hideError?: boolean;
+    selectSize?: 'sm' | 'default' | 'lg';
+}
+interface FormTextareaProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T>, Omit<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, 'name'> {
+    hideError?: boolean;
+    showCount?: boolean;
+    maxLength?: number;
+}
+interface FormCheckboxProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    hideError?: boolean;
+}
+interface FormSwitchProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    hideError?: boolean;
+}
+interface RadioOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface FormRadioGroupProps<T extends FieldValues = FieldValues> extends BaseFieldProps<T> {
+    options: RadioOption[];
+    orientation?: 'horizontal' | 'vertical';
+    hideError?: boolean;
+}
+
+declare function FormInput<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, mask, icon, showPasswordToggle, inputSize, hideError, type, maxLength, ...inputProps }: FormInputProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormInput {
+    var displayName: string;
+}
+
+declare function FormSelect<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, options, placeholder, icon, hideError, selectSize, emptyText, loading, }: FormSelectProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormSelect {
+    var displayName: string;
+}
+
+declare function FormTextarea<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, hideError, showCount, maxLength, ...textareaProps }: FormTextareaProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormTextarea {
+    var displayName: string;
+}
+
+declare function FormCheckbox<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, hideError, }: FormCheckboxProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormCheckbox {
+    var displayName: string;
+}
+
+declare function FormSwitch<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, hideError, }: FormSwitchProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormSwitch {
+    var displayName: string;
+}
+
+declare function FormRadioGroup<T extends FieldValues = FieldValues>({ name, label, description, required, disabled, className, options, orientation, hideError, }: FormRadioGroupProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormRadioGroup {
+    var displayName: string;
+}
+
+declare function useFormContext<T extends FieldValues = FieldValues>(): UseFormReturn<T>;
+interface FormProviderProps<T extends FieldValues = FieldValues> {
+    form: UseFormReturn<T>;
+    children: React$1.ReactNode;
+}
+declare function FormProvider<T extends FieldValues = FieldValues>({ form, children, }: FormProviderProps<T>): react_jsx_runtime.JSX.Element;
+declare function useFormFieldContext(): FormFieldContextValue;
+interface FormFieldProviderProps {
+    name: string;
+    children: React$1.ReactNode;
+}
+declare function FormFieldProvider({ name, children }: FormFieldProviderProps): react_jsx_runtime.JSX.Element;
+
+interface FormRootProps<T extends FieldValues = FieldValues> extends Omit<React$1.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onError'> {
+    form: UseFormReturn<T>;
+    onSubmit: SubmitHandler<T>;
+    onError?: SubmitErrorHandler<T>;
+}
+declare function FormRoot<T extends FieldValues = FieldValues>({ form, onSubmit, onError, children, className, ...props }: FormRootProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace FormRoot {
+    var displayName: string;
+}
+
+declare const Form: typeof FormRoot & {
+    Input: typeof FormInput;
+    Select: typeof FormSelect;
+    Textarea: typeof FormTextarea;
+    Checkbox: typeof FormCheckbox;
+    Switch: typeof FormSwitch;
+    RadioGroup: typeof FormRadioGroup;
+    Label: React$1.ForwardRefExoticComponent<FormLabelProps & React$1.RefAttributes<HTMLLabelElement>>;
+    Description: React$1.ForwardRefExoticComponent<FormDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+    Error: React$1.ForwardRefExoticComponent<FormErrorProps & React$1.RefAttributes<HTMLParagraphElement>>;
+    FieldWrapper: React$1.ForwardRefExoticComponent<FormFieldWrapperProps & React$1.RefAttributes<HTMLDivElement>>;
+    Field: typeof FormFieldProvider;
+};
+
+interface AuthLayoutProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface AuthLayoutImageProps {
+    src: string;
+    alt: string;
+    position?: 'left' | 'right';
+    className?: string;
+    priority?: boolean;
+}
+interface AuthLayoutContentProps {
+    children: React$1.ReactNode;
+    className?: string;
+    maxWidth?: 'sm' | 'md' | 'lg';
+}
+interface AuthLayoutHeaderProps {
+    children?: React$1.ReactNode;
+    className?: string;
+    logo?: React$1.ReactNode;
+    title?: string;
+    description?: string;
+    centered?: boolean;
+}
+interface AuthLayoutBodyProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface AuthLayoutFooterProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface AuthLayoutLinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement> {
+    children: React$1.ReactNode;
+}
+interface AuthLayoutDividerProps {
+    text?: string;
+    className?: string;
+}
+
+declare function AuthLayoutRoot({ children, className }: AuthLayoutProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutRoot {
+    var displayName: string;
+}
+declare function AuthLayoutImage({ src, alt, position: _position, className, priority, }: AuthLayoutImageProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutImage {
+    var displayName: string;
+}
+declare function AuthLayoutContent({ children, className, maxWidth, }: AuthLayoutContentProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutContent {
+    var displayName: string;
+}
+declare function AuthLayoutHeader({ children, className, logo, title, description, centered, }: AuthLayoutHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutHeader {
+    var displayName: string;
+}
+declare function AuthLayoutBody({ children, className }: AuthLayoutBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutBody {
+    var displayName: string;
+}
+declare function AuthLayoutFooter({ children, className }: AuthLayoutFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutFooter {
+    var displayName: string;
+}
+declare function AuthLayoutLink({ children, className, ...props }: AuthLayoutLinkProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutLink {
+    var displayName: string;
+}
+declare function AuthLayoutDivider({ text, className }: AuthLayoutDividerProps): react_jsx_runtime.JSX.Element;
+declare namespace AuthLayoutDivider {
+    var displayName: string;
+}
+declare const AuthLayout: typeof AuthLayoutRoot & {
+    Image: typeof AuthLayoutImage;
+    Content: typeof AuthLayoutContent;
+    Header: typeof AuthLayoutHeader;
+    Body: typeof AuthLayoutBody;
+    Footer: typeof AuthLayoutFooter;
+    Link: typeof AuthLayoutLink;
+    Divider: typeof AuthLayoutDivider;
+};
+
+interface SelectionLayoutProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutSidebarProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutLogoProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutHeadlineProps {
+    title: string;
+    bullets?: string[];
+    className?: string;
+}
+interface SelectionLayoutStatsProps {
+    label: string;
+    value: string | number;
+    className?: string;
+}
+interface SelectionLayoutMainProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutHeaderProps {
+    title: string;
+    subtitle?: string;
+    action?: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutSearchProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+}
+interface SelectionLayoutTabsProps {
+    children: React$1.ReactNode;
+    value: string;
+    onValueChange: (value: string) => void;
+    className?: string;
+}
+interface SelectionLayoutTabProps {
+    value: string;
+    label: string;
+    icon?: LucideIcon;
+    badge?: string | number;
+    className?: string;
+}
+interface SelectionLayoutListProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface SelectionLayoutCardProps {
+    children?: React$1.ReactNode;
+    className?: string;
+    onClick?: () => void;
+    icon?: LucideIcon | React$1.ReactNode;
+    title: string;
+    description?: string;
+    badge?: React$1.ReactNode;
+    favorite?: boolean;
+    onFavoriteClick?: () => void;
+}
+interface SelectionLayoutEmptyProps {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+    action?: React$1.ReactNode;
+    className?: string;
+}
+
+declare function SelectionLayoutRoot({ children, className }: SelectionLayoutProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutRoot {
+    var displayName: string;
+}
+declare function SelectionLayoutSidebar({ children, className }: SelectionLayoutSidebarProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutSidebar {
+    var displayName: string;
+}
+declare function SelectionLayoutLogo({ children, className }: SelectionLayoutLogoProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutLogo {
+    var displayName: string;
+}
+declare function SelectionLayoutHeadline({ title, bullets, className, }: SelectionLayoutHeadlineProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutHeadline {
+    var displayName: string;
+}
+declare function SelectionLayoutStats({ label, value, className }: SelectionLayoutStatsProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutStats {
+    var displayName: string;
+}
+declare function SelectionLayoutMain({ children, className }: SelectionLayoutMainProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutMain {
+    var displayName: string;
+}
+declare function SelectionLayoutHeader({ title, subtitle, action, className, }: SelectionLayoutHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutHeader {
+    var displayName: string;
+}
+declare function SelectionLayoutSearch({ value, onChange, placeholder, className, }: SelectionLayoutSearchProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutSearch {
+    var displayName: string;
+}
+declare function SelectionLayoutTabs({ children, value, onValueChange, className, }: SelectionLayoutTabsProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutTabs {
+    var displayName: string;
+}
+declare function SelectionLayoutTab({ value, label, icon: Icon, badge, className, }: SelectionLayoutTabProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutTab {
+    var displayName: string;
+}
+declare function SelectionLayoutList({ children, className }: SelectionLayoutListProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutList {
+    var displayName: string;
+}
+declare function SelectionLayoutCard({ children, className, onClick, icon, title, description, badge, favorite, onFavoriteClick, }: SelectionLayoutCardProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutCard {
+    var displayName: string;
+}
+declare function SelectionLayoutEmpty({ icon: Icon, title, description, action, className, }: SelectionLayoutEmptyProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectionLayoutEmpty {
+    var displayName: string;
+}
+declare const SelectionLayout: typeof SelectionLayoutRoot & {
+    Sidebar: typeof SelectionLayoutSidebar;
+    Logo: typeof SelectionLayoutLogo;
+    Headline: typeof SelectionLayoutHeadline;
+    Stats: typeof SelectionLayoutStats;
+    Main: typeof SelectionLayoutMain;
+    Header: typeof SelectionLayoutHeader;
+    Search: typeof SelectionLayoutSearch;
+    Tabs: typeof SelectionLayoutTabs;
+    Tab: typeof SelectionLayoutTab;
+    List: typeof SelectionLayoutList;
+    Card: typeof SelectionLayoutCard;
+    Empty: typeof SelectionLayoutEmpty;
+};
+
+interface DashboardLayoutContextValue {
+    sidebarExpanded: boolean;
+    setSidebarExpanded: (expanded: boolean) => void;
+    sidebarPinned: boolean;
+    setSidebarPinned: (pinned: boolean) => void;
+    isMobile: boolean;
+    mobileMenuOpen: boolean;
+    setMobileMenuOpen: (open: boolean) => void;
+}
+interface DashboardLayoutProps {
+    children: React.ReactNode;
+    className?: string;
+    defaultExpanded?: boolean;
+    defaultPinned?: boolean;
+}
+interface DashboardLayoutSidebarProps {
+    children: React.ReactNode;
+    className?: string;
+    collapsedWidth?: number;
+    expandedWidth?: number;
+}
+interface DashboardLayoutSidebarHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+    logo?: React.ReactNode;
+    collapsedLogo?: React.ReactNode;
+    title?: string;
+}
+interface DashboardLayoutSidebarNavProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutSidebarNavItemProps {
+    icon?: LucideIcon | React.ReactNode;
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    isActive?: boolean;
+    badge?: string | number;
+    badgeVariant?: 'default' | 'primary' | 'destructive';
+    className?: string;
+    disabled?: boolean;
+}
+interface DashboardLayoutSidebarNavGroupProps {
+    icon?: LucideIcon | React.ReactNode;
+    label: string;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    isActive?: boolean;
+    badge?: string | number;
+    badgeVariant?: 'default' | 'primary' | 'destructive';
+    className?: string;
+}
+interface DashboardLayoutSidebarSectionProps {
+    title?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutSidebarFooterProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutHeaderProps {
+    children?: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutHeaderTitleProps {
+    children?: React.ReactNode;
+    className?: string;
+    title?: string;
+    subtitle?: string;
+}
+interface DashboardLayoutHeaderActionsProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutHeaderUserProps {
+    name: string;
+    email?: string;
+    avatar?: string;
+    className?: string;
+    children?: React.ReactNode;
+    onLogout?: () => void;
+}
+interface DashboardLayoutContentProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutBreadcrumbsProps {
+    items: Array<{
+        label: string;
+        href?: string;
+        icon?: LucideIcon;
+    }>;
+    className?: string;
+    separator?: React.ReactNode;
+}
+interface DashboardLayoutMobileNavProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DashboardLayoutMobileNavItemProps {
+    icon: LucideIcon;
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    isActive?: boolean;
+    badge?: string | number;
+}
+
+declare function useDashboardLayout(): DashboardLayoutContextValue;
+declare function DashboardLayoutRoot({ children, className, defaultExpanded, defaultPinned, }: DashboardLayoutProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutRoot {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebar({ children, className, collapsedWidth, expandedWidth, }: DashboardLayoutSidebarProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebar {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarHeader({ children, className, logo, collapsedLogo, title, }: DashboardLayoutSidebarHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarHeader {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarNav({ children, className }: DashboardLayoutSidebarNavProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarNav {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarNavItem({ icon, label, href, onClick, isActive, badge, badgeVariant, className, disabled, }: DashboardLayoutSidebarNavItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarNavItem {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarNavGroup({ icon, label, children, defaultOpen, isActive, badge, badgeVariant, className, }: DashboardLayoutSidebarNavGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarNavGroup {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarSection({ title, children, className, }: DashboardLayoutSidebarSectionProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarSection {
+    var displayName: string;
+}
+declare function DashboardLayoutSidebarFooter({ children, className }: DashboardLayoutSidebarFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutSidebarFooter {
+    var displayName: string;
+}
+declare function DashboardLayoutHeader({ children, className }: DashboardLayoutHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutHeader {
+    var displayName: string;
+}
+declare function DashboardLayoutHeaderTitle({ children, className, title, subtitle, }: DashboardLayoutHeaderTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutHeaderTitle {
+    var displayName: string;
+}
+declare function DashboardLayoutHeaderActions({ children, className }: DashboardLayoutHeaderActionsProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutHeaderActions {
+    var displayName: string;
+}
+declare function DashboardLayoutHeaderUser({ name, email, avatar, className, children, onLogout, }: DashboardLayoutHeaderUserProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutHeaderUser {
+    var displayName: string;
+}
+declare function DashboardLayoutContent({ children, className }: DashboardLayoutContentProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutContent {
+    var displayName: string;
+}
+declare function DashboardLayoutBreadcrumbs({ items, className, separator, }: DashboardLayoutBreadcrumbsProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutBreadcrumbs {
+    var displayName: string;
+}
+declare function DashboardLayoutMobileNav({ children, className }: DashboardLayoutMobileNavProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutMobileNav {
+    var displayName: string;
+}
+declare function DashboardLayoutMobileNavItem({ icon: Icon, label, href, onClick, isActive, badge, }: DashboardLayoutMobileNavItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DashboardLayoutMobileNavItem {
+    var displayName: string;
+}
+declare const DashboardLayout: typeof DashboardLayoutRoot & {
+    Sidebar: typeof DashboardLayoutSidebar;
+    SidebarHeader: typeof DashboardLayoutSidebarHeader;
+    SidebarNav: typeof DashboardLayoutSidebarNav;
+    SidebarNavItem: typeof DashboardLayoutSidebarNavItem;
+    SidebarNavGroup: typeof DashboardLayoutSidebarNavGroup;
+    SidebarSection: typeof DashboardLayoutSidebarSection;
+    SidebarFooter: typeof DashboardLayoutSidebarFooter;
+    Header: typeof DashboardLayoutHeader;
+    HeaderTitle: typeof DashboardLayoutHeaderTitle;
+    HeaderActions: typeof DashboardLayoutHeaderActions;
+    HeaderUser: typeof DashboardLayoutHeaderUser;
+    Content: typeof DashboardLayoutContent;
+    Breadcrumbs: typeof DashboardLayoutBreadcrumbs;
+    MobileNav: typeof DashboardLayoutMobileNav;
+    MobileNavItem: typeof DashboardLayoutMobileNavItem;
+};
+
+type Theme = 'dark' | 'light' | 'system';
+interface ThemeProviderProps {
+    children: React$1.ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+}
+interface ThemeProviderState {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+}
+declare function ThemeProvider({ children, defaultTheme, storageKey, ...props }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare const useTheme: () => ThemeProviderState;
+
 /**
  * Merge Tailwind CSS classes
  * Combines clsx (conditional classes) with tailwind-merge (deduplicates classes)
@@ -78,4 +1257,4 @@ declare function GlobalLoaderController(): null;
  */
 declare function cn(...inputs: ClassValue[]): string;
 
-export { Badge, type BadgeProps, Button, type ButtonProps, GlobalLoaderController, Input, type InputProps, Loader, type LoaderProps, LoaderProvider, cn, loader, useLoader };
+export { AuthLayout, type AuthLayoutBodyProps, type AuthLayoutContentProps, type AuthLayoutDividerProps, type AuthLayoutFooterProps, type AuthLayoutHeaderProps, type AuthLayoutImageProps, type AuthLayoutLinkProps, type AuthLayoutProps, Badge, type BadgeProps, type BaseFieldProps, Button, type ButtonProps, Checkbox, type CheckboxProps, DENSITY_CONFIG, DashboardLayout, type DashboardLayoutBreadcrumbsProps, type DashboardLayoutContentProps, type DashboardLayoutContextValue, type DashboardLayoutHeaderActionsProps, type DashboardLayoutHeaderProps, type DashboardLayoutHeaderTitleProps, type DashboardLayoutHeaderUserProps, type DashboardLayoutMobileNavItemProps, type DashboardLayoutMobileNavProps, type DashboardLayoutProps, type DashboardLayoutSidebarFooterProps, type DashboardLayoutSidebarHeaderProps, type DashboardLayoutSidebarNavGroupProps, type DashboardLayoutSidebarNavItemProps, type DashboardLayoutSidebarNavProps, type DashboardLayoutSidebarProps, type DashboardLayoutSidebarSectionProps, DataTable, type DataTableBulkActionsProps, type DataTableColumnHeaderProps, type DataTableColumnVisibilityProps, type DataTableContentProps, type DataTableContextValue, type DataTableDensity, type DataTableDensityToggleProps, type DataTableEmptyStateProps, type DataTableExportFormat, type DataTableExportProps, type DataTableFilterOption, type DataTableFilterProps, type DataTableFiltersProps, type DataTableLoadingProps, type DataTableMeta, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRowActionsProps, type DataTableSearchProps, type DataTableState, type DataTableTab, type DataTableTabsProps, type DataTableToolbarProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DialogWrapper, type DialogWrapperProps, EmptyState, type EmptyStateProps, Form, FormCheckbox, type FormCheckboxProps, type FormContextValue, FormDescription, type FormDescriptionProps, FormError, type FormErrorProps, type FormFieldContextValue, FormFieldProvider, FormFieldWrapper, type FormFieldWrapperProps, FormInput, type FormInputProps, FormLabel, type FormLabelProps, FormProvider, FormRadioGroup, type FormRadioGroupProps, type FormRootProps, FormSelect, type FormSelectProps, FormSwitch, type FormSwitchProps, FormTextarea, type FormTextareaProps, GlobalLoaderController, Input, type InputProps, Loader, type LoaderProps, LoaderProvider, type MaskType, type PaginatedResponse, type PaginationMeta, type PaginationParams, type RadioOption, RippleBackground, type RippleBackgroundProps, RippleEffect, type RippleEffectProps, RippleWrapper, type RippleWrapperProps, Select, SelectGroup, SelectItem, type SelectItemProps, SelectLabel, type SelectOption, type SelectProps, SelectSeparator, SelectionLayout, type SelectionLayoutCardProps, type SelectionLayoutEmptyProps, type SelectionLayoutHeaderProps, type SelectionLayoutHeadlineProps, type SelectionLayoutListProps, type SelectionLayoutLogoProps, type SelectionLayoutMainProps, type SelectionLayoutProps, type SelectionLayoutSearchProps, type SelectionLayoutSidebarProps, type SelectionLayoutStatsProps, type SelectionLayoutTabProps, type SelectionLayoutTabsProps, Switch, type SwitchProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, type TextareaProps, ThemeProvider, Toaster, type ToasterProps, type UseDataTableConfig, cn, loader, toast, useDashboardLayout, useDataTable, useDataTableColumnVisibility, useDataTableDensity, useDataTableEmpty, useDataTableInstance, useDataTableLoading, useDataTableMeta, useDataTablePagination, useDataTableSelection, useDataTableSorting, useDataTableState, useDebounce, useDebouncedCallback, useFormContext, useFormFieldContext, useLoader, useTheme };