import * as React$1 from 'react';
import React__default, { RefObject, ForwardedRef, ReactNode } from 'react';
import * as _tanstack_react_table from '@tanstack/react-table';
import { Table, Cell, Row, RowData, FilterFn, TableOptions, ColumnDef, TableMeta, OnChangeFn, Updater, Column, Header as Header$1, TableState, RowSelectionState } from '@tanstack/react-table';
import { InputProps, TabsProps, ButtonProps, CheckboxProps as CheckboxProps$1, ImageProps, DividerProps, PopoverProps, DatePickerProps, InputNumberProps, SpinProps } from 'antd';
import { ProFormDigitProps, GetComponentProps as GetComponentProps$1, ProFieldValueEnumType, ProFormFieldProps } from '@ant-design/pro-components';
import { MenuItemType } from 'antd/es/menu/interface';
import * as antd_style from 'antd-style';
import { WaveConfig } from 'antd/es/config-provider/context';
import { TitleProps } from 'antd/es/typography/Title';
import { ParagraphProps } from 'antd/es/typography/Paragraph';
import { TextProps } from 'antd/es/typography/Text';
import { TooltipPropsWithOverlay } from 'antd/es/tooltip';
import { Dayjs } from 'dayjs';
import { IconProps } from '@iconify/react';

declare const ShadcnTable: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
declare const ShadcnTableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const ShadcnTableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const ShadcnTableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
declare const ShadcnTableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
declare const ShadcnTableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
declare const ShadcnTableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
declare const ShadcnTableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;

declare function Skeleton({ className, ...props }: React__default.HTMLAttributes<HTMLDivElement>): React__default.JSX.Element;

declare function useIsMobile(): boolean;

type BaseInputProps = InputProps & ProFormDigitProps;
type TableInputFieldTypes = "select" | "digit" | "text" | "amount" | "quantity" | "date";
interface TableInputProps extends BaseInputProps {
    type?: TableInputFieldTypes | string;
}
declare const TableInput: React__default.FC<TableInputProps>;

interface InternalTableProps<T> {
    table: Table<T>;
    loading?: boolean;
    tableLoadingRowCount?: string | number;
    bordered?: boolean;
    onRow?: GetComponentProps$1<T>;
}
declare const InternalTable: <T>({ table, loading, tableLoadingRowCount, bordered, onRow, }: InternalTableProps<T>) => React__default.JSX.Element;
interface TableBodyProps<T> extends InternalTableProps<T> {
    table: Table<T>;
    data?: any[];
    totalSize?: number;
}
declare const TableBody: <T>({ table, bordered, onRow, }: TableBodyProps<T>) => React__default.JSX.Element;
declare const VirtualTableBody: <T>({ data, table, bordered, totalSize, onRow, }: TableBodyProps<T>) => React__default.JSX.Element;
declare const MemoizedTableBody: typeof TableBody;
declare const MemoizedCell: React__default.FC<{
    cell: Cell<any, any>;
    token: any;
    table: CustomTable<any>;
    bordered: any;
}>;
declare const EditableRow: React__default.FC<{
    index: any;
    row: Row<any>;
    onRow: any;
    table: Table<any>;
    bordered: any;
    data?: any[];
    ref?: any;
    height?: number;
}>;

