@juspay/blend-design-system 0.0.1

package/dist/components/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,8 @@
+import { BreadcrumbItemType } from './types';
+declare const Breadcrumb: {
+    ({ items }: {
+        items: BreadcrumbItemType[];
+    }): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export default Breadcrumb;

package/dist/components/Breadcrumb/breadcrumb.tokens.d.ts

@@ -0,0 +1,31 @@
+import { CSSObject } from 'styled-components';
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { BreakpointType } from '../../breakpoints/breakPoints';
+type BreadcrumbItemType = 'active' | 'inactive';
+export type BreadcrumbTokenType = {
+    height: CSSObject['height'];
+    padding: CSSObject['padding'];
+    gap: CSSObject['gap'];
+    item: {
+        padding: CSSObject['padding'];
+        gap: CSSObject['gap'];
+        fontSize: {
+            [key in BreadcrumbItemType]: CSSObject['fontSize'];
+        };
+        fontWeight: {
+            [key in BreadcrumbItemType]: CSSObject['fontWeight'];
+        };
+        color: {
+            [key in BreadcrumbItemType]: CSSObject['color'];
+        };
+        background: {
+            [key in BreadcrumbItemType]: CSSObject['background'];
+        };
+    };
+};
+export type ResponsiveBreadcrumbTokens = {
+    [key in keyof BreakpointType]: BreadcrumbTokenType;
+};
+declare const breadcrumbTokens: BreadcrumbTokenType;
+export declare const getBreadcrumbTokens: (foundationToken: FoundationTokenType) => ResponsiveBreadcrumbTokens;
+export default breadcrumbTokens;

package/dist/components/Breadcrumb/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Breadcrumb } from './Breadcrumb';
+export * from './types';

package/dist/components/Breadcrumb/types.d.ts

@@ -0,0 +1,6 @@
+export type BreadcrumbItemType = {
+    leftSlot?: React.ReactNode;
+    rightSlot?: React.ReactNode;
+    label: string;
+    href: string;
+};

package/dist/components/Button/Button.d.ts

@@ -0,0 +1,18 @@
+import { ButtonSize, ButtonSubType, ButtonType } from './types';
+declare const Button: import('react').ForwardRefExoticComponent<{
+    buttonType?: ButtonType;
+    size?: ButtonSize;
+    subType?: ButtonSubType;
+    text?: string;
+    leadingIcon?: React.ReactNode;
+    trailingIcon?: React.ReactNode;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    loading?: boolean;
+    buttonGroupPosition?: "center" | "left" | "right";
+    fullWidth?: boolean;
+    justifyContent?: import('styled-components').CSSObject["justifyContent"];
+} & Omit<import('react').ButtonHTMLAttributes<HTMLButtonElement>, "style" | "className"> & import('react').RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/components/Button/button.tokens.d.ts

@@ -0,0 +1,61 @@
+import { CSSObject } from 'styled-components';
+import { ButtonSize, ButtonSubType, ButtonType } from './types';
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { BreakpointType } from '../../breakpoints/breakPoints';
+export type ButtonState = 'default' | 'hover' | 'active' | 'disabled';
+export type ButtonTokensType = {
+    gap: CSSObject['gap'];
+    backgroundColor: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['background'];
+            };
+        };
+    };
+    color: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['color'];
+            };
+        };
+    };
+    borderRadius: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['borderRadius'];
+            };
+        };
+    };
+    padding: {
+        [key in ButtonSize]: {
+            [key in ButtonSubType]: CSSObject['padding'];
+        };
+    };
+    border: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['border'];
+            };
+        };
+    };
+    shadow: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['boxShadow'];
+            };
+        };
+    };
+    outline: {
+        [key in ButtonType]: {
+            [key in ButtonSubType]: {
+                [key in ButtonState]: CSSObject['outline'];
+            };
+        };
+    };
+};
+declare const buttonTokens: ButtonTokensType;
+export type ResponsiveButtonTokens = {
+    [key in keyof BreakpointType]: ButtonTokensType;
+};
+export declare const getButtonTokens: (foundationToken: FoundationTokenType) => ResponsiveButtonTokens;
+export default buttonTokens;

package/dist/components/Button/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Button } from './Button';
+export * from './types';

