@skalar-saas/design-system 0.1.67

package/dist/shared/ui/ProjectCard/ProjectCard.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { StatusState } from '@/shared/ui/Badge/Badge';
+/**
+ * Defines the public API for the ProjectCard component, extending standard div attributes.
+ */
+export interface ProjectCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    title: string;
+    companyImage: string;
+    badgeStatus: string;
+    badgeStatusState: StatusState;
+    onButtonAction?: () => void;
+    stackLabel: React.ReactNode;
+    powerLabel: React.ReactNode;
+    calendarLabel: React.ReactNode;
+    link1Label: string;
+    link1Href: string;
+    link2Label: string;
+    link2Href: string;
+    link2Status: StatusState;
+    onCardClick?: () => void;
+    className?: string;
+}
+/**
+ * A project card component for displaying project information in dashboard views.
+ *
+ * This component displays project details including company icon, title, status badge,
+ * metadata labels, and related links with independent status indicators.
+ *
+ * @param {string} title - The project title/name (required).
+ * @param {string} companyImage - Image URL representing the company/project.
+ * @param {string} badgeStatus - Text to display in the main status badge.
+ * @param {StatusState} badgeStatusState - Status state for the main status badge indicator.
+ * @param {() => void} [onButtonAction] - Callback for the action button click.
+ * @param {React.ReactNode} stackLabel - Label for the first metric (stack icon).
+ * @param {React.ReactNode} powerLabel - Label for the second metric (power icon).
+ * @param {React.ReactNode} calendarLabel - Label for the third metric (calendar icon).
+ * @param {string} link1Label - Text label for the first link (subdomain).
+ * @param {string} link1Href - URL for the first link.
+ * @param {string} link2Label - Text label for the second link (database).
+ * @param {string} link2Href - URL for the second link.
+ * @param {StatusState} link2Status - Status state for the second link badge.
+ * @param {() => void} [onCardClick] - Callback when card is clicked.
+ * @param {string} [className] - Additional CSS classes.
+ * @returns {JSX.Element} The rendered project card element.
+ */
+export declare const ProjectCard: React.ForwardRefExoticComponent<ProjectCardProps & React.RefAttributes<HTMLDivElement>>;

package/dist/shared/ui/ProjectCard/index.d.ts

@@ -0,0 +1,2 @@
+export { ProjectCard } from './ProjectCard';
+export type { ProjectCardProps } from './ProjectCard';