type FilterVariantOptions = "search" | "select" | "range" | "multi-select" | "date" | "date-range";
type GetComponentProps<DataType> = (data: DataType, index?: number) => React.HTMLAttributes<any> & React.TdHTMLAttributes<any>;
interface TableEditableCellProps extends Record<string, any> {
    valueType?: TableInputFieldTypes;
    inputItemProps?: BaseInputProps;
}
interface RequestResponse<T> {
    data: T[];
    total: number;
    success: boolean;
}
interface DataProps {
    rowIndex: number;
    columnId: string;
    value: unknown;
}
interface CustomTableMeta extends TableMeta<any> {
    reload: () => void;
    updateData: (rowIndex: number, columnId: string, value: any) => void;
    updateDensity?: (density: DensityState) => void;
    rowSelection?: {
        selectedRowKeys?: React.Key[];
        onChange: (selectedRowKeys: React.Key[], selectedRows: any[]) => void;
        selections?: MenuItemType[] | true;
    };
    rowExpandable?: {
        onExpand: (selectedRowKeys: React.Key[], selectedRows: any[]) => void;
    };
}
interface CustomTableOptions<T> extends TableOptions<T> {
    meta?: CustomTableMeta;
}
interface CustomTable<T> extends Omit<Table<T>, "options"> {
    options: CustomTableOptions<T>;
}
interface TanstackToolbarProps {
    options?: OptionConfig;
    actions?: any[];
    menu?: ListToolBarHeaderMenuProps;
    title?: React.ReactNode | string;
    subTitle?: React.ReactNode | string;
    table?: Table<unknown>;
    ref?: ForwardedRef<TableRef | undefined>;
}
interface Editable {
    onDataSourceChange: ({ record, recordList }: any) => void;
}
type OmittedProps = "data" | "columns" | "getFilteredRowModel" | "getSortedRowModel" | "getCoreRowModel" | "getGroupedRowModel" | "getExpandedRowModel" | "getFacetedRowModel" | "getFacetedUniqueValues" | "getFacetedMinMaxValues" | "getPaginationRowModel" | "filterFns";
type OmittedTableProps<T> = Omit<TableOptions<T>, OmittedProps>;
interface TableRef {
    reload: () => void;
    focus?: () => void;
    blur?: () => void;
}
interface OptionConfig {
    reload?: boolean;
    search?: boolean | {
        autoFocus?: boolean;
        placeholder?: string;
    };
    reloadIcon?: React.ReactNode;
}
type PaginationType = "virtual" | "pagination";
type OmittedInternalTableProps<T> = Omit<InternalTableProps<T>, "table">;
interface TanstackTableProps<T> extends OmittedInternalTableProps<T> {
    paginationType?: PaginationType;
    pagination?: PaginationState;
    displayName?: string;
    bordered?: boolean;
    ref?: RefObject<TableRef | null>;
    tableLoading?: boolean;
    request?: (params: Record<string, unknown>) => Promise<RequestResponse<T>>;
    dataSource?: T[];
    density?: DensityState;
    refreshDeps?: any[];
    toolbar?: TanstackToolbarProps;
    editable?: Editable;
    tableProps?: OmittedTableProps<T>;
    columns?: Array<ColumnDef<T, any>>;
    rowSelection?: {
        selectionType?: "checkbox" | "radio";
        selectedRowKeys?: React.Key[];
        onChange: (selectedRowKeys: React.Key[], selectedRows: T[]) => void;
        selections?: MenuItemType[] | true;
    };
    rowExpandable?: {
        onExpand: (selectedRowKeys: React.Key[], selectedRows: T[]) => void;
    };
    options?: OptionConfig;
    tableAlertOptionRender?: (selectedRowKeys: React.Key[], selectedRows: T[], onCleanSelected: () => void) => React.ReactNode;
}
interface PaginationState {
    pageIndex: number;
    pageSize: number;
}
type DensityState = "small" | "middle" | "large" | undefined;
interface DensityTableState {
    density: DensityState;
}
interface DensityOptions {
    enableDensity?: boolean;
    onDensityChange?: OnChangeFn<DensityState>;
}
interface DensityInstance {
    setDensity: (updater: Updater<DensityState>) => void;
    toggleDensity: (value?: DensityState) => void;
}
interface _CustomColumnMeta<T, J> {
    filterVariant?: FilterVariantOptions;
    editable?: boolean;
    valueType?: TableInputFieldTypes;
    inputItemProps?: (row: T) => BaseInputProps;
    valueEnum?: ProFieldValueEnumType | any;
    render?: (value: J, record: T, index: number) => React.ReactNode;
    hidden?: boolean;
}
interface CustomColumnMeta<T, J> extends Omit<_CustomColumnMeta<T, J>, "render"> {
}
declare module "@tanstack/react-table" {
    interface TableState extends DensityTableState {
    }
    interface ColumnMeta<TData extends RowData, TValue> extends CustomColumnMeta<TData, TValue> {
    }
    interface FilterFns {
        ISODateFilter: FilterFn<unknown>;
        BooleanFn: FilterFn<unknown>;
    }
}
interface ListToolBarMenuItem {
    key: React.Key;
    label: React.ReactNode;
    disabled?: boolean;
}
interface ListToolBarHeaderMenuProps {
    type?: "dropdown" | "tab";
    activeKey?: TabsProps["activeKey"];
    defaultActiveKey?: TabsProps["defaultActiveKey"];
    items?: TabsProps["items"];
    onChange?: (activeKey?: React.Key) => void;
    prefixCls?: string;
}