package/dist/components/Button/types.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+import { CSSObject } from 'styled-components';
+export declare enum ButtonType {
+    PRIMARY = "primary",
+    SECONDARY = "secondary",
+    DANGER = "danger",
+    SUCCESS = "success"
+}
+export declare enum ButtonSize {
+    SMALL = "sm",
+    MEDIUM = "md",
+    LARGE = "lg"
+}
+export declare enum ButtonSubType {
+    DEFAULT = "default",
+    ICON_ONLY = "iconOnly",
+    INLINE = "inline"
+}
+export type ButtonV2Props = {
+    buttonType?: ButtonType;
+    size?: ButtonSize;
+    subType?: ButtonSubType;
+    text?: string;
+    leadingIcon?: React.ReactNode;
+    trailingIcon?: React.ReactNode;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    loading?: boolean;
+    buttonGroupPosition?: 'center' | 'left' | 'right';
+    fullWidth?: boolean;
+    justifyContent?: CSSObject['justifyContent'];
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'style' | 'className'>;

package/dist/components/ButtonGroup/ButtonGroup.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ButtonGroupProps } from './types';
+declare const ButtonGroupV2: React.FC<ButtonGroupProps>;
+export default ButtonGroupV2;

package/dist/components/ButtonGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ButtonGroup } from './ButtonGroup';
+export * from './types';

package/dist/components/ButtonGroup/types.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+import { ButtonV2Props } from '../Button';
+export type ButtonGroupProps = {
+    stacked?: boolean;
+    children: ReactElement<ButtonV2Props> | ReactElement<ButtonV2Props>[];
+};

package/dist/components/Charts/ChartHeader.d.ts

@@ -0,0 +1,2 @@
+import { ChartHeaderProps } from './types';
+export declare const ChartHeader: React.FC<ChartHeaderProps>;

package/dist/components/Charts/ChartLegend.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { ChartLegendsProps } from './types';
+export declare const ChartLegends: React.NamedExoticComponent<ChartLegendsProps>;

package/dist/components/Charts/ChartUtils.d.ts

@@ -0,0 +1,5 @@
+import { NewNestedDataPoint, FlattenedDataPoint } from './types';
+export declare function transformNestedData(data: NewNestedDataPoint[], selectedKeys?: string[]): FlattenedDataPoint[];
+export declare function lightenHexColor(hex: string, amount?: number): string;
+export declare const formatNumber: (value: number | string) => string;
+export declare const capitaliseCamelCase: (text: string) => string;

package/dist/components/Charts/Charts.d.ts

@@ -0,0 +1,3 @@
+import { ChartsProps } from './types';
+declare const Charts: React.FC<ChartsProps>;
+export default Charts;

package/dist/components/Charts/CustomTooltip.d.ts

@@ -0,0 +1,2 @@
+import { CustomTooltipProps } from './types';
+export declare const CustomTooltip: ({ active, payload, label, hoveredKey, originalData, setHoveredKey, chartType, selectedKeys, }: CustomTooltipProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Charts/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Charts } from './Charts';
+export * from './types';

package/dist/components/Charts/renderChart.d.ts