package/dist/shared/ui/ProjectCardPlan/ProjectCardPlan.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import { BadgeProps } from "@/shared/ui/Badge/Badge";
+export type ProjectCardTimeLabel = "month" | "week" | "year" | "day";
+export interface ProjectCardPlanItem {
+    icon: React.ReactNode;
+    itemLabel: string;
+    badge: string;
+    badgeTheme: BadgeProps["theme"];
+    progress: number;
+}
+export interface ProjectCardPlanProps extends React.HTMLAttributes<HTMLDivElement> {
+    planLabel: string;
+    priceLabel: string;
+    timeLabel: ProjectCardTimeLabel;
+    nextPaymentLabel: string;
+    dateLabel: string;
+    items: ProjectCardPlanItem[];
+    buttonLabel1: string;
+    onClickButton1?: () => void;
+    buttonLabel2: string;
+    onClickButton2?: () => void;
+}
+/**
+ * A component for displaying project plan information including pricing, plan details,
+ * and usage metrics with progress indicators. Includes action buttons for plan management.
+ */
+export declare const ProjectCardPlan: ({ className, planLabel, priceLabel, timeLabel, nextPaymentLabel, dateLabel, items, buttonLabel1, onClickButton1, buttonLabel2, onClickButton2, ...props }: ProjectCardPlanProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/ProjectCardPlan/index.d.ts

@@ -0,0 +1,2 @@
+export { ProjectCardPlan } from './ProjectCardPlan';
+export type { ProjectCardPlanProps } from './ProjectCardPlan';

package/dist/shared/ui/Radio/Radio.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+type RadioSize = 'small' | 'medium' | 'large';
+/**
+ * Defines the public API for the Radio component, omitting the native 'size'
+ * attribute to avoid conflicts with the custom size prop.
+ */
+export interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** The size of the radio button. */
+    size?: RadioSize;
+}
+/**
+ * @file An accessible, themeable radio button component.
+ * @description This component renders a custom-styled radio button that wraps a native,
+ * visually hidden `<input type="radio">` for accessibility. Radio buttons are intended
+ * to be used in groups (by providing the same `name` attribute) to allow for a single
+ * selection from a set of options.
+ *
+ * @param {RadioSize} [size='medium'] - The size of the radio button.
+ * @param {boolean} [checked=false] - The controlled checked state of the component.
+ * @param {boolean} [disabled=false] - If true, the component will be non-interactive.
+ * @returns {JSX.Element} The rendered Radio element.
+ */
+export declare const Radio: ({ size, checked, disabled, className, ...props }: RadioProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/Radio/index.d.ts

@@ -0,0 +1 @@
+export { Radio } from './Radio';

package/dist/shared/ui/RecoveryWidget/RecoveryWidget.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+export type RecoveryStep = "email" | "code";
+export type RecoveryType = "account" | "password";
+export interface RecoveryWidgetProps {
+    /** Title displayed in the widget header. Defaults to "Recuperación" */
+    title?: string;
+    /** Actions displayed in the widget header. Pass `null` to hide. Defaults to settings button */
+    actions?: React.ReactNode | null;
+    /** Step of the recovery process */
+    step: RecoveryStep;
+    /** Type of recovery: account or password */
+    type?: RecoveryType;
+    /** Callback when recovery form is submitted */
+    onSubmit?: (value: string) => void;
+    /** Callback when back to login is clicked */
+    onBackToLogin?: () => void;
+    /** Callback when settings button is clicked */
+    onSettings?: () => void;
+    /** Optional className for the widget container */
+    className?: string;
+}
+/**
+ * Recovery Widget - A unified recovery form for account and password recovery
+ * Supports both email input and code verification steps
+ */
+export declare const RecoveryWidget: ({ title, actions, step, type, onSubmit, onBackToLogin, onSettings, className, }: RecoveryWidgetProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/RecoveryWidget/index.d.ts

@@ -0,0 +1,2 @@
+export { RecoveryWidget } from './RecoveryWidget';
+export type { RecoveryWidgetProps, RecoveryStep, RecoveryType } from './RecoveryWidget';

package/dist/shared/ui/RelatedDataCard/RelatedDataCard.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+export interface RelatedDataItem {
+    /** Unique identifier */
+    id: string;
+    /** Item label */
+    label: string;
+    /** Item type (e.g., "Database", "API", "Service") */
+    type: string;
+}
+export interface RelatedDataCardProps {
+    /** Card title */
+    title?: string;
+    /** Array of related data items */
+    items?: RelatedDataItem[];
+    /** Additional CSS classes */
+    className?: string;
+    /** Callback when export icon is clicked */
+    onExportClick?: () => void;
+    /** Minimum width of the card */
+    minWidth?: number;
+    /** Maximum width of the card */
+    maxWidth?: number;
+    /** Opacity of the card (disabled state) */
+    opacity?: number;
+}
+/**
+ * RelatedDataCard - A disabled/readonly card displaying related data items
+ *
+ * Used in visualizer diagrams to show linked data sources or modules.
+ * The card is intentionally styled with reduced opacity to indicate
+ * it's not directly editable.
+ *
+ * @example
+ * ```tsx
+ * const relatedItems = [
+ *   { id: '1', label: 'Users', type: 'Database' },
+ *   { id: '2', label: 'Orders', type: 'API' },
+ * ];
+ *
+ * <RelatedDataCard
+ *   title="Related Modules"
+ *   items={relatedItems}
+ *   onExportClick={() => console.log('Export')}
+ * />
+ * ```
+ */
+export declare const RelatedDataCard: React.FC<RelatedDataCardProps>;

package/dist/shared/ui/RelatedDataCard/index.d.ts

@@ -0,0 +1 @@
+export { RelatedDataCard, type RelatedDataCardProps, type RelatedDataItem, } from './RelatedDataCard';

package/dist/shared/ui/SettingsCard/SettingsCard.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import { ProductIconType, ProductIconSize, ProductIconVariant } from "../ProductIcon/ProductIcon";
+export interface SettingsCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    subtitle?: string;
+    /** @ignore */
+    icon?: React.ReactNode;
+    iconType?: ProductIconType;
+    iconVariant?: ProductIconVariant;
+    iconSize?: ProductIconSize;
+    headerActions?: React.ReactNode;
+    children?: React.ReactNode;
+    footerText?: React.ReactNode;
+    footerActions?: React.ReactNode;
+    footerVariant?: "default" | "danger" | "warning" | "success";
+    classNameHeader?: string;
+    classNameBody?: string;
+    classNameFooter?: string;
+}
+/**
+ * A flexible settings card component with optional header, body, and footer sections.
+ * All sections are optional - only render what you need.
+ */
+export declare const SettingsCard: ({ className, title, subtitle, icon, iconType, iconVariant, iconSize, headerActions, children, footerText, footerActions, footerVariant, classNameHeader, classNameBody, classNameFooter, ...props }: SettingsCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/SettingsCard/index.d.ts

@@ -0,0 +1,2 @@
+export { SettingsCard } from './SettingsCard';
+export type { SettingsCardProps } from './SettingsCard';

package/dist/shared/ui/SidePanel/SidePanel.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { SidePanelProps } from './SidePanel.types';
+/**
+ * SidePanel - A flexible, reusable panel component that maintains consistency
+ * with the design system while allowing full control over internal content.
+ *
+ * @example
+ * ```tsx
+ * // Basic panel
+ * <SidePanel>
+ *   <div>Your content here</div>
+ * </SidePanel>
+ *
+ * // Panel with custom header
+ * <SidePanel borderSide="right" borderStyle="surface-3">
+ *   <div className="border-b border-surface-3 px-[24px] py-[16.5px]">
+ *     <h1 className="font-medium text-[20px] text-high-em">Title</h1>
+ *   </div>
+ *   <div className="flex-1 overflow-y-auto">
+ *     <p>Content</p>
+ *   </div>
+ * </SidePanel>
+ * ```
+ */
+export declare const SidePanel: React.NamedExoticComponent<SidePanelProps>;
+export default SidePanel;

package/dist/shared/ui/SidePanel/SidePanel.types.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+/**
+ * Props for the SidePanel component
+ */
+export interface SidePanelProps {
+    /**
+     * Content to be rendered inside the panel
+     */
+    children: ReactNode;
+    /**
+     * Additional CSS classes to apply to the panel container
+     */
+    className?: string;
+    /**
+     * Which side should have a border
+     * - 'left': Left border
+     * - 'right': Right border
+     * - 'none': No border
+     */
+    borderSide?: 'left' | 'right' | 'none';
+    /**
+     * Border color style from design system
+     * - 'surface-3': Lighter border (default)
+     * - 'surface-4': Darker border
+     */
+    borderStyle?: 'surface-3' | 'surface-4';
+}

package/dist/shared/ui/SidePanel/index.d.ts

@@ -0,0 +1,2 @@
+export { SidePanel, default } from './SidePanel';
+export type { SidePanelProps } from './SidePanel.types';

package/dist/shared/ui/SupportCard/SupportCard.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import { ButtonVariant, ButtonHierarchy } from "@/shared/ui/Button/Button";
+export interface SupportCardButtonItem {
+    icon?: React.ReactNode;
+    label: string;
+    variant?: ButtonVariant;
+    hierarchy?: ButtonHierarchy;
+    buttonOnClick?: () => void;
+}
+export interface SupportCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    title: string;
+    subtitle: string;
+    buttonItems: SupportCardButtonItem[];
+}
+/**
+ * A component for displaying a support card with a title, subtitle, and action buttons.
+ * Each button can have an icon, label, and custom variant/hierarchy styling.
+ */
+export declare const SupportCard: ({ className, title, subtitle, buttonItems, ...props }: SupportCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/SupportCard/index.d.ts

@@ -0,0 +1,2 @@
+export { SupportCard } from './SupportCard';
+export type { SupportCardProps, SupportCardButtonItem } from './SupportCard';

package/dist/shared/ui/Switcher/Switcher.d.ts

@@ -0,0 +1,41 @@
+type SwitcherSize = 'xs' | 'sm' | 'md' | 'lg' | 'ai-chat';
+/**
+ * Defines the shape for a single item in the Switcher.
+ */
+export interface SwitcherItem {
+    id: string | number;
+    label: string;
+}
+/**
+ * Defines the public API for the Switcher component.
+ */
+export interface SwitcherProps {
+    /** An array of item objects to be rendered as switcher options. */
+    items: SwitcherItem[];
+    /** The id of the currently selected item. */
+    value: string | number;
+    /** Callback function that is fired when an item is clicked. */
+    onChange: (id: string | number) => void;
+    /** The size of the switcher. */
+    size?: SwitcherSize;
+    /** If true, the switcher will have a border around its container. */
+    withBorder?: boolean;
+    /** Optional custom classes for the container. */
+    className?: string;
+}
+/**
+ * @file A segmented control component for single-choice selection.
+ * @description The Switcher displays a set of options in a pill-shaped container,
+ * with the active option highlighted. It is a fully controlled component, managed
+ * via the `value` and `onChange` props. All size-related styles are centralized
+ * in a configuration object for easy theming.
+ *
+ * @param {SwitcherItem[]} items - The array of options to display.
+ * @param {string | number} value - The controlled value of the selected item.
+ * @param {(id: string | number) => void} onChange - The callback fired when an item is selected.
+ * @param {SwitcherSize} [size='md'] - The size variant of the switcher.
+ * @param {boolean} [withBorder=false] - If true, adds a border to the component's container.
+ * @returns {JSX.Element} The rendered Switcher element.
+ */
+export declare const Switcher: ({ items, value, onChange, size, withBorder, className, }: SwitcherProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/Switcher/index.d.ts

@@ -0,0 +1 @@
+export { Switcher, type SwitcherItem } from './Switcher';

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

@@ -0,0 +1,136 @@
+import React from "react";
+import { TableLayoutOptions } from "./TableContext";
+export type SortDirection = "asc" | "desc" | null;
+export interface TableColumn<T = unknown> {
+    /** Unique identifier for the column */
+    id: string;
+    /** Header label */
+    header: string;
+    /** Accessor function to get cell value from row data */
+    accessor?: (row: T) => React.ReactNode;
+    /** Custom cell renderer */
+    cell?: (row: T) => React.ReactNode;
+    /** Component to render in the cell - enables dynamic component injection */
+    component?: React.ComponentType<{
+        value: unknown;
+        row: T;
+        rowIndex: number;
+    }>;
+    /** Data type for automatic component mapping (avatar, tag, text, number, date, etc.) */
+    dataType?: "avatar" | "tag" | "text" | "number" | "date" | "boolean" | "custom";
+    /** Props to pass to the component */
+    componentProps?: Record<string, unknown>;
+    /** Column width (flex-1 by default) */
+    width?: string;
+    /** Column size in pixels */
+    size?: number;
+    /** Minimum column size in pixels */
+    minSize?: number;
+    /** Maximum column size in pixels */
+    maxSize?: number;
+    /** Enable sorting for this column */
+    sortable?: boolean;
+    /** Enable filtering for this column */
+    filterable?: boolean;
+    /** Filter type for dynamic filter rendering */
+    filterType?: "text" | "select" | "date" | "number" | "boolean";
+    /** Filter options for select-type filters */
+    filterOptions?: Array<{
+        label: string;
+        value: unknown;
+    }>;
+    /** Column type for header styling */
+    type?: "select" | "text" | "sortable" | "filterable";
+}
+export interface TableAction {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onClick: () => void;
+    /** Component to render instead of default Button - enables dynamic component injection */
+    component?: React.ComponentType<{
+        value?: unknown;
+    }>;
+    /** Accessor function to get value for the component */
+    accessor?: () => unknown;
+    /** Props to pass to the component */
+    componentProps?: Record<string, unknown>;
+}
+export interface TableProps<T = unknown> {
+    /** Column definitions */
+    columns: TableColumn<T>[];
+    /** Data rows */
+    data: T[];
+    /** Table layout options */
+    tableLayout?: TableLayoutOptions;
+    /** Table title */
+    title?: React.ReactNode;
+    /** Enable search input in header */
+    showSearch?: boolean;
+    /** Search placeholder text */
+    searchPlaceholder?: string;
+    /** Search value */
+    searchValue?: string;
+    /** Callback when search changes */
+    onSearchChange?: (value: string) => void;
+    /** Header actions (Filters, Refresh, Settings) - accepts TableAction[] or React.ReactNode[] */
+    headerActions?: (TableAction | React.ReactNode)[];
+    /** Enable row selection with checkboxes */
+    selectable?: boolean;
+    /** Selected row IDs */
+    selectedRows?: Set<string | number>;
+    /** Callback when selection changes */
+    onSelectionChange?: (selected: Set<string | number>) => void;
+    /** Row ID accessor */
+    getRowId?: (row: T, index: number) => string | number;
+    /** Sorting state */
+    sortBy?: string;
+    sortDirection?: SortDirection;
+    /** Callback when sort changes */
+    onSortChange?: (columnId: string, direction: SortDirection) => void;
+    /** Enable virtualization */
+    virtualized?: boolean;
+    /** Container height for virtualization */
+    height?: string | number;
+    /** Show pagination footer */
+    showPagination?: boolean;
+    /** Current page */
+    currentPage?: number;
+    /** Total pages */
+    totalPages?: number;
+    /** Items per page */
+    itemsPerPage?: number;
+    /** Total items */
+    totalItems?: number;
+    /** Pagination callbacks */
+    onPageChange?: (page: number) => void;
+    onNextPage?: () => void;
+    onPreviousPage?: () => void;
+    /** Custom className */
+    className?: string;
+    /** Empty state title */
+    emptyStateTitle?: string;
+    /** Empty state description */
+    emptyStateDescription?: string;
+    /** Show clear filters button in empty state */
+    showClearFiltersButton?: boolean;
+}
+/**
+ * Highly flexible, virtualized table component for large datasets.
+ *
+ * This component initializes the table logic and provides context to child components.
+ * It does not render any UI elements directly.
+ *
+ * @example
+ * ```tsx
+ * <Table columns={columns} data={data} tableLayout={{ dense: true }}>
+ *   <TableRoot>
+ *     <TableHeader />
+ *     <TableBody />
+ *   </TableRoot>
+ * </Table>
+ * ```
+ */
+export declare const Table: <T extends Record<string, unknown>>({ columns, data, tableLayout, children, ...props }: TableProps<T> & {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,13 @@
+import React from "react";
+export interface TableBodyProps {
+    className?: string;
+    /** Empty state title */
+    emptyStateTitle?: string;
+    /** Empty state description */
+    emptyStateDescription?: string;
+    /** Show clear filters button in empty state */
+    showClearFiltersButton?: boolean;
+    /** Callback when clear filters is clicked */
+    onClearFilters?: () => void;
+}
+export declare const TableBody: React.FC<TableBodyProps>;

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

@@ -0,0 +1,6 @@
+import { type Cell } from "@tanstack/react-table";
+export interface TableCellProps<TData = unknown, TValue = unknown> {
+    cell: Cell<TData, TValue>;
+    className?: string;
+}
+export declare const TableCell: <TData = unknown, TValue = unknown>({ cell, className }: TableCellProps<TData, TValue>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/Table/TableColumnFilter.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface TableColumnFilterProps {
+    columnId: string;
+    className?: string;
+    options?: Array<{
+        label: string;
+        value: unknown;
+    }>;
+    title?: string;
+}
+export declare const TableColumnFilter: React.FC<TableColumnFilterProps>;

package/dist/shared/ui/Table/TableColumnHeader.d.ts

@@ -0,0 +1,6 @@
+import { type Header } from "@tanstack/react-table";
+export interface TableColumnHeaderProps<TData = unknown> {
+    header: Header<TData, unknown>;
+    className?: string;
+}
+export declare const TableColumnHeader: <TData = unknown>({ header, className, }: TableColumnHeaderProps<TData>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/Table/TableColumnVisibility.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export interface TableColumnVisibilityProps {
+    className?: string;
+    trigger?: React.ReactNode;
+    position?: "left" | "right";
+}
+export declare const TableColumnVisibility: React.FC<TableColumnVisibilityProps>;

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

@@ -0,0 +1,31 @@
+import React from "react";
+import type { Table as ReactTable } from "@tanstack/react-table";
+export interface TableLayoutOptions {
+    dense?: boolean;
+    cellBorder?: boolean;
+    rowBorder?: boolean;
+    headerBackground?: boolean;
+    headerBorder?: boolean;
+    virtualized?: boolean;
+    width?: 'auto' | 'fixed';
+    columnsVisibility?: boolean;
+    columnsResizable?: boolean;
+    rowHeight?: number;
+    cellAlign?: 'left' | 'center' | 'right' | 'start' | 'end';
+}
+export type TableContextValue<T = unknown> = {
+    table: ReactTable<T>;
+    tableLayout: TableLayoutOptions;
+    parentRef?: React.RefObject<HTMLDivElement | null>;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    showClearFiltersButton?: boolean;
+    resetAllFilters?: () => void;
+};
+export declare const TableContext: React.Context<TableContextValue<unknown> | null>;
+export declare const useTableContext: <T = unknown>() => TableContextValue<T>;
+export interface TableProviderProps<T = unknown> {
+    children: React.ReactNode;
+    value: TableContextValue<T>;
+}
+export declare const TableProvider: <T = unknown>({ children, value, }: TableProviderProps<T>) => React.FunctionComponentElement<React.ProviderProps<TableContextValue<unknown> | null>>;

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

@@ -0,0 +1,16 @@
+import React from "react";
+export interface TableEmptyStateProps {
+    /** Empty state title */
+    title?: string;
+    /** Empty state description */
+    description?: string;
+    /** Show clear filters button */
+    showClearFiltersButton?: boolean;
+    /** Callback when clear filters is clicked */
+    onClearFilters?: () => void;
+    /** Custom className */
+    className?: string;
+    /** Number of columns for colspan */
+    colSpan?: number;
+}
+export declare const TableEmptyState: React.FC<TableEmptyStateProps>;

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

@@ -0,0 +1,5 @@
+import React from "react";
+export interface TableHeaderProps {
+    className?: string;
+}
+export declare const TableHeader: React.FC<TableHeaderProps>;

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

@@ -0,0 +1,9 @@
+import React from "react";
+export interface TablePaginationProps {
+    showPagination?: boolean;
+    totalItems?: number;
+    className?: string;
+    sizes?: number[];
+    infoTemplate?: string;
+}
+export declare const TablePagination: React.FC<TablePaginationProps>;

package/dist/shared/ui/Table/TableRoot.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export interface TableRootProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const TableRoot: React.FC<TableRootProps>;

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

@@ -0,0 +1,8 @@
+import React from "react";
+export interface TableRowProps {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    isTBody?: boolean;
+}
+export declare const TableRow: React.FC<TableRowProps>;

package/dist/shared/ui/Table/configParser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration parser for JSON-based table setup
+ * Converts API configuration into React Table columns
+ */
+import type { TableColumn } from './Table';
+import type { TableColumnConfig } from './types';
+/**
+ * Converts a JSON column configuration into a React Table column
+ */
+export declare function parseColumnConfig<T extends Record<string, unknown>>(columnConfig: TableColumnConfig): TableColumn<T>;
+/**
+ * Converts an array of column configurations into React Table columns
+ */
+export declare function parseTableConfig<T extends Record<string, unknown>>(columns: TableColumnConfig[]): TableColumn<T>[];
+/**
+ * Utility to add selection column to parsed columns
+ */
+export declare function addSelectionColumn<T extends Record<string, unknown>>(columns: TableColumn<T>[]): TableColumn<T>[];