declare const NoobTanstackTable: <T>(props: TanstackTableProps<T> & {
    ref?: ForwardedRef<TableRef>;
}) => any;

declare const useTableStyles: () => antd_style.ReturnStyles<{
    body: {
        ".ant-form-item": {
            marginBottom: string;
        };
    };
    dropDown: {
        ".ant-dropdown-menu": {
            padding: number;
            borderRadius: string;
            "&:hover": {
                backgroundColor: "white !important";
            };
        };
        ".ant-dropdown-menu-item": {
            padding: string;
            "&:hover": {
                backgroundColor: "white !important";
            };
        };
    };
    tableHead: {
        backgroundColor: string;
        color: string;
        textAlign: "left";
        fontWeight: number;
        margin: number;
        maxWidth: string;
    };
}>;

declare const FilterDropDown: ({ column }: {
    column: Column<any>;
}) => React__default.JSX.Element;
interface ColumnDropDownProps<T> {
    column: Table<T>;
}
declare const ColumnDropDown: <T>(table: ColumnDropDownProps<T>) => React__default.JSX.Element;
declare const SortableHeader: React__default.FC<{
    header: Header$1<unknown, unknown>;
}>;
declare const EditableCell: React__default.FC<TableEditableCellProps>;
declare const SortableColumns: React__default.FC<{
    children: React__default.ReactNode;
    id: string | number;
}>;
interface CheckboxProps {
    indeterminate: boolean;
    className?: string;
    checked: boolean;
}
declare const IndeterminateCheckbox: React__default.FC<CheckboxProps>;
declare const TanstackTablePagination: <T>({ tableInstance, table, }: {
    table: Table<T>;
    tableInstance: TableState;
}) => React__default.JSX.Element;
declare const TanstackTableEmpty: () => React__default.JSX.Element;
declare const TanstackToolbar: any;
declare const TanstackTableRowSelection: React__default.FC<{
    table: Table<any>;
    render?: React__default.ReactNode;
}>;
interface TanstackGlobalFilterProps {
    table: Table<unknown>;
    options?: OptionConfig["search"];
}
declare const TanstackGlobalFilter: React__default.ForwardRefExoticComponent<TanstackGlobalFilterProps & React__default.RefAttributes<TableRef | undefined>>;

declare const useTanstackTable: <T>() => {
    rowSelectionState: RowSelectionState;
    setRowSelectionState: React__default.Dispatch<React__default.SetStateAction<RowSelectionState>>;
    columnHelper: _tanstack_react_table.ColumnHelper<T>;
    rowSelectionColumn: _tanstack_react_table.DisplayColumnDef<T, unknown>;
    getFilterColumn: (threeDot: (value: T) => any) => _tanstack_react_table.DisplayColumnDef<T, unknown>;
    expandableColumn: _tanstack_react_table.DisplayColumnDef<T, unknown>;
    selectedRowKeys: React__default.Key[];
    setSelectedRowKeys: React__default.Dispatch<React__default.SetStateAction<React__default.Key[]>>;
    indexColumn: _tanstack_react_table.DisplayColumnDef<T, unknown>;
};