@@ -0,0 +1,2 @@
+import { RenderChartProps } from './types';
+export declare const renderChart: ({ flattenedData, chartType, hoveredKey, lineKeys, colors, setHoveredKey, xAxisLabel, yAxisLabel, data: originalData, selectedKeys, }: RenderChartProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Charts/types.d.ts

@@ -0,0 +1,83 @@
+import { ReactNode } from 'react';
+import { TooltipProps } from 'recharts';
+import { NameType, ValueType } from 'recharts/types/component/DefaultTooltipContent';
+export type DataPoint = {
+    primary: {
+        label: string;
+        val: number;
+    };
+    aux?: {
+        label: string;
+        val: number;
+    }[];
+};
+export declare enum ChartLegendPosition {
+    TOP = "top",
+    RIGHT = "right"
+}
+export declare enum ChartType {
+    LINE = "line",
+    BAR = "bar",
+    PIE = "pie"
+}
+export type NewNestedDataPoint = {
+    name: string;
+    data: {
+        [key: string]: DataPoint;
+    };
+};
+export type RenderChartProps = {
+    flattenedData: FlattenedDataPoint[];
+    chartType: ChartType;
+    hoveredKey: string | null;
+    lineKeys: string[];
+    colors: string[];
+    setHoveredKey: (key: string | null) => void;
+    xAxisLabel?: string;
+    yAxisLabel?: string;
+    data: NewNestedDataPoint[];
+    selectedKeys: string[];
+};
+export type ChartsProps = {
+    chartType?: ChartType;
+    data: NewNestedDataPoint[];
+    xAxisLabel?: string;
+    yAxisLabel?: string;
+    colors?: string[];
+    metrics?: string[];
+    slot1?: ReactNode;
+    slot2?: ReactNode;
+    slot3?: ReactNode;
+    legendPosition?: ChartLegendPosition;
+    chartHeaderSlot: ReactNode;
+};
+export type FlattenedDataPoint = {
+    name: string;
+    [key: string]: number | string;
+};
+export type ChartHeaderProps = {
+    slot1: React.ReactNode;
+    slot2: React.ReactNode;
+    slot3: React.ReactNode;
+    chartHeaderSlot: ReactNode;
+};
+export type ChartLegendsProps = {
+    chartContainerRef: React.RefObject<HTMLDivElement>;
+    keys: string[];
+    colors: string[];
+    handleLegendClick: (key: string) => void;
+    handleLegendEnter: (key: string) => void;
+    handleLegendLeave: () => void;
+    selectedKeys: string[];
+    setSelectedKeys: (keys: string[]) => void;
+    hoveredKey: string | null;
+    activeKeys: string[] | null;
+    stacked?: boolean;
+};
+export type CustomTooltipProps = TooltipProps<ValueType, NameType> & {
+    hoveredKey: string | null;
+    originalData: NewNestedDataPoint[];
+    setHoveredKey: (key: string) => void;
+    chartType: ChartType;
+    selectedKeys: string[];
+};

package/dist/components/Charts/utils.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_COLORS: string[];

package/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,3 @@
+import { CheckboxProps } from './types';
+export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLButtonElement>>;
+export default Checkbox;

package/dist/components/Checkbox/StyledCheckbox.d.ts

@@ -0,0 +1,11 @@
+import { CheckboxSize } from './types';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+export declare const StyledCheckboxRoot: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<CheckboxPrimitive.CheckboxProps & import('react').RefAttributes<HTMLButtonElement>, {
+    size: CheckboxSize;
+    $isDisabled: boolean;
+    $checked: boolean | "indeterminate";
+    $error?: boolean;
+}>> & string & Omit<import('react').ForwardRefExoticComponent<CheckboxPrimitive.CheckboxProps & import('react').RefAttributes<HTMLButtonElement>>, keyof import('react').Component<any, {}, any>>;
+export declare const StyledCheckboxIndicator: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<CheckboxPrimitive.CheckboxIndicatorProps & import('react').RefAttributes<HTMLSpanElement>, {
+    size: CheckboxSize;
+}>> & string & Omit<import('react').ForwardRefExoticComponent<CheckboxPrimitive.CheckboxIndicatorProps & import('react').RefAttributes<HTMLSpanElement>>, keyof import('react').Component<any, {}, any>>;

package/dist/components/Checkbox/checkbox.token.d.ts

@@ -0,0 +1,96 @@
+import { CSSObject } from 'styled-components';
+import { ThemeType } from '../../tokens';
+import { CheckboxCheckedState, CheckboxInteractionState, CheckboxSize } from './types';
+import { BreakpointType } from '../../breakpoints/breakPoints';
+export type CheckboxTokensType = {
+    gap: CSSObject['gap'];
+    slotGap: CSSObject['gap'];
+    checkboxMarginRight: CSSObject['marginRight'];
+    indicator: {
+        size: {
+            [key in CheckboxSize]: {
+                width: CSSObject['width'];
+                height: CSSObject['height'];
+            };
+        };
+        background: {
+            [key in CheckboxCheckedState]?: {
+                [key in CheckboxInteractionState]?: CSSObject['backgroundColor'];
+            };
+        };
+        border: {
+            radius: CSSObject['borderRadius'];
+            width: CSSObject['borderWidth'];
+            color: {
+                [key in CheckboxCheckedState]?: {
+                    [key in CheckboxInteractionState]?: CSSObject['borderColor'];
+                };
+            };
+        };
+        focus: {
+            outlineColor: CSSObject['borderColor'];
+            outlineWidth: CSSObject['borderWidth'];
+            outlineOffset: CSSObject['outlineOffset'];
+            boxShadow: CSSObject['boxShadow'];
+        };
+    };
+    icon: {
+        color: {
+            [key in Exclude<CheckboxCheckedState, 'unchecked'>]?: {
+                [key in Extract<CheckboxInteractionState, 'default' | 'disabled'>]?: CSSObject['color'];
+            };
+        };
+        size: {
+            [key in CheckboxSize]: {
+                width: CSSObject['width'];
+                height: CSSObject['height'];
+                strokeWidth: CSSObject['strokeWidth'];
+            };
+        };
+    };
+    content: {
+        gap: CSSObject['gap'];
+        label: {
+            color: {
+                [key in Exclude<CheckboxInteractionState, 'hover'>]: CSSObject['color'];
+            };
+            font: {
+                [key in CheckboxSize]: {
+                    fontSize: CSSObject['fontSize'];
+                    fontWeight: CSSObject['fontWeight'];
+                };
+            };
+        };
+        subtext: {
+            color: {
+                [key in Exclude<CheckboxInteractionState, 'hover'>]: CSSObject['color'];
+            };
+            font: {
+                [key in CheckboxSize]: {
+                    fontSize: CSSObject['fontSize'];
+                    fontWeight: CSSObject['fontWeight'];
+                };
+            };
+            spacing: {
+                left: {
+                    [key in CheckboxSize]: CSSObject['marginLeft'];
+                };
+                top: CSSObject['marginTop'];
+            };
+        };
+    };
+    required: {
+        color: CSSObject['color'];
+        spacing: CSSObject['marginLeft'];
+    };
+    transition: {
+        duration: CSSObject['transitionDuration'];
+        easing: CSSObject['transitionTimingFunction'];
+    };
+};
+export type ResponsiveCheckboxTokens = {
+    [key in keyof BreakpointType]: CheckboxTokensType;
+};
+export declare const getCheckboxTokens: (foundationToken: ThemeType) => ResponsiveCheckboxTokens;
+declare const checkboxTokens: ResponsiveCheckboxTokens;
+export default checkboxTokens;

package/dist/components/Checkbox/checkboxUtils.d.ts

@@ -0,0 +1,68 @@
+import { CheckboxSize } from './types';
+import { CheckboxTokensType } from './checkbox.token';
+export declare const getCheckboxDataState: (checked: boolean | "indeterminate") => string;
+export declare const extractPixelValue: (tokenValue: string | number | undefined) => number;
+/**
+ * Determines if the checkbox component is controlled based on the checked prop
+ */
+export declare const isControlledCheckbox: (checked: boolean | "indeterminate" | undefined) => boolean;
+/**
+ * Creates input props for controlled vs uncontrolled components
+ */
+export declare const createCheckboxInputProps: (checked: boolean | "indeterminate" | undefined, defaultChecked: boolean) => {
+    checked: boolean | undefined;
+    defaultChecked?: undefined;
+} | {
+    defaultChecked: boolean;
+    checked?: undefined;
+};
+/**
+ * Gets the current checked state for styling purposes
+ */
+export declare const getCurrentCheckedState: (checked: boolean | "indeterminate" | undefined, defaultChecked: boolean) => boolean | "indeterminate";
+/**
+ * Gets the icon color based on checkbox state
+ */
+export declare const getCheckboxIconColor: (tokens: CheckboxTokensType, currentChecked: boolean | "indeterminate", disabled: boolean) => string;
+/**
+ * Gets the text color based on checkbox state
+ */
+export declare const getCheckboxTextColor: (tokens: CheckboxTokensType, disabled: boolean, error: boolean) => string;
+/**
+ * Gets the subtext color based on checkbox state
+ */
+export declare const getCheckboxSubtextColor: (tokens: CheckboxTokensType, disabled: boolean, error: boolean) => string;
+/**
+ * Gets the text properties for checkbox labels
+ */
+export declare const getCheckboxTextProps: (tokens: CheckboxTokensType, size: CheckboxSize, disabled: boolean, error: boolean) => {
+    fontSize: string;
+    fontWeight: string;
+    color: string;
+};
+/**
+ * Gets the subtext properties for checkbox
+ */
+export declare const getCheckboxSubtextProps: (tokens: CheckboxTokensType, size: CheckboxSize, disabled: boolean, error: boolean) => {
+    fontSize: string;
+    color: string;
+};
+/**
+ * Gets label styles for checkbox components
+ */
+export declare const getCheckboxLabelStyles: (disabled: boolean) => {
+    cursor: "not-allowed" | "pointer";
+    display: "flex";
+    alignItems: "center";
+    margin: number;
+    padding: number;
+};
+/**
+ * Gets accessibility attributes for checkbox
+ */
+export declare const getAccessibilityAttributes: (uniqueId: string, isIndeterminate: boolean) => {
+    role: string;
+    'aria-checked': string | undefined;
+    'aria-labelledby': string;
+    'aria-describedby': string;
+};

package/dist/components/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Checkbox } from './Checkbox';
+export * from './types';

