@fabio.caffarello/react-design-system 1.7.0 → 1.8.0

package/dist/ui/organisms/Stepper/Stepper.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+export type StepperStatus = 'pending' | 'active' | 'completed' | 'error';
+export interface StepperStep {
+    id: string;
+    title: string;
+    description?: string;
+    content: ReactNode;
+    status?: StepperStatus;
+    disabled?: boolean;
+}
+export interface StepperProps {
+    steps: StepperStep[];
+    currentStep?: number;
+    defaultCurrentStep?: number;
+    onStepChange?: (stepIndex: number) => void;
+    onComplete?: () => void;
+    allowNavigation?: boolean;
+    showStepNumbers?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+}
+/**
+ * Stepper Component
+ *
+ * A multi-step wizard component for guided workflows.
+ * Supports validation, navigation, and completion callbacks.
+ * Follows Atomic Design principles as an Organism component.
+ *
+ * @example
+ * ```tsx
+ * <Stepper
+ *   steps={[
+ *     { id: '1', title: 'Step 1', content: <div>Content 1</div> },
+ *     { id: '2', title: 'Step 2', content: <div>Content 2</div> },
+ *   ]}
+ *   onComplete={() => console.log('Completed!')}
+ * />
+ * ```
+ */
+export default function Stepper({ steps, currentStep: controlledCurrentStep, defaultCurrentStep, onStepChange, onComplete, allowNavigation, showStepNumbers, orientation, className, }: StepperProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Stepper/Stepper.stories.d.ts

@@ -0,0 +1,12 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import Stepper from './Stepper';
+declare const meta: Meta<typeof Stepper>;
+export default meta;
+type Story = StoryObj<typeof Stepper>;
+export declare const Default: Story;
+export declare const Vertical: Story;
+export declare const WithoutStepNumbers: Story;
+export declare const WithStatus: Story;
+export declare const WithError: Story;
+export declare const WithoutNavigation: Story;
+export declare const ComplexWorkflow: Story;

package/dist/ui/organisms/Stepper/Stepper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/organisms/Stepper/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Stepper';
+export type { StepperProps, StepperStep, StepperStatus } from './Stepper';

package/dist/ui/organisms/Table/Table.d.ts

@@ -1,11 +1,20 @@
 import type { HTMLAttributes, ReactNode } from "react";
-export interface TableColumn<T = any> {
-    key: string;
-    label: string;
-    render?: (value: any, row: T) => ReactNode;
-    sortable?: boolean;
-}
-interface Props<T = any> extends HTMLAttributes<HTMLTableElement> {
+import { type TableProviderProps } from './TableProvider';
+import type { FilterConfig, FilterValue } from './TableFilters/TableFilters';
+import type { TableAction } from './TableActions/TableActions';
+import type { TableColumn } from './TableTypes';
+import TableHeader from './TableHeader';
+import TableHeaderRow from './TableHeaderRow';
+import TableHeaderCell from './TableHeaderCell';
+import TableBody from './TableBody';
+import TableRow from './TableRow';
+import TableCell from './TableCell';
+import TableFilters from './TableFilters';
+import TablePagination from './TablePagination';
+import TableEmptyState from './TableEmptyState';
+import TableActions from './TableActions';
+export type { TableColumn } from './TableTypes';
+interface SimplifiedTableProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<HTMLAttributes<HTMLDivElement>, 'onSort' | 'children'> {
     columns: TableColumn<T>[];
     data: T[];
     loading?: boolean;
@@ -13,23 +22,82 @@ interface Props<T = any> extends HTMLAttributes<HTMLTableElement> {
     sortColumn?: string;
     sortDirection?: 'asc' | 'desc';
     emptyMessage?: string;
+    emptyStateTitle?: string;
+    emptyStateMessage?: string;
+    emptyStateIllustration?: ReactNode;
+    emptyStateAction?: ReactNode;
+    pagination?: {
+        page: number;
+        pageSize: number;
+        total: number;
+        onPageChange: (page: number) => void;
+        onPageSizeChange: (size: number) => void;
+        pageSizeOptions?: number[];
+    };
+    filters?: {
+        config: FilterConfig[];
+        onFilter: (filters: Record<string, FilterValue>) => void;
+        initialValues?: Record<string, FilterValue>;
+    };
+    selectable?: boolean;
+    selectedRows?: string[];
+    onSelectionChange?: (selected: string[]) => void;
+    rowId?: (row: T) => string;
+    actions?: (row: T) => TableAction<T>[];
+    paginationMode?: 'client' | 'server' | 'auto';
+    defaultPageSize?: number;
+    resizable?: boolean;
+    columnWidths?: Record<string, number>;
+    onColumnResize?: (columnKey: string, width: number) => void;
+    virtualScrolling?: boolean;
+    virtualScrollingOptions?: {
+        itemHeight?: number;
+        containerHeight?: number;
+        overscan?: number;
+    };
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    children?: never;
+}
+interface DeclarativeTableProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<TableProviderProps<T>, 'children'> {
+    children: ReactNode;
 }
+type TableProps<T extends Record<string, unknown> = Record<string, unknown>> = SimplifiedTableProps<T> | DeclarativeTableProps<T>;
 /**
  * Table Component
  *
- * A table component with sorting, loading states, and responsive design.
- * Follows Atomic Design principles as an Organism component.
+ * A comprehensive table component with sorting, pagination, filters, selection, and actions.
+ * Supports both simplified API (props-based) and declarative API (compound components).
  *
  * @example
  * ```tsx
+ * // Simplified API
  * <Table
- *   columns={[
- *     { key: 'name', label: 'Name', sortable: true },
- *     { key: 'status', label: 'Status' }
- *   ]}
- *   data={items}
+ *   columns={columns}
+ *   data={data}
+ *   pagination={{ page, pageSize, total, onPageChange }}
  * />
+ *
+ * // Declarative API
+ * <Table columns={columns} data={data}>
+ *   <Table.Filters />
+ *   <Table.Header />
+ *   <Table.Body />
+ *   <Table.Pagination />
+ * </Table>
  * ```
  */
-export default function Table<T = any>({ columns, data, loading, onSort, sortColumn, sortDirection, emptyMessage, className, ...props }: Props<T>): import("react/jsx-runtime").JSX.Element;
-export {};
+declare function TableComponent<T = any>(props: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace TableComponent {
+    var Header: typeof TableHeader;
+    var HeaderRow: typeof TableHeaderRow;
+    var HeaderCell: typeof TableHeaderCell;
+    var Body: typeof TableBody;
+    var Row: typeof TableRow;
+    var Cell: typeof TableCell;
+    var Filters: typeof TableFilters;
+    var Pagination: typeof TablePagination;
+    var EmptyState: typeof TableEmptyState;
+    var Actions: typeof TableActions;
+}
+export default TableComponent;

package/dist/ui/organisms/Table/Table.stories.d.ts

@@ -6,4 +6,19 @@ export declare const WithSorting: StoryObj<typeof Table>;
 export declare const WithCustomRendering: StoryObj<typeof Table>;
 export declare const Loading: StoryObj<typeof Table>;
 export declare const Empty: StoryObj<typeof Table>;
+export declare const WithPagination: StoryObj<typeof Table>;
+export declare const WithFilters: StoryObj<typeof Table>;
+export declare const WithSelection: StoryObj<typeof Table>;
+export declare const WithActions: StoryObj<typeof Table>;
+export declare const FullFeatured: StoryObj<typeof Table>;
+export declare const ClientSidePagination: StoryObj<typeof Table>;
+export declare const ServerSidePagination: StoryObj<typeof Table>;
+export declare const AutoDetectPagination: StoryObj<typeof Table>;
+export declare const DeclarativeAPI: StoryObj<typeof Table>;
+export declare const Accessibility: StoryObj<typeof Table>;
+export declare const KeyboardNavigation: StoryObj<typeof Table>;
+export declare const DashboardComposition: StoryObj<typeof Table>;
+export declare const EmptyState: StoryObj<typeof Table>;
+export declare const LoadingState: StoryObj<typeof Table>;
+export declare const LargeDataset: StoryObj<typeof Table>;
 export default meta;

package/dist/ui/organisms/Table/TableActions/TableActions.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from 'react';
+export interface TableAction<T extends Record<string, unknown> = Record<string, unknown>> {
+    label: string;
+    onClick: (row: T) => void;
+    variant?: 'default' | 'danger';
+    disabled?: boolean;
+    icon?: React.ReactNode;
+}
+export interface TableActionsProps<T extends Record<string, unknown> = Record<string, unknown>> extends HTMLAttributes<HTMLDivElement> {
+    actions: TableAction<T>[];
+    row: T;
+    align?: 'left' | 'right';
+}
+/**
+ * TableActions Component
+ *
+ * Dropdown menu for row actions in tables.
+ * Follows Atomic Design principles as a Molecule component.
+ *
+ * @example
+ * ```tsx
+ * <TableActions
+ *   row={rowData}
+ *   actions={[
+ *     { label: 'Edit', onClick: (row) => handleEdit(row) },
+ *     { label: 'Delete', onClick: (row) => handleDelete(row), variant: 'danger' },
+ *   ]}
+ * />
+ * ```
+ */
+export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ actions, row, align, className, ...props }: TableActionsProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableActions/TableActions.stories.d.ts

@@ -0,0 +1,7 @@
+import type { Meta, StoryObj } from "@storybook/react";
+import TableActions from "./TableActions";
+declare const meta: Meta<typeof TableActions>;
+export declare const Default: StoryObj<typeof TableActions>;
+export declare const WithDisabledAction: StoryObj<typeof TableActions>;
+export declare const LeftAligned: StoryObj<typeof TableActions>;
+export default meta;

package/dist/ui/organisms/Table/TableActions/TableActions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/organisms/Table/TableActions.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from 'react';
+export interface TableActionsProps<T extends Record<string, unknown> = Record<string, unknown>> extends HTMLAttributes<HTMLDivElement> {
+    row: T;
+    align?: 'left' | 'right';
+}
+/**
+ * TableActions Component
+ *
+ * Renders action dropdown menu for a table row.
+ * Uses actions configuration from Table context.
+ * Must be used within a Table component.
+ */
+export default function TableActions<T extends Record<string, unknown> = Record<string, unknown>>({ row, align, className, ...props }: TableActionsProps<T>): import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/organisms/Table/TableBody.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLAttributes, ReactNode } from 'react';
+export interface TableBodyProps<T extends Record<string, unknown> = Record<string, unknown>> extends HTMLAttributes<HTMLTableSectionElement> {
+    children?: (row: T, index: number) => ReactNode;
+}
+/**
+ * TableBody Component
+ *
+ * Renders the table body (tbody) with rows.
+ * Can render loading skeleton, empty state, or data rows.
+ * Must be used within a Table component.
+ */
+export default function TableBody({ children, className, ...props }: TableBodyProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableCell.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from 'react';
+import type { TableColumn } from './TableTypes';
+export interface TableCellProps<T = any> extends HTMLAttributes<HTMLTableCellElement> {
+    column: TableColumn<T>;
+    row: T;
+}
+/**
+ * TableCell Component
+ *
+ * Renders a table cell (td) for a column.
+ * Uses column.render if available, otherwise renders the raw value.
+ * Must be used within a Table component.
+ */
+export default function TableCell<T extends Record<string, unknown> = Record<string, unknown>>({ column, row, className, ...props }: TableCellProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableContext.d.ts

@@ -0,0 +1,75 @@
+import type { ReactNode } from 'react';
+import type { TableColumn } from './TableTypes';
+import type { FilterConfig } from './TableFilters/TableFilters';
+import type { TableAction } from './TableActions/TableActions';
+export type PaginationMode = 'client' | 'server' | 'auto';
+export interface PaginationState {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+}
+export interface SortState {
+    column: string;
+    direction: 'asc' | 'desc';
+}
+import type { FilterValue } from './TableFilters/TableFilters';
+export interface FilterState {
+    values: Record<string, FilterValue>;
+    config: FilterConfig[];
+}
+export interface SelectionState {
+    selectedRows: string[];
+    isAllSelected: boolean;
+    isIndeterminate: boolean;
+}
+export interface TableContextValue<T extends Record<string, unknown> = Record<string, unknown>> {
+    columns: TableColumn<T>[];
+    data: T[];
+    paginatedData: T[];
+    loading: boolean;
+    paginationState: PaginationState;
+    sortState: SortState;
+    filterState: FilterState;
+    selectionState: SelectionState;
+    paginationMode: PaginationMode;
+    selectable: boolean;
+    rowId?: (row: T) => string;
+    actions?: (row: T) => TableAction<T>[];
+    resizable?: boolean;
+    columnWidths?: Record<string, number>;
+    virtualScrolling?: boolean;
+    emptyMessage?: string;
+    emptyStateTitle?: string;
+    emptyStateMessage?: string;
+    emptyStateIllustration?: ReactNode;
+    emptyStateAction?: ReactNode;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    setSorting: (column: string, direction: 'asc' | 'desc') => void;
+    setFilters: (filters: Record<string, FilterValue>) => void;
+    setSelection: (selected: string[]) => void;
+    toggleRowSelection: (rowId: string) => void;
+    toggleSelectAll: () => void;
+    getRowId: (row: T, index: number) => string;
+    setColumnWidth?: (columnKey: string, width: number) => void;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+    onSort?: (column: string, direction: 'asc' | 'desc') => void;
+    onFilter?: (filters: Record<string, FilterValue>) => void;
+    onSelectionChange?: (selected: string[]) => void;
+    onRowClick?: (row: T) => void;
+    onColumnResize?: (columnKey: string, width: number) => void;
+}
+declare const TableContext: import("react").Context<TableContextValue<Record<string, unknown>> | undefined>;
+/**
+ * Hook to access Table context
+ *
+ * @throws Error if used outside of Table component
+ */
+export declare function useTableContext<T extends Record<string, unknown> = Record<string, unknown>>(): TableContextValue<T>;
+/**
+ * Hook to access Table context (optional, returns undefined if not in Table)
+ */
+export declare function useTableContextOptional<T extends Record<string, unknown> = Record<string, unknown>>(): TableContextValue<T> | undefined;
+export { TableContext };

package/dist/ui/organisms/Table/TableEmptyState.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes } from 'react';
+export interface TableEmptyStateProps extends HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * TableEmptyState Component
+ *
+ * Renders empty state when table has no data.
+ * Uses empty state configuration from Table context.
+ * Must be used within a Table component.
+ */
+export default function TableEmptyState({ className, ...props }: TableEmptyStateProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableFilters/TableFilters.d.ts

@@ -0,0 +1,37 @@
+import type { HTMLAttributes } from 'react';
+export type FilterType = 'text' | 'select' | 'date';
+export interface FilterConfig {
+    key: string;
+    label: string;
+    type: FilterType;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+}
+export type FilterValue = string | number | boolean | null | undefined;
+export interface TableFiltersProps extends HTMLAttributes<HTMLDivElement> {
+    filters: FilterConfig[];
+    onFilter: (filters: Record<string, FilterValue>) => void;
+    initialValues?: Record<string, FilterValue>;
+    showClearAll?: boolean;
+}
+/**
+ * TableFilters Component
+ *
+ * Filter controls for tables with support for text, select, and date filters.
+ * Follows Atomic Design principles as a Molecule component.
+ *
+ * @example
+ * ```tsx
+ * <TableFilters
+ *   filters={[
+ *     { key: 'status', label: 'Status', type: 'select', options: [...] },
+ *     { key: 'search', label: 'Search', type: 'text', placeholder: 'Search...' }
+ *   ]}
+ *   onFilter={(filters) => handleFilter(filters)}
+ * />
+ * ```
+ */
+export default function TableFilters({ filters, onFilter, initialValues, showClearAll, className, ...props }: TableFiltersProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableFilters/TableFilters.stories.d.ts

@@ -0,0 +1,7 @@
+import type { Meta, StoryObj } from "@storybook/react";
+import TableFilters from "./TableFilters";
+declare const meta: Meta<typeof TableFilters>;
+export declare const Default: StoryObj<typeof TableFilters>;
+export declare const WithInitialValues: StoryObj<typeof TableFilters>;
+export declare const WithDateFilter: StoryObj<typeof TableFilters>;
+export default meta;

package/dist/ui/organisms/Table/TableFilters/TableFilters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/organisms/Table/TableFilters.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from 'react';
+export interface TableFiltersProps extends HTMLAttributes<HTMLDivElement> {
+    showClearAll?: boolean;
+}
+/**
+ * TableFilters Component
+ *
+ * Renders filter controls for the table.
+ * Uses filter configuration from Table context.
+ * Must be used within a Table component.
+ */
+export default function TableFilters({ showClearAll, className, ...props }: TableFiltersProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/organisms/Table/TableHeader.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes } from 'react';
+export interface TableHeaderProps extends HTMLAttributes<HTMLTableSectionElement> {
+}
+/**
+ * TableHeader Component
+ *
+ * Renders the table header (thead) with columns.
+ * Must be used within a Table component.
+ */
+export default function TableHeader({ className, ...props }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableHeaderCell.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from 'react';
+import type { TableColumn } from './TableTypes';
+export interface TableHeaderCellProps extends HTMLAttributes<HTMLTableCellElement> {
+    column: TableColumn;
+    resizable?: boolean;
+    width?: number;
+    onResize?: (columnKey: string, width: number) => void;
+    minWidth?: number;
+    maxWidth?: number;
+}
+/**
+ * TableHeaderCell Component
+ *
+ * Renders a header cell (th) for a column.
+ * Supports sorting if column is sortable.
+ * Must be used within a Table component.
+ */
+export default function TableHeaderCell({ column, resizable, width, onResize, minWidth, maxWidth, className, ...props }: TableHeaderCellProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableHeaderRow.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes } from 'react';
+export interface TableHeaderRowProps extends HTMLAttributes<HTMLTableRowElement> {
+}
+/**
+ * TableHeaderRow Component
+ *
+ * Renders a header row (tr) with header cells.
+ * Must be used within a Table component.
+ */
+export default function TableHeaderRow({ className, ...props }: TableHeaderRowProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TablePagination/TablePagination.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes } from 'react';
+export interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
+    page: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (size: number) => void;
+    pageSizeOptions?: number[];
+    showPageSizeSelector?: boolean;
+    showPageInfo?: boolean;
+}
+/**
+ * TablePagination Component
+ *
+ * Pagination controls for tables with page navigation and page size selection.
+ * Follows Atomic Design principles as a Molecule component.
+ *
+ * @example
+ * ```tsx
+ * <TablePagination
+ *   page={1}
+ *   pageSize={10}
+ *   total={100}
+ *   onPageChange={(page) => setPage(page)}
+ *   onPageSizeChange={(size) => setPageSize(size)}
+ * />
+ * ```
+ */
+export default function TablePagination({ page, pageSize, total, onPageChange, onPageSizeChange, pageSizeOptions, showPageSizeSelector, showPageInfo, className, ...props }: TablePaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TablePagination/TablePagination.stories.d.ts

@@ -0,0 +1,8 @@
+import type { Meta, StoryObj } from "@storybook/react";
+import TablePagination from "./TablePagination";
+declare const meta: Meta<typeof TablePagination>;
+export declare const Default: StoryObj<typeof TablePagination>;
+export declare const WithoutPageSizeSelector: StoryObj<typeof TablePagination>;
+export declare const WithoutPageInfo: StoryObj<typeof TablePagination>;
+export declare const LargeDataset: StoryObj<typeof TablePagination>;
+export default meta;

package/dist/ui/organisms/Table/TablePagination/TablePagination.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ui/organisms/Table/TablePagination.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from 'react';
+export interface TablePaginationProps extends HTMLAttributes<HTMLDivElement> {
+    showPageSizeSelector?: boolean;
+    showPageInfo?: boolean;
+    pageSizeOptions?: number[];
+}
+/**
+ * TablePagination Component
+ *
+ * Renders pagination controls for the table.
+ * Uses pagination state from Table context.
+ * Must be used within a Table component.
+ */
+export default function TablePagination({ showPageSizeSelector, showPageInfo, pageSizeOptions, className, ...props }: TablePaginationProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/organisms/Table/TableProvider.d.ts

@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react';
+import { type PaginationMode } from './TableContext';
+import type { TableColumn } from './TableTypes';
+import type { FilterConfig, FilterValue } from './TableFilters/TableFilters';
+import type { TableAction } from './TableActions/TableActions';
+export interface TableProviderProps<T extends Record<string, unknown> = Record<string, unknown>> {
+    columns: TableColumn<T>[];
+    data: T[];
+    loading?: boolean;
+    paginationMode?: PaginationMode;
+    page?: number;
+    pageSize?: number;
+    total?: number;
+    onPageChange?: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    sortColumn?: string;
+    sortDirection?: 'asc' | 'desc';
+    onSort?: (column: string, direction: 'asc' | 'desc') => void;
+    defaultSortColumn?: string;
+    defaultSortDirection?: 'asc' | 'desc';
+    filters?: FilterConfig[];
+    filterValues?: Record<string, FilterValue>;
+    onFilter?: (filters: Record<string, FilterValue>) => void;
+    initialFilterValues?: Record<string, FilterValue>;
+    selectable?: boolean;
+    selectedRows?: string[];
+    onSelectionChange?: (selected: string[]) => void;
+    rowId?: (row: T) => string;
+    actions?: (row: T) => TableAction<T>[];
+    emptyMessage?: string;
+    emptyStateTitle?: string;
+    emptyStateMessage?: string;
+    emptyStateIllustration?: ReactNode;
+    emptyStateAction?: ReactNode;
+    onRowClick?: (row: T) => void;
+    resizable?: boolean;
+    columnWidths?: Record<string, number>;
+    onColumnResize?: (columnKey: string, width: number) => void;
+    virtualScrolling?: boolean;
+    virtualScrollingOptions?: {
+        itemHeight?: number;
+        containerHeight?: number;
+        overscan?: number;
+    };
+    children: ReactNode;
+}
+/**
+ * TableProvider Component
+ *
+ * Manages table state (pagination, sorting, filters, selection) and provides it via Context.
+ * Supports both client-side and server-side pagination with auto-detection.
+ */
+export declare function TableProvider<T extends Record<string, unknown> = Record<string, unknown>>({ columns, data, loading, paginationMode: explicitMode, page: controlledPage, pageSize: controlledPageSize, total: externalTotal, onPageChange, onPageSizeChange, defaultPageSize, pageSizeOptions, sortColumn: controlledSortColumn, sortDirection: controlledSortDirection, onSort, defaultSortColumn, defaultSortDirection, filters, filterValues: controlledFilterValues, onFilter, initialFilterValues, selectable, selectedRows: controlledSelectedRows, onSelectionChange, rowId, actions, emptyMessage, emptyStateTitle, emptyStateMessage, emptyStateIllustration, emptyStateAction, onRowClick, resizable, columnWidths, onColumnResize, virtualScrolling, virtualScrollingOptions, children, }: TableProviderProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableRow.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes } from 'react';
+export interface TableRowProps<T extends Record<string, unknown> = Record<string, unknown>> extends HTMLAttributes<HTMLTableRowElement> {
+    row: T;
+    rowIndex: number;
+    style?: React.CSSProperties;
+}
+/**
+ * TableRow Component
+ *
+ * Renders a table row (tr) with cells.
+ * Supports selection and row click.
+ * Must be used within a Table component.
+ */
+export default function TableRow<T extends Record<string, unknown> = Record<string, unknown>>({ row, rowIndex, className, onClick, style, ...props }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/ui/organisms/Table/TableTypes.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface TableColumn<T = Record<string, unknown>> {
+    key: keyof T | string;
+    label: string;
+    render?: (value: unknown, row: T) => ReactNode;
+    sortable?: boolean;
+    hiddenOnMobile?: boolean;
+}