/** Context provider for DataTable state and logic.
 *
 * Children can call `useDataTable` to access everything provided by `@tanstack/react-table` plus
 * the functionality we've built on top.
 */
export declare const DataTable: (({ columns, data: dataProp, getAsyncData, defaultSort, initialState, disabledRows, enableRowSelection, onRowSelectionChange, children }: {
    columns: any;
    defaultSort?: import("./DataTable.types").TDefaultSort;
    children: React.ReactNode;
    initialState?: import("./DataTable.types").InitialState;
    disabledRows?: Record<string, boolean>;
    enableRowSelection?: boolean | ((row: import("@tanstack/table-core").Row<unknown>) => boolean);
    onRowSelectionChange?: import("@tanstack/table-core").OnChangeFn<import("@tanstack/table-core").RowSelectionState>;
} & ({
    data: import("./DataTable.types").TableData;
    getAsyncData?: never;
} | {
    data?: never;
    getAsyncData: import("./DataTable.types").TGetAsyncData;
})) => React.JSX.Element) & {
    /** Default table body implementation for `DataTable`.
     *
     * Can be configured with alternating colours of rows. If you need more customisation options,
     * you can build your own implementation with `useDataTable()` and the UI-only `Table` components.
     */
    Body: ({ striped, rowAction, ...props }: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "striped"> & {
        striped?: boolean | undefined;
    } & {
        as?: import("react").ElementType;
    }, "children"> & {
        rowAction?: (row: Record<string, unknown>, event: React.MouseEvent) => void;
    }) => import("react").JSX.Element;
    /** Default table data cell implementation for `DataTable`
     *
     *
     */
    DataCell: ({ cell }: {
        cell: import("@tanstack/table-core").Cell<Record<string, unknown>, unknown>;
    }) => import("react").JSX.Element;
    /**
     * Used in place of `DataTable.Table` to render a table with rows that the user can sort by drag-and-drop
     */
    DragAndDropTable: ({ idColumn, onDragAndDrop, sortable, striped, theme, className, ...props }: Omit<Omit<Omit<import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "size" | "corners"> & {
        size?: "md" | "lg" | "xl" | undefined;
        corners?: "round" | "square" | undefined;
    } & {
        as?: import("react").ElementType;
    } & {
        numberOfStickyColumns?: number;
        scrollContainerCls?: string | string[];
        scrollContainerkey?: string;
        maxRowDepth?: number;
    }, "ref"> & import("react").RefAttributes<HTMLTableElement>, "children" | "numberOfStickyColumns"> & Partial<Pick<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "theme" | "isSticky"> & {
        theme?: "primary" | "white" | "primaryDark" | "light" | "primaryLight" | undefined;
        isSticky?: boolean | undefined;
    } & {
        as?: import("react").ElementType;
    }, "children"> & {
        sortable?: boolean;
        isSticky?: boolean;
        stickyOffset?: number;
        showTotalInFirstColumn?: boolean;
        totalSuffix?: string;
    }, "theme" | "sortable">> & Partial<Pick<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "striped"> & {
        striped?: boolean | undefined;
    } & {
        as?: import("react").ElementType;
    }, "striped">> & {
        scrollOptions?: {
            hasStickyHeader?: boolean;
            stickyHeaderOffset?: number;
            headerCss?: string;
            numberOfStickyColumns?: number;
            scrollContainerCls?: string | string[];
            showTotalInFirstColumn?: boolean;
            totalSuffix?: string;
        };
        rowAction?: (row: Record<string, unknown>, event: React.MouseEvent) => void;
        withContainer?: boolean;
    } & {
        className?: string;
        idColumn?: string;
        onDragAndDrop?: (onDragAndDropData: {
            oldIndex: number;
            newIndex: number;
            newData: import("./DataTable.types").TAsyncDataResult;
        }) => void;
    }) => import("react").JSX.Element;
    /** Default global search implementation for `DataTable`
     *
     * If you need more customisation options, you can compose your own implementation with our UI-only input components and `useDataTable`.
     */
    GlobalFilter: ({ onChange, label, hideLabel, ...props }: Omit<import("../search-input/SearchInput").SearchInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement> & {
        label: string;
        hideLabel?: boolean;
    }) => import("react").JSX.Element | null;
    /** Default table head implementation
     *
     * Can be configured to be sortable and with different visual themes.
     * If you need more customisation options, you can build your own implementation
     * with `useDataTable` and the UI-only `Table` components.
     */
    Head: ({ sortable, theme, isSticky, stickyOffset, showTotalInFirstColumn, totalSuffix, style, className, ...props }: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "theme" | "isSticky"> & {
        theme?: "primary" | "white" | "primaryDark" | "light" | "primaryLight" | undefined;
        isSticky?: boolean | undefined;
    } & {
        as?: import("react").ElementType;
    }, "children"> & {
        sortable?: boolean;
        isSticky?: boolean;
        stickyOffset?: number;
        showTotalInFirstColumn?: boolean;
        totalSuffix?: string;
    }) => React.ReactElement<unknown>;
    /** Default header implementation for `DataTable`
     *
     * Can be configured to make the column sortable. If you need more customisation options,
     * you can build your own implementation with the UI-only `Table` components.
     */
    HeaderCell: ({ header, includeTotal, totalSuffix, children, className, ...props }: Omit<import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never> & {
        as?: import("react").ElementType;
    } & {
        header: import("@tanstack/table-core").Header<Record<string, unknown>, unknown>;
        includeTotal?: boolean;
        totalSuffix?: string;
    }) => import("react").JSX.Element;
    /** Default pagination implementation for `DataTable`
     *
     * Can navigate forward, backward, or to any specific page. If you need more customisation options,
     * you can build your own implementation with `useDataTable` and other UI components.
     *
     */
    MetaData: ({ copy, ...rest }: React.ComponentProps<typeof import("..").Text> & {
        copy?: {
            sorted_by?: string;
            ascending?: string;
            descending?: string;
            separator?: string;
        };
        sortLabel?: string;
    }) => import("react").JSX.Element;
    /** Default display of amount of items and current sorting status for 'DataTable'
     *
     */
    Pagination: {
        ({ colorScheme, ...props }: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, never> & {
            as?: import("react").ElementType;
        } & {
            colorScheme?: import("../..").TcolorScheme;
        }): import("react").JSX.Element | null;
        displayName: string;
    };
    /** Default row implementation for `DataTable`
     *
     * Renders all visible cells as `Table.Cell`. If you need more customisation options,
     * you can build your own implementation with the UI-only `Table` components.
     */
    Row: ({ row, rowAction }: import("./DataTableRow").DataTableRowProps) => import("react").JSX.Element;
    /** Default table implementation for `DataTable`.
     *
     * Can be configured with sortable columns and different visual themes.
     *
     * If you need more customisation options, you can compose your own implementation with
     * lower-level `DataTable` components or build the whole thing from
     * scratch with `useDataTable` and the UI-only `Table` components.
     *
     */
    Table: ({ sortable, striped, theme, className, scrollOptions, rowAction, withContainer, ...props }: import("./DataTableTable").DataTableTableProps) => React.JSX.Element | null;
    /** Default loading implementation for remote data
     *
     * Renders a loading component while fetching the paginated data using `getAsyncData`.
     *
     * If you need more customisation, you can compose your own implentation, `asyncDataState`
     * can be retrieved from `useDataTable`
     */
    Loading: (props: React.ComponentProps<import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
        message?: string;
        size?: "sm" | "md" | "lg";
    }, never> & {
        as?: import("react").ElementType;
    }>>) => import("react").JSX.Element | null;
    /** Default error implementation for remote data
     *
     * Renders an error component when `getAsyncData` promise rejects.
     * Children are rendered as a function, it exposes a `runAsyncData` function to the children component.
     * `runAsyncData()` can be used to retry fetching the paginated data with the current pageIndex, pageSize
     * and sorting parameters or your own custom paginated options.
     *
     * If you need more customisation, you can compose your own implentation, `asyncDataState` and `runAsyncData()`
     * can be retrieved from `useDataTable`
     *
     */
    Error: ({ children }: {
        children: (retry?: import("./DataTable.types").DataTableContextType["runAsyncData"]) => React.ReactElement<unknown>;
    }) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
    /** Empty state implementation for `DataTable`.
     *
     * Extends the EmptyState component
     */
    EmptyState: ({ children, ...rest }: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "size"> & {
        size?: ("sm" | "md" | "lg" | "xs" | "xl" | Partial<Record<"@initial" | "@sm" | "@md" | "@lg" | "@xl", "sm" | "md" | "lg" | "xs" | "xl">>) | undefined;
    } & {
        as?: import("react").ElementType;
    }) => import("react").JSX.Element | null;
    /** Select all rows checkbox.
     *
     * Renders a checkbox on the header, allowing for bulk selection/deselection of all selectable rows
     */
    SelectAllRowsCheckbox: ({ label }: {
        label?: string;
    }) => import("react").JSX.Element;
    /** Individual row selection checkbox.
     *
     * Renders a checkbox on each row, allowing for individual selection/deselection of any selectable row
     */
    RowSelectionCheckbox: ({ row, checked, onCheckedChange, label }: {
        row: import("@tanstack/table-core").Row<Record<string, unknown>>;
        checked: boolean | "indeterminate";
        onCheckedChange: (value: boolean) => void;
        label?: string;
    }) => React.ReactElement<unknown>;
    /** Bulk actions for selected rows.
     *
     * Renders a toolbar with actions that can be applied to all selected rows
     */
    BulkActions: (({ children, ...rest }: {
        children: React.ReactElement<React.ComponentProps<({ children }: {
            children: React.ReactElement<unknown>;
        }) => React.ReactElement<unknown> | null>> | React.ReactElement<React.ComponentProps<({ cancelLabel, children }: {
            cancelLabel?: string;
            children: React.ReactNode;
        }) => import("react").JSX.Element | null>> | [React.ReactElement<React.ComponentProps<({ children }: {
            children: React.ReactElement<unknown>;
        }) => React.ReactElement<unknown> | null>>, React.ReactElement<React.ComponentProps<({ cancelLabel, children }: {
            cancelLabel?: string;
            children: React.ReactNode;
        }) => import("react").JSX.Element | null>>];
    }) => import("react").JSX.Element) & {
        DefaultActions: ({ children }: {
            children: React.ReactElement<unknown>;
        }) => React.ReactElement<unknown> | null;
        SelectedRowActions: ({ cancelLabel, children }: {
            cancelLabel?: string;
            children: React.ReactNode;
        }) => import("react").JSX.Element | null;
    };
    /** Bulk actions for selected rows.
     *
     * Renders a toolbar with actions that can be applied to all selected rows
     */
    BulkActionsFloating: (({ children, ...rest }: React.PropsWithChildren<React.ComponentProps<import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & {
        as?: import("react").ElementType;
    }>>>) => import("react").JSX.Element | null) & {
        SelectedRowActions: ({ cancelLabel, showDividers, children }: {
            cancelLabel?: string;
            showDividers?: boolean;
            children: React.ReactNode;
        }) => import("react").JSX.Element | null;
    };
};