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

package/dist/ui/organisms/SplitSidebar/hooks/useResponsiveSidebar.d.ts

@@ -0,0 +1,40 @@
+export interface UseResponsiveSidebarOptions {
+    /**
+     * Breakpoint in pixels for mobile detection
+     * @default 768
+     */
+    mobileBreakpoint?: number;
+    /**
+     * Callback when mobile state changes
+     */
+    onMobileChange?: (isMobile: boolean) => void;
+    /**
+     * Whether responsive behavior is enabled
+     * @default true
+     */
+    enabled?: boolean;
+}
+export interface UseResponsiveSidebarReturn {
+    /**
+     * Whether current viewport is mobile
+     */
+    isMobile: boolean;
+    /**
+     * Current viewport width
+     */
+    width: number;
+}
+/**
+ * Hook for responsive sidebar behavior
+ *
+ * Detects mobile breakpoints and provides responsive state.
+ *
+ * @example
+ * ```tsx
+ * const { isMobile, width } = useResponsiveSidebar({
+ *   mobileBreakpoint: 768,
+ *   onMobileChange: (isMobile) => console.log('Mobile:', isMobile)
+ * });
+ * ```
+ */
+export declare function useResponsiveSidebar({ mobileBreakpoint, onMobileChange, enabled, }?: UseResponsiveSidebarOptions): UseResponsiveSidebarReturn;

package/dist/ui/organisms/SplitSidebar/hooks/useSplitSidebar.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook to access SplitSidebar context
+ *
+ * Provides access to sidebar state and controls.
+ * Must be used within a SplitSidebar component.
+ *
+ * @example
+ * ```tsx
+ * const { collapsed, toggle, setCollapsed } = useSplitSidebar();
+ * ```
+ */
+export declare function useSplitSidebar(): import("..").SplitSidebarContextValue;

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

@@ -0,0 +1,6 @@
+export { default as SplitSidebar } from './SplitSidebar';
+export { SplitSidebar, SplitSidebarContext } from './SplitSidebar';
+export type { SplitSidebarProps, SplitSidebarContextValue } from './SplitSidebar';
+export * from './hooks';
+export * from './components';
+export * from './utils/splitSidebarHelpers';

package/dist/ui/organisms/SplitSidebar/utils/splitSidebarHelpers.d.ts

@@ -0,0 +1,21 @@
+import type { SplitSidebarProps } from '../SplitSidebar';
+/**
+ * Helper function to create a common playground configuration
+ */
+export declare function createPlaygroundSidebarConfig(overrides?: Partial<SplitSidebarProps>): Partial<SplitSidebarProps>;
+/**
+ * Helper function to create a mobile-optimized configuration
+ */
+export declare function createMobileSidebarConfig(overrides?: Partial<SplitSidebarProps>): Partial<SplitSidebarProps>;
+/**
+ * Helper function to create a compact sidebar configuration
+ */
+export declare function createCompactSidebarConfig(overrides?: Partial<SplitSidebarProps>): Partial<SplitSidebarProps>;
+/**
+ * Parse width string/number to pixels
+ */
+export declare function parseWidthToPixels(width: number | string): number;
+/**
+ * Format pixels to CSS width string
+ */
+export declare function formatPixelsToWidth(pixels: number): string;

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,20 @@
+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;
+export declare const WithValidation: Story;
+export declare const WithEvents: Story;
+export declare const HorizontalState: Story;
+export declare const VerticalState: Story;
+export declare const WithStepNumbersState: Story;
+export declare const WithoutStepNumbersState: Story;
+export declare const WithNavigationState: Story;
+export declare const WithoutNavigationState: 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,83 @@ 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>[];
+    onRowClick?: (row: T) => void;
+    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 = unknown>(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,25 @@ 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 declare const WithEvents: StoryObj<typeof Table>;
+export declare const DefaultState: StoryObj<typeof Table>;
+export declare const WithSortingState: StoryObj<typeof Table>;
+export declare const WithSelectionState: StoryObj<typeof Table>;
+export declare const LoadingStateSimple: StoryObj<typeof Table>;
+export declare const NoData: 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,13 @@
+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 declare const WithEvents: StoryObj<typeof TableActions>;
+export declare const DefaultState: StoryObj<typeof TableActions>;
+export declare const LeftAlignedState: StoryObj<typeof TableActions>;
+export declare const RightAlignedState: StoryObj<typeof TableActions>;
+export declare const WithDisabledActionState: StoryObj<typeof TableActions>;
+export declare const WithDangerActionState: 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,13 @@
+import { type HTMLAttributes, ReactNode } from 'react';
+export interface TableBodyProps<T extends Record<string, unknown> = Record<string, unknown>> extends Omit<HTMLAttributes<HTMLTableSectionElement>, 'children'> {
+    children?: (row: T, index: number) => ReactNode;
+    className?: string;
+}
+/**
+ * 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 = unknown> 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,10 @@
+import type { HTMLAttributes } from 'react';
+export type TableEmptyStateProps = 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,13 @@
+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 declare const WithEvents: StoryObj<typeof TableFilters>;
+export declare const DefaultState: StoryObj<typeof TableFilters>;
+export declare const WithInitialValuesState: StoryObj<typeof TableFilters>;
+export declare const TextFilterState: StoryObj<typeof TableFilters>;
+export declare const SelectFilterState: StoryObj<typeof TableFilters>;
+export declare const DateFilterState: 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,11 @@
+import type { HTMLAttributes } from 'react';
+export interface TableHeaderProps extends Omit<HTMLAttributes<HTMLTableSectionElement>, 'children'> {
+    className?: string;
+}
+/**
+ * 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,9 @@
+import type { HTMLAttributes } from 'react';
+export type TableHeaderRowProps = 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,15 @@
+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 declare const WithEvents: StoryObj<typeof TablePagination>;
+export declare const DefaultState: StoryObj<typeof TablePagination>;
+export declare const FirstPageState: StoryObj<typeof TablePagination>;
+export declare const MiddlePageState: StoryObj<typeof TablePagination>;
+export declare const LastPageState: StoryObj<typeof TablePagination>;
+export declare const WithoutPageSizeSelectorState: StoryObj<typeof TablePagination>;
+export declare const WithoutPageInfoState: StoryObj<typeof TablePagination>;
+export default meta;

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

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