declare const getHiddenColumns: (columns: any[]) => any;
declare const getRowIds: <T>(table: Table<T>) => string[];
declare const getSelectedRowModel: <T>(table: Table<T>) => T[];
declare const getCellSize: (type: DensityState) => "py-2" | "py-4" | "py-6";
declare const getBordered: (bordered: boolean) => "" | "border";
declare const handlePinColumn: (columnId: string, pinType: "left" | "right", table: Table<unknown>) => void;
declare const getExtraColumns: <T>({ rowSelection, rowExpandable, }: {
    rowSelection?: unknown;
    rowExpandable?: unknown;
}) => _tanstack_react_table.DisplayColumnDef<T, unknown>[];
declare const isIndeterminate: (selected: string[], allOptions: string[]) => boolean;
declare const isCheckAll: (selected: string[], allOptions: string[]) => boolean;
declare const getColumnAggregation: <T>(rows: T[], accessor: string) => {
    sum: number;
    avg: number;
    min: number;
    max: number;
    count: number;
};

declare const PAGINATION_PAGE_SIZE_OPTIONS: {
    value: string;
    label: string;
}[];

interface EButtonProps extends ButtonProps {
    ref?: RefObject<HTMLDivElement>;
}
declare const EButton: React__default.FC<EButtonProps>;
type EIconButtonVariant = "default" | "transparent" | "primary" | "success" | "error" | "warning" | "info" | "blue";
interface EIconButtonProps extends EButtonProps {
    eIconButtonVariant?: EIconButtonVariant;
}
declare const EIconButtonIcon: React__default.FC<EIconButtonProps>;
interface ENoobButtonProps extends EButtonProps {
    wantHoverEffect?: boolean;
    buttonVariant?: EIconButtonVariant;
}
declare const ENoobButton: React__default.FC<ENoobButtonProps>;
interface EButtonGroupOptions {
    value: string | number;
    label: string | React__default.ReactNode;
}
interface EButtonGroupProps extends Omit<ButtonProps, "onChange"> {
    options: EButtonGroupOptions[];
    onChange: (value: string | number) => void;
}
declare const EButtonGroup: React__default.FC<EButtonGroupProps>;
interface EButtonIconProps extends EButtonProps {
    icon?: string;
    title?: string;
}
declare const EIconButton: React__default.FC<EButtonIconProps>;
declare const EButtonTransparent: React__default.FC<EButtonProps>;
interface TableDeleteButtonProps extends ButtonProps {
    indicator?: number;
}
declare const TableDeleteButton: React__default.FC<TableDeleteButtonProps>;
declare const TableClearButton: React__default.FC<TableDeleteButtonProps>;
declare const EThirdPartyLogInButtonProps: React__default.FC<ButtonProps>;
declare const ShakeButtonWrapper: ({ showShakeEffect, showEffect, children, ...wave }: ShakeButtonProps) => React__default.JSX.Element;
interface ShakeButtonProps extends WaveConfig {
    buttonProps?: ButtonProps;
    children: React__default.ReactNode;
    showShakeEffect?: boolean;
}
declare const ShakeButton: ({ showShakeEffect, showEffect, children, buttonProps, ...wave }: ShakeButtonProps) => React__default.JSX.Element;

interface ECheckboxProps extends CheckboxProps$1 {
    label?: string | React__default.ReactNode;
    helperMessage?: string;
    error?: boolean;
    errorMessage?: string;
}
declare const ECheckbox: React__default.FC<ECheckboxProps>;

interface TitleTypographyProps extends TitleProps {
    children: ReactNode;
    color?: string;
    fontWeight?: "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
    textAlign?: "center" | "left" | "right";
}
declare const EHeading: React__default.FC<TitleTypographyProps>;

interface ParagraphTypographyProps extends ParagraphProps {
    children: ReactNode;
    color?: string;
    fontWeight?: "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
    textAlign?: "center" | "left" | "right";
}
declare const EParagraph: React__default.FC<ParagraphTypographyProps>;