package/dist/components/Checkbox/types.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+export declare enum CheckboxSize {
+    SMALL = "sm",
+    MEDIUM = "md"
+}
+export type CheckboxCheckedState = 'checked' | 'unchecked' | 'indeterminate';
+export type CheckboxInteractionState = 'default' | 'hover' | 'disabled' | 'error';
+export type CheckboxProps = {
+    id?: string;
+    value?: string;
+    checked?: boolean | 'indeterminate';
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    disabled?: boolean;
+    required?: boolean;
+    error?: boolean;
+    size?: CheckboxSize;
+    children?: ReactNode;
+    subtext?: string;
+    slot?: ReactNode;
+};

package/dist/components/DataTable/ColumnFilter/index.d.ts

@@ -0,0 +1,9 @@
+import { FilterType, ColumnDefinition, ColumnFilter } from '../types';
+export type ColumnFilterProps<T extends Record<string, unknown>> = {
+    column: ColumnDefinition<T>;
+    data: T[];
+    currentFilter?: ColumnFilter;
+    onFilter: (field: keyof T, type: FilterType, value: string | string[], operator?: string) => void;
+};
+declare const ColumnFilter: import('react').ForwardRefExoticComponent<ColumnFilterProps<Record<string, unknown>> & import('react').RefAttributes<HTMLDivElement>>;
+export default ColumnFilter;