interface TextTypographyProps extends TextProps {
    children: ReactNode;
    color?: string;
    fontWeight?: "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
    textAlign?: "center" | "left" | "right";
    fontSize?: string;
}
declare const EText: React__default.FC<TextTypographyProps>;
declare const ETextForSearchFilterDropDown: React__default.FC<TextTypographyProps>;
interface SearchFilterTypographyProps extends TextProps {
    children: React__default.ReactNode;
    color?: string;
    fontWeight?: "100" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
    textAlign?: "center" | "left" | "right";
    fontSize?: string;
    marginLeft?: string;
}
declare const ETextForSearchFilterLabel: React__default.FC<SearchFilterTypographyProps>;
interface VerticalTextStyles {
    heading?: React__default.CSSProperties;
    desc?: React__default.CSSProperties;
    divider?: React__default.CSSProperties;
}
declare const VerticalText: React__default.FC<{
    heading: string;
    align?: "center" | "left" | "right";
    desc?: string;
    divider?: boolean;
    colon?: boolean;
    vertical?: boolean;
    headingProps?: TextTypographyProps;
    styles?: VerticalTextStyles;
}>;
interface Styles {
    img: React__default.CSSProperties;
}
declare const TextWithIcon: React__default.FC<{
    img?: string | React__default.ReactNode;
    text: string | React__default.ReactNode;
    infoText?: string;
    ellipsisRows?: number;
    textMaxWidth?: number;
    styles?: Styles;
    imgProps?: ImageProps;
}>;
interface BaseHeaderProps {
    heading: string;
    subHeading: string;
    extra?: React__default.ReactNode;
}
declare const Header: React__default.FC<BaseHeaderProps>;

interface EDividerProps extends DividerProps {
    children?: React__default.ReactNode;
    marginTop?: number | string;
    marginBottom?: number | string;
    marginLeft?: number | string;
    marginRight?: number | string;
}
declare const EDivider: React__default.FC<EDividerProps>;
declare const EFullDivider: React__default.FC<EDividerProps>;
declare const EDividerWithNoStyle: React__default.FC<EDividerProps>;
interface DividerWithTextStyle {
    dividerStyles?: React__default.CSSProperties;
    textStyles?: React__default.CSSProperties;
}
interface DividerWithTextProps {
    dividerProps?: EDividerProps;
    ghost?: boolean;
    textProps?: TextProps;
    children?: any;
    styles?: DividerWithTextStyle;
}
declare const EDividerWithText: React__default.FC<DividerWithTextProps>;

interface ETooltipProps extends TooltipPropsWithOverlay {
}
declare const ETooltip: React__default.FC<ETooltipProps>;

interface EPopoverProps extends PopoverProps {
}
declare const EPopover: React__default.FC<EPopoverProps>;

interface ETabProps extends TabsProps {
}
declare const ETab: React__default.FC<ETabProps>;

interface EDatePickerProps extends DatePickerProps<Dayjs> {
}
declare const EDatePicker: React__default.FC<EDatePickerProps>;

interface EIconProps extends IconProps {
}
declare const EIcon: React__default.FC<EIconProps>;
interface EPrimaryIconProps extends IconProps {
    child?: boolean;
    isActive?: boolean;
}
declare const EPrimaryIcon: React__default.FC<EPrimaryIconProps>;

interface NoDataProps {
    width?: string;
    height?: string;
    style?: React__default.CSSProperties;
}
declare const NoData: React__default.FC<NoDataProps>;

declare const EAmount: React__default.FC<ProFormDigitProps>;
declare const EEmail: React__default.FC<ProFormFieldProps>;
declare const EPan: React__default.FC<ProFormFieldProps>;
declare const EGstNo: React__default.FC<ProFormFieldProps>;
declare const EPinCode: React__default.FC<ProFormFieldProps>;
interface EProLongitudeLatitudeProps extends ProFormDigitProps {
    type?: "latitude" | "longitude";
}
declare const ELatitude: React__default.FC<EProLongitudeLatitudeProps>;

declare const ProDigitNumber: React__default.FC<ProFormDigitProps>;
interface ProDigitNumberProps extends ProFormFieldProps<any, InputNumberProps> {
}
interface ProDigitNumberProps extends ProFormFieldProps<any, InputNumberProps> {
}
declare const ProWeightNumber: React__default.FC<ProDigitNumberProps>;
declare const ProAmount: React__default.FC<ProFormDigitProps>;
interface ProAmountFieldProps {
    amount?: number | string;
    iconColor?: string;
    textProps?: TextTypographyProps;
    popoverProps?: PopoverProps;
    info?: React__default.ReactNode;
    infoTitle?: string;
    suffix?: React__default.ReactNode | string;
}
declare const ProAmountField: React__default.FC<ProAmountFieldProps>;
interface ProDatePickerProps extends ProFormFieldProps<any, DatePickerProps> {
    name?: string | number;
}
declare const ProDatePicker: React__default.FC<ProDatePickerProps>;

interface ELoaderProps extends SpinProps {
    width?: string;
    height?: string;
}
declare const ELoader: React__default.FC<ELoaderProps>;
declare const MainLoader: () => React__default.JSX.Element;
declare const PageLoader: () => React__default.JSX.Element;

export { type BaseHeaderProps, type BaseInputProps, ColumnDropDown, type CustomColumnMeta, type CustomTable, type CustomTableMeta, type CustomTableOptions, type DataProps, type DensityInstance, type DensityOptions, type DensityState, type DensityTableState, EAmount, EButton, EButtonGroup, type EButtonGroupOptions, type EButtonGroupProps, type EButtonIconProps, type EButtonProps, EButtonTransparent, ECheckbox, type ECheckboxProps, EDatePicker, type EDatePickerProps, EDivider, type EDividerProps, EDividerWithNoStyle, EDividerWithText, EEmail, EFullDivider, EGstNo, EHeading, EIcon, EIconButton, EIconButtonIcon, type EIconButtonVariant, type EIconProps, ELatitude, ELoader, type ELoaderProps, ENoobButton, EPan, EParagraph, EPinCode, EPopover, type EPopoverProps, EPrimaryIcon, type EPrimaryIconProps, ETab, type ETabProps, EText, ETextForSearchFilterDropDown, ETextForSearchFilterLabel, EThirdPartyLogInButtonProps, ETooltip, type ETooltipProps, type Editable, EditableCell, EditableRow, FilterDropDown, type GetComponentProps, Header, IndeterminateCheckbox, InternalTable, type InternalTableProps, type ListToolBarHeaderMenuProps, type ListToolBarMenuItem, MainLoader, MemoizedCell, MemoizedTableBody, NoData, type NoDataProps, NoobTanstackTable, type OmittedInternalTableProps, type OmittedTableProps, type OptionConfig, PAGINATION_PAGE_SIZE_OPTIONS, PageLoader, type PaginationState, ProAmount, ProAmountField, ProDatePicker, ProDigitNumber, ProWeightNumber, type RequestResponse, ShadcnTable, ShadcnTableBody, ShadcnTableCaption, ShadcnTableCell, ShadcnTableFooter, ShadcnTableHead, ShadcnTableHeader, ShadcnTableRow, ShakeButton, ShakeButtonWrapper, Skeleton, SortableColumns, SortableHeader, TableBody, TableClearButton, TableDeleteButton, type TableEditableCellProps, TableInput, type TableInputFieldTypes, type TableInputProps, type TableRef, TanstackGlobalFilter, TanstackTableEmpty, TanstackTablePagination, type TanstackTableProps, TanstackTableRowSelection, TanstackToolbar, type TanstackToolbarProps, type TextTypographyProps, TextWithIcon, VerticalText, VirtualTableBody, type _CustomColumnMeta, getBordered, getCellSize, getColumnAggregation, getExtraColumns, getHiddenColumns, getRowIds, getSelectedRowModel, handlePinColumn, isCheckAll, isIndeterminate, useIsMobile, useTableStyles, useTanstackTable };