package/dist/components/DataTable/ColumnManager.d.ts

@@ -0,0 +1,5 @@
+import { ColumnManagerProps } from './types';
+export declare const ColumnManager: {
+    <T extends Record<string, unknown>>({ columns, visibleColumns, onColumnChange, }: ColumnManagerProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/DataTable/DataTable.d.ts

@@ -0,0 +1,3 @@
+import { DataTableProps } from './types';
+declare const DataTable: import('react').ForwardRefExoticComponent<DataTableProps<Record<string, unknown>> & import('react').RefAttributes<HTMLDivElement>>;
+export default DataTable;

package/dist/components/DataTable/DataTable.stories.d.ts

@@ -0,0 +1,16 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { default as DataTable } from './DataTable';
+declare const meta: Meta<typeof DataTable>;
+export default meta;
+type Story = StoryObj<typeof DataTable>;
+export declare const Default: Story;
+export declare const WithSearchAndFiltering: Story;
+export declare const WithAdvancedFiltering: Story;
+export declare const WithInlineEditing: Story;
+export declare const WithRowExpansion: Story;
+export declare const WithPagination: Story;
+export declare const WithCustomHeaderSlots: Story;
+export declare const ServerSideOperations: Story;
+export declare const LoadingState: Story;
+export declare const EmptyState: Story;
+export declare const WithRowStyling: Story;

package/dist/components/DataTable/DataTableHeader/index.d.ts

@@ -0,0 +1,3 @@
+import { DataTableHeaderProps } from './types';
+declare const DataTableHeader: import('react').ForwardRefExoticComponent<DataTableHeaderProps<Record<string, unknown>> & import('react').RefAttributes<HTMLDivElement>>;
+export default DataTableHeader;

package/dist/components/DataTable/DataTableHeader/types.d.ts

@@ -0,0 +1,20 @@
+import { ColumnDefinition, SearchConfig, AdvancedFilterProps } from '../types';
+export type DataTableHeaderProps<T extends Record<string, unknown>> = {
+    title?: string;
+    description?: string;
+    showToolbar?: boolean;
+    enableSearch?: boolean;
+    searchPlaceholder?: string;
+    searchConfig: SearchConfig;
+    enableAdvancedFilter?: boolean;
+    advancedFilterComponent?: React.ComponentType<AdvancedFilterProps>;
+    advancedFilters?: unknown[];
+    visibleColumns: ColumnDefinition<T>[];
+    data: T[];
+    onSearch: (query: string) => void;
+    onAdvancedFiltersChange?: (filters: unknown[]) => void;
+    onClearAllFilters: () => void;
+    headerSlot1?: React.ReactNode;
+    headerSlot2?: React.ReactNode;
+    headerSlot3?: React.ReactNode;
+};

package/dist/components/DataTable/DataTablePagination.d.ts

@@ -0,0 +1,11 @@
+type DataTablePaginationProps = {
+    currentPage: number;
+    pageSize: number;
+    totalRows: number;
+    pageSizeOptions: number[];
+    isLoading?: boolean;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+};
+export declare function DataTablePagination({ currentPage, pageSize, totalRows, pageSizeOptions, isLoading, onPageChange, onPageSizeChange, }: DataTablePaginationProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DataTable/TableBody/BulkActionBar.d.ts

@@ -0,0 +1,8 @@
+export type BulkActionBarProps = {
+    selectedCount: number;
+    onExport: () => void;
+    onDeselectAll: () => void;
+    customActions?: React.ReactNode;
+};
+declare const BulkActionBar: import('react').ForwardRefExoticComponent<BulkActionBarProps & import('react').RefAttributes<HTMLDivElement>>;
+export default BulkActionBar;

package/dist/components/DataTable/TableBody/index.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TableBodyProps } from './types';
+declare const TableBody: React.ForwardRefExoticComponent<TableBodyProps<Record<string, unknown>> & React.RefAttributes<HTMLTableSectionElement>>;
+export default TableBody;

package/dist/components/DataTable/TableBody/types.d.ts

@@ -0,0 +1,32 @@
+import { ColumnDefinition } from '../types';
+export type TableBodyProps<T extends Record<string, unknown>> = {
+    currentData: T[];
+    visibleColumns: ColumnDefinition<T>[];
+    idField: string;
+    selectedRows: Record<string, boolean>;
+    editingRows: Record<string, boolean>;
+    editValues: Record<string, T>;
+    expandedRows: Record<string, boolean>;
+    enableInlineEdit?: boolean;
+    enableColumnManager?: boolean;
+    enableRowExpansion?: boolean;
+    enableRowSelection?: boolean;
+    columnFreeze?: number;
+    renderExpandedRow?: (expandedData: {
+        row: T;
+        index: number;
+        isExpanded: boolean;
+        toggleExpansion: () => void;
+    }) => React.ReactNode;
+    isRowExpandable?: (row: T, index: number) => boolean;
+    onRowSelect: (rowId: unknown) => void;
+    onEditRow: (rowId: unknown) => void;
+    onSaveRow: (rowId: unknown) => void;
+    onCancelEdit: (rowId: unknown) => void;
+    onRowExpand: (rowId: unknown) => void;
+    onFieldChange: (rowId: unknown, field: keyof T, value: unknown) => void;
+    onRowClick?: (row: T, index: number) => void;
+    getColumnWidth: (column: ColumnDefinition<T>, index: number) => React.CSSProperties;
+    getRowStyle?: (row: T, index: number) => React.CSSProperties;
+    getDisplayValue?: (value: unknown, column: ColumnDefinition<T>) => unknown;
+};

package/dist/components/DataTable/TableCell/index.d.ts

@@ -0,0 +1,3 @@
+import { TableCellProps } from './types';
+declare const TableCell: import('react').ForwardRefExoticComponent<TableCellProps<Record<string, unknown>> & import('react').RefAttributes<HTMLTableCellElement>>;
+export default TableCell;