import * as _ag_grid_community_core from '@ag-grid-community/core';
import { ICellRendererParams, NumberFilterModel as NumberFilterModel$1, ColDef, IRowNode, ICellEditorParams, RowDataTransaction, RowNodeTransaction, ServerSideTransaction, GridApi, ICellEditor, RefreshCellsParams, RowNode as RowNode$1, Column, ColumnPinnedType, RowHeightParams, CheckboxSelectionCallbackParams, ExcelDataType, Module, RowSelectedEvent, ColumnEverythingChangedEvent, GetRowIdParams, ColumnApi, IFilter, IScalarFilterParams, ISimpleFilterParams } from '@ag-grid-community/core';
import * as React$1 from 'react';
import React__default from 'react';
import { AgGridReactProps, AgReactUiProps } from '@ag-grid-community/react';
import { DropdownFlyoutOption, FormSelectProps, FormMultiSelectProps, FormCurrencyProps, TypographyProps, InputProps, DateTimeFormatTypes, PillColor, TextAreaProps, ComponentWithFieldProp, FormFieldValueComponentProps } from '@procore/core-react';
import { IAnalytics } from '@procore/core-react/dist/_utils/genericAnalyticsClient';
import { FormatConfig } from '@procore/labs-financials-utils/dist/configs';

interface GrandTotalsLabelRendererProps extends ICellRendererParams {
}
declare const GrandTotalsLabelRenderer: React__default.FunctionComponent<GrandTotalsLabelRendererProps>;

declare const columnSort: {
    readonly asc: "asc";
    readonly desc: "desc";
};
type ColumnSort = (typeof columnSort)[keyof typeof columnSort];
declare const pinColumnSide: {
    readonly left: "left";
    readonly right: "right";
};
type PinColumnSide = (typeof pinColumnSide)[keyof typeof pinColumnSide];
declare const rowSize: {
    readonly sm: 33;
    readonly md: 49;
    readonly lg: 65;
};
type RowSize = (typeof rowSize)[keyof typeof rowSize];

type AcceptedTypes = NumberFilterModel$1['type'] | 'any_value' | 'no_value';
type NumberFilterModel = Omit<NumberFilterModel$1, 'type'> & {
    type?: AcceptedTypes;
};
type NumberFilterValue = {
    type?: AcceptedTypes;
    filter?: number;
    filterTo?: number;
} | undefined;
type NumberFilterProps = FilterComponentProps<unknown, NumberFilterValue>;
declare const NumberFilterRenderer: React__default.NamedExoticComponent<NumberFilterProps>;

interface MenuDropdownOption extends Omit<DropdownFlyoutOption, 'children'> {
    action?: (params: ColDef | null) => void;
    children?: MenuDropdownOption[];
    menuType?: 'defaultMenuOptions' | 'menuOptions';
}

interface BulkEditResult {
    /** The id of the selected row node. The value is the output from the getRowId callback */
    id: number | string | undefined;
    /** The row index of the selected row node */
    rowIndex: IRowNode['rowIndex'];
    /** The row data from before the bulk edit for the entire row */
    oldRowData: {
        [key: string]: any;
    };
    /** Row Data containing only the changed key/value pairs from the bulk edit */
    changedRowData: {
        [key: string]: any;
    };
    /** The entire updated row data including changes from the bulk edit */
    newRowData: {
        [key: string]: any;
    };
}
/**  For server side implementation, we may want to extend options to be an array,
 *   or a promise returning an array like server side filters */
interface SelectBulkEditorParams extends Omit<FormSelectProps, 'name'> {
}
interface MultiSelectBulkEditorParams extends Omit<FormMultiSelectProps, 'name'> {
}
interface CurrencyBulkEditorParams extends FormCurrencyProps {
}

interface ClientSideFilterProps<TValue = any[] | NumberFilterModel> {
    filter: FilterRecord<TValue>;
    columnDefinition: ColumnDefinition;
    onChange?: (values: any[]) => void;
    onRemove?: () => void;
}
interface ServerSideFilterProps {
    columnDefinition: ColumnDefinition;
}
type FilterProps<TValue = any[] | NumberFilterModel> = ClientSideFilterProps<TValue> | ServerSideFilterProps;

interface ExportPageFormat {
    pageWidthInInches: number;
    pageHeightInInches?: number;
    marginInPixels?: {
        top: number;
        left: number;
        bottom: number;
        right: number;
    };
}

declare const rowSelectionState: {
    readonly indeterminate: "indeterminate";
    readonly selected: "selected";
    readonly unselected: "unselected";
};
type RowSelectionState = (typeof rowSelectionState)[keyof typeof rowSelectionState];
interface AffectedRows {
    [id: string]: {
        node: IRowNode;
        selectedState: RowSelectionState;
    };
}

interface DataTableCellRendererProps<TValue = any, TColumnDefinition extends ColumnDefinition = ColumnDefinition<TValue>> {
    columnDefinition: TColumnDefinition;
    /**
     * Array of data for the row, keyed by field
     */
    data: any;
    /**
     * Field name for the cell being rendered
     */
    field: string;
    /**
     * Boolean for if the cell is a group cell
     */
    isGroup: boolean;
    /**
     * If rendering in a nested table, this is the data for the parent row
     */
    parentData: any | undefined;
    /**
     * If rendering in a nested table, this is the id of the parent row
     */
    parentId: string | undefined;
    /**
     * The height of the row in pixels
     */
    rowHeight: RowSize;
    /**
     * Will be "top" or "bottom" if the row is pinned, otherwise undefined
     */
    rowPinned: string | undefined;
    /**
     * The api for working with and modifying the table data
     */
    tableApi: TableApi;
    /**
     * The individual cell's value
     */
    value: TValue;
    /**
     * Row index of current row
     */
    rowIndex?: number;
}
interface DataTableCellEditorProps<TValue = any, TColumnDefinition extends ColumnDefinition = ColumnDefinition<TValue>> extends DataTableCellRendererProps<TValue, TColumnDefinition> {
    ref?: ((instance: HTMLElement | null) => void) | React__default.MutableRefObject<HTMLElement | null> | null;
    setDataValue: (field: string, newValue: TValue) => void;
    stopEditing: () => void;
}

interface BooleanCellRendererParams {
    typographyProps?: TypographyProps;
}
type BooleanCellColumnDefinition<TValue = boolean> = ColumnDefinition<TValue, typeof BooleanCellRenderer, BooleanCellRendererParams>;
interface BooleanCellRendererProps<TValue = boolean> extends DataTableCellRendererProps<TValue, BooleanCellColumnDefinition<TValue>> {
}
declare const BooleanCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface BooleanCellEditorProps<TValue = boolean> extends DataTableCellEditorProps<TValue, BooleanCellColumnDefinition<TValue>> {
}
declare const BooleanCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

interface ButtonsCellRendererParams {
    buttons: React__default.FunctionComponent<DataTableCellRendererProps>[];
}
type ButtonsCellColumnDefinition<TValue = undefined> = GranularRequired<ColumnDefinition<TValue, typeof ButtonsCellRenderer, ButtonsCellRendererParams>, 'cellRendererParams'>;
declare const ButtonsCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface CompanyCellRendererParams<TValue> {
    typographyProps?: TypographyProps;
    getCompanyName?: (companyInfo: TValue) => string;
    getImageURL?: (companyInfo: TValue) => string;
}
type CompanyCellColumnDefinition<TValue = any, TFilterOption = any, TFilterValue = number | string> = ColumnDefinition<TValue, typeof CompanyCellRenderer, CompanyCellRendererParams<TValue>, never, // editor does not exist
never, // editor does not exist
TFilterOption, TFilterValue>;
interface CompanyCellRendererProps<TValue = any> extends DataTableCellRendererProps<TValue, CompanyCellColumnDefinition> {
}
declare const CompanyCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface CurrencyCellRendererParams {
    typographyProps?: TypographyProps;
    formatConfig?: Partial<FormatConfig>;
}
type CurrencyCellColumnDefinition<TValue = any> = ColumnDefinition<TValue, typeof CurrencyCellRenderer, CurrencyCellRendererParams, typeof CurrencyCellEditor, CurrencyCellEditorParams, '', '', 'currency', CurrencyBulkEditorParams> & {
    rightAlign: true;
};
interface CurrencyCellRendererProps<TValue = string> extends DataTableCellRendererProps<TValue, CurrencyCellColumnDefinition<TValue>> {
}
declare const CurrencyCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface CurrencyCellEditorParams {
    inputProps?: InputProps;
    formatConfig?: Partial<FormatConfig>;
}
interface CurrencyCellEditorProps<TValue = string> extends DataTableCellEditorProps<TValue, CurrencyCellColumnDefinition<TValue>> {
}
declare const CurrencyCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

type PickedDateTimeFormatTypes = Extract<DateTimeFormatTypes, 'abbr-weekday-abbr-date' | 'date' | 'numeric-date' | 'weekday-date'>;
interface DateCellRendererParams {
    dateFormatType?: PickedDateTimeFormatTypes;
    typographyProps?: TypographyProps;
    timeZone?: string;
}
interface DateCellColumnDefinition<TValue = string | Date | undefined> extends DateTimeCellColumnDefinition<TValue, typeof DateCellRenderer, DateCellRendererParams, typeof DateCellEditor, DateCellEditorParams> {
}
interface DateCellRendererProps<TValue = string | Date | undefined> extends DataTableCellRendererProps<TValue, DateCellColumnDefinition<TValue>> {
}
declare const DateCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface DateCellEditorParams {
    disabledDate?: ((date: Date, today: Date) => boolean) | undefined;
    timeZone?: string;
}
interface DateCellEditorProps<TValue = string | Date | undefined> extends DataTableCellEditorProps<TValue, DateCellColumnDefinition<TValue>> {
}
declare const DateCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

type GroupCellRendererParams<TInnerRendererParams> = {
    /**
     * turn off the row count
     */
    suppressCount?: boolean;
    /**
     * enable checkbox selection
     */
    checkbox?: boolean;
    /**
     * set to true to node including any padding (indentation) in the child rows
     */
    suppressPadding?: boolean;
    /**
     * turn off double click for expand
     */
    suppressDoubleClickExpand?: boolean;
    /**
     * suppress expand on Enter key
     */
    suppressEnterExpand?: boolean;
    /**
     * the renderer to use inside the cell (after grouping functions are added)
     */
    innerRenderer?: string;
    /**
     * provide a footer value getter
     */
    footerValueGetter?: string | ((value: any) => string);
} & TInnerRendererParams;
type GroupCellColumnDefinition<TValue = any, TInnerRendererParams = object> = ColumnDefinition<TValue, typeof GroupCellRenderer, GroupCellRendererParams<TInnerRendererParams>>;
declare const GroupCellRenderer: React$1.FC<any>;

interface LinkCellRendererParams<TValue> {
    typographyProps?: TypographyProps;
    getURL: (value: TValue, data: any) => string;
}
type LinkCellColumnDefinition<TValue = any> = GranularRequired<ColumnDefinition<TValue, typeof LinkCellRenderer, LinkCellRendererParams<TValue>>, 'cellRendererParams'>;
interface LinkCellRendererProps<TValue = any> extends DataTableCellRendererProps<TValue, LinkCellColumnDefinition> {
}
declare const LinkCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface MultiSelectCellRendererParams<TValue, OptionValue> {
    getId?: (cellValue: OptionValue) => string | number;
    getLabel?: (cellValue: OptionValue) => string;
    getValue?: (cellValue: TValue) => OptionValue[];
    typographyProps?: TypographyProps;
}
type MultiSelectCellColumnDefinition<TValue = any[], OptionValue = any, TFilterOption = any, TFilterValue = number | string> = ColumnDefinition<TValue, typeof MultiSelectCellRenderer, MultiSelectCellRendererParams<TValue, OptionValue>, never, // editor does not exist
never, // editor does not exist
TFilterOption, TFilterValue, 'multiSelect', MultiSelectBulkEditorParams>;
interface MultiSelectCellRendererProps<TValue = any[], OptionValue = any> extends DataTableCellRendererProps<TValue, MultiSelectCellColumnDefinition<TValue, OptionValue>> {
}
declare const MultiSelectCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface NumberCellRendererParams {
    typographyProps?: TypographyProps;
    formatConfig?: Partial<FormatConfig>;
}
type NumberCellColumnDefinition<TValue = number> = ColumnDefinition<TValue, typeof NumberCellRenderer, NumberCellRendererParams, typeof NumberCellEditor, NumberCellEditorParams>;
interface NumberCellRendererProps<TValue = number | string> extends DataTableCellRendererProps<TValue, NumberCellColumnDefinition<TValue>> {
}
declare const NumberCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface NumberCellEditorParams {
    inputProps?: InputProps;
}
interface NumberCellEditorProps<TValue = number> extends DataTableCellEditorProps<TValue, NumberCellColumnDefinition<TValue>> {
}
declare const NumberCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

interface PeopleCellRendererParams<TValue, PersonValue> extends AvatarStackItemFilter {
    getCompanyName?: (person: PersonValue) => string;
    getImageURL?: (person: PersonValue) => string;
    getInitials?: (person: PersonValue) => string;
    getPersonName?: (person: PersonValue) => string;
    getValue?: (cellValue: TValue) => PersonValue[];
    typographyProps?: TypographyProps;
}
type PeopleCellColumnDefinition<TValue = any[], PersonValue = any, TFilterOption = any, TFilterValue = number | string> = ColumnDefinition<TValue, typeof PeopleCellRenderer, PeopleCellRendererParams<TValue, PersonValue>, never, // editor does not exist
never, // editor does not exist
TFilterOption, TFilterValue>;
interface PeopleCellRendererProps<TValue = any[], PersonValue = any> extends DataTableCellRendererProps<TValue, PeopleCellColumnDefinition<TValue, PersonValue>> {
}
declare const PeopleCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface PercentCellRendererParams {
    typographyProps?: TypographyProps;
    formatConfig?: Partial<FormatConfig>;
}
interface PercentCellEditorParams {
    inputProps?: InputProps;
    formatConfig?: Partial<FormatConfig>;
}
type PercentCellColumnDefinition<TValue = any> = ColumnDefinition<TValue, typeof PercentCellRenderer, PercentCellRendererParams, typeof PercentCellEditor, PercentCellEditorParams> & {
    rightAlign: true;
};
interface PercentCellRendererProps<TValue = string> extends DataTableCellRendererProps<TValue, PercentCellColumnDefinition<TValue>> {
}
declare const PercentCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface PercentCellEditorProps<TValue = string> extends DataTableCellEditorProps<TValue, PercentCellColumnDefinition<TValue>> {
}
declare const PercentCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

interface PillCellRendererParams<TValue> {
    getColor: (item: TValue) => PillColor;
    typographyProps?: TypographyProps;
}
type PillCellColumnDefinition<TValue = any, TFilterOption = any, TFilterValue = number | string> = GranularRequired<ColumnDefinition<TValue, typeof PillCellRenderer, PillCellRendererParams<TValue>, typeof PillSelectCellEditor, PillCellEditorParams<TValue>, TFilterOption, TFilterValue>, 'cellRendererParams'>;
interface PillCellRendererProps<TValue = any> extends DataTableCellRendererProps<TValue, PillCellColumnDefinition<TValue>> {
}
declare const PillCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface PillCellEditorParams<TValue> {
    clearable?: boolean;
    getId?: (item: TValue) => number | string;
    getColor?: (item: TValue) => PillColor;
    placeholder?: string;
    selectOptions: TValue[] | ((rowData: Record<string, any>) => TValue[]) | ((rowData: Record<string, any>) => Promise<TValue[]>);
}
interface PillSelectCellEditorProps<TValue = any> extends DataTableCellEditorProps<TValue, PillCellColumnDefinition<TValue>> {
}
declare const PillSelectCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

type SelectCellColumnDefinition<TValue = any, TFilterOption = any, TFilterValue = number | string> = GranularRequired<ColumnDefinition<TValue, typeof SelectCellRenderer, {
    typographyProps?: TypographyProps;
}, typeof SelectCellEditor, SelectCellEditorParams<TValue>, TFilterOption, TFilterValue, 'select', SelectBulkEditorParams>, 'cellEditor' | 'cellEditorParams'>;
interface SelectCellRendererProps<TValue = any> extends DataTableCellRendererProps<TValue, SelectCellColumnDefinition<TValue>> {
}
declare const SelectCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
type OnSearchParams = {
    data: SelectCellEditorProps['data'];
    event: React__default.ChangeEvent<HTMLInputElement>;
};
interface SelectCellEditorParams<TValue> {
    clearable?: boolean;
    getId?: (item: TValue) => number | string;
    getOptionLabel?: (option: any) => string;
    placeholder?: string;
    selectOptions: TValue[] | ((rowData: Record<string, any>) => TValue[]) | ((rowData: Record<string, any>) => Promise<TValue[]>);
    onSearch?: (params: OnSearchParams) => TValue[] | Promise<TValue[]>;
}
interface SelectCellEditorProps<TValue = any> extends DataTableCellEditorProps<TValue, SelectCellColumnDefinition<TValue>> {
}
declare const SelectCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

interface TextAreaCellRendererParams {
    typographyProps?: TypographyProps;
}
interface TextAreaCellEditorParams {
    textAreaProps?: TextAreaProps;
}
type TextAreaCellColumnDefinition<TValue = string, TFilterOption = any, TFilterValue = number | string> = ColumnDefinition<TValue, typeof TextAreaCellRenderer, TextAreaCellRendererParams, typeof TextAreaCellEditor, TextAreaCellEditorParams, TFilterOption, TFilterValue>;
interface TextAreaCellRendererProps<TValue = string> extends DataTableCellRendererProps<TValue, TextAreaCellColumnDefinition<TValue>> {
    node?: RowNode;
}
interface TextAreaCellEditorProps<TValue = string> extends DataTableCellEditorProps<TValue, TextAreaCellColumnDefinition<TValue>> {
}
declare const TextAreaCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;
declare const TextAreaCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface TextCellRendererParams {
    typographyProps?: TypographyProps;
}
interface TextCellEditorParams {
    inputProps?: InputProps;
}
type TextCellColumnDefinition<TValue = string, TFilterOption = any, TFilterValue = number | string> = ColumnDefinition<TValue, typeof TextCellRenderer, TextCellRendererParams, typeof TextCellEditor, TextCellEditorParams, TFilterOption, TFilterValue>;
interface TextCellRendererProps<TValue = string> extends DataTableCellRendererProps<TValue, TextCellColumnDefinition<TValue>> {
    node?: RowNode;
}
declare const TextCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
interface TextCellEditorProps<TValue = string> extends DataTableCellEditorProps<TValue, TextCellColumnDefinition<TValue>> {
}
declare const TextCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

type GranularRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
type GranularPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
/** Column Definitions */
interface ColumnDefinition<TValue = any, TRenderer = React.FC<ICellRendererParams<any, TValue>>, TRendererParams = any, TEditor = React.ForwardRefExoticComponent<ICellEditorParams<any, TValue>>, TEditorParams = any, TFilterOption = TValue, TFilterValue = number | string | LocationFilterOpt | {
    date: Date;
} | NumberFilterValue, TBulkEditor = string, TBulkEditorParams = any> {
    aggFunc?: string | AggregationFunction<TValue>;
    bulkEditable?: ((params: IsEditableParams) => boolean) | boolean;
    bulkEditEditor?: TBulkEditor;
    bulkEditEditorParams?: TBulkEditorParams;
    children?: ColumnDefinition[] | ExtendedColDef[];
    groupId?: string;
    cellEditor?: TEditor;
    cellEditorParams?: TEditorParams;
    cellCSVFormatter?: (value: TValue) => string;
    cellExcelFormatter?: (value: TValue) => string;
    cellExcelDataType?: string;
    cellRenderer?: TRenderer;
    cellRendererParams?: TRendererParams;
    cellRendererSelector?: (params?: ICellRendererParams) => {
        component: TRenderer;
        params: TRendererParams;
    };
    columnGroupName?: string;
    comparator?: (a: any, b: any) => number;
    editable?: ((params: IsEditableParams) => boolean) | boolean;
    enableRowGroup?: boolean;
    field: string;
    filterRenderer?: React.FunctionComponent<FilterComponentProps>;
    filterProps?: Omit<IFilterProps<TFilterOption, TFilterValue> | IDateFilterProps<TFilterOption, TFilterValue> | ILocationFilterProps<TFilterOption, TFilterValue> | INumberFilterProps<{
        id: NumberFilterModel['type'];
        label: string;
    }, TFilterValue>, 'columnDefinition'>;
    quickFilterRenderer?: React.FunctionComponent<ClientSideFilterProps | ServerSideFilterProps>;
    flex?: number;
    getStringFormattedValue?: (value: TValue) => string;
    getFilterKeyCreator?: ColDef['keyCreator'];
    headerName?: string;
    columnHeaderParams?: {
        menuOptions?: MenuDropdownOption[];
        headerNode?: (props: {
            columnDefinition: ColumnDefinition;
        }) => React.ReactNode;
    };
    hidden?: boolean;
    /** @deprecated please use pinned instead */
    initialIsPinned?: PinColumnSide;
    initialSort?: ColumnSort;
    lockPinned?: boolean;
    lockVisible?: boolean;
    marryChildren?: boolean;
    maxWidth?: number;
    minWidth?: number;
    onCellValueChanged?: (params: CellValueChangeParams<TValue>) => void;
    pinned?: PinColumnSide;
    resizable?: boolean;
    rightAlign?: boolean;
    rowGroup?: boolean;
    sortable?: boolean;
    suppressMenu?: boolean;
    suppressMovable?: boolean;
    suppressSizeToFit?: boolean;
    valueGetter?: (params: ValueGetterParams) => TValue;
    valueParser?: (params: ValueParserParams) => TValue;
    valueSetter?: (params: ValueSetterParams) => boolean;
    valueValidator?: ValueValidator<TValue>;
    width?: number;
    autoHeight?: boolean;
    wrapText?: boolean;
    lockPosition?: ColDef['lockPosition'];
}
interface ExtendedColDef extends ColDef {
    bulkEditable?: ((params: IsEditableParams) => boolean) | boolean;
    valueValidator?: ValueValidator;
    bulkEditEditor?: 'number' | 'text';
    cellCSVFormatter?: (v: any) => any;
    cellExcelFormatter?: (v: any) => any;
    colGroupName?: string;
    children?: ExtendedColDef[];
    groupId?: string;
}
interface NestedColumnDefinition {
    children: ColumnDefinition[];
    groupId: string;
    headerName: string;
    columnGroupShow?: 'open' | 'closed';
    marryChildren?: boolean;
}
/** Controls the type of filtering: single, range,
 * or up to user choice (either) */
type DateFilterSelectionType = 'single' | 'range' | 'either';
interface DateTimeCellColumnDefinition<TValue = any, TRenderer = string, TRendererParams = any, TEditor = string, TEditorParams = any> extends ColumnDefinition<TValue, TRenderer, TRendererParams, TEditor, TEditorParams, {
    date: Date;
}, string> {
    filterProps?: Omit<IDateFilterProps<{
        date: Date;
    }, string>, 'columnDefinition'>;
    /** See this this list of timezones: https://github.com/eggert/tz/blob/main/zone1970.tab */
    timeZone?: string;
}
interface LocationFilterOpt {
    id: number | string;
    label: string;
}
interface LocationColumnDefinition extends Omit<ColumnDefinition, 'filterProps'> {
    filterProps?: ILocationFilterProps<LocationFilterOpt, string>;
}

/** End Column Definitions */
interface TableApi {
    applyListFilter: (field: string, values: any[]) => Promise<void>;
    applyNumberFilter: (field: string, values: Omit<NumberFilterModel, 'filterType'>) => Promise<void>;
    applyTransaction: (rowDataTransaction: RowDataTransaction) => RowNodeTransaction | null | undefined;
    applyServerSideTransaction: (transaction: ServerSideTransaction) => ReturnType<GridApi['applyServerSideTransaction']>;
    collapseAll: () => void;
    exportToCSV: (config: CSVExportConfig) => void;
    expandAll: () => void;
    exportToExcel: (config: ExcelExportConfig) => void;
    exportToHTMLString: (config?: HTMLStringExportConfig) => Promise<string>;
    /**
     * Returns an array of column definitions (of type ColumnDefinition from DataTable) transformed
     * from ag-grid's current array of col defs (of type ColDef from ag-grid)
     */
    getColumnDefinitions: () => ColumnDefinition[];
    getDetailGridTableApi: (rowId: string) => PartialTableApi | undefined;
    getRootAggregateData: () => any;
    /**
     * For now, used for testing to detect open editors. If programmatic editing
     * is something we want to enable, we can consider making this public
     * @private
     */
    getCellEditorInstances: () => ICellEditor[];
    /**
     * Get the sorted leaf and group nodes remaining after filtering. Note: This only works for tables using the client side row model.
     */
    getFilteredAndSortedRowNodes: () => RowNode[];
    getListFilter: (field: string) => Promise<any | undefined>;
    getListFilters: (fields?: string[]) => Promise<ListFilter[]>;
    getTableConfiguration: () => DataTableConfig;
    getBulkEditColumns: () => ColumnDefinition[];
    hideContextPanel: ContextPanelApi['hide'];
    isAnyFilterPresent: () => boolean;
    isSearchPresent: () => boolean;
    refreshCells: (params?: RefreshCellsParams) => void;
    refreshServerSide: (params: RefreshServerSideDataParams) => void;
    removeAllFilters: () => void;
    removeFilter: (field: string) => Promise<void>;
    setColumnsVisibility: (field: string[], visibility: boolean) => void;
    setColumnVisibility: (field: string, visibility: boolean) => void;
    setLoading: (loading: boolean, message?: string) => void;
    setPinnedBottomRowData: (rows: any[]) => void;
    setRowNodeExpanded: (rowNode: RowNode$1, expanded: boolean) => void;
    setRowGrouping: (group: string[]) => void;
    setRowHeight: (size: RowSize) => void;
    setSearchValue: (value: string) => void;
    setTableConfiguration: (config: DataTableConfig) => void;
    showContextPanel: ContextPanelApi['show'];
    sizeColumnsToFit: (tableWidth?: number) => void;
    /**
     * Get row data for all leaf row nodes. Note: This only works for tables using the client side row model.
     */
    getRowData: () => any[];
    setRowData: (items: any[]) => void;
    getSelectedRows: () => any[];
    /**
     * Select all rows, regardless of filtering and rows that are not visible due to grouping being enabled and their groups not expanded.
     * Note: This currently doesn't work for SSRM tables.
     */
    selectAll: () => void;
    /** Clear all row selections, regardless of filtering. */
    deselectAll: () => void;
    /** Auto-sizes a column based on its contents. */
    autoSizeColumn?: (key: string | Column, skipHeader?: boolean) => void;
    /** Same as `autoSizeColumn`, but provide a list of column keys. */
    autoSizeColumns?: (keys: (string | Column)[], skipHeader?: boolean) => void;
    /** Calls `autoSizeColumns` on all displayed columns. */
    autoSizeAllColumns?: (skipHeader?: boolean) => void;
    /**
     * Scroll a row into view and optionally focus on one of its cells. If no argument is passed to `focusField` it will default to not applying focus.
     * Once in view the row will be positioned at the top, middle or bottom of the visible table rows depending on the optional `position` parameter.
     * If no argument is passsed to `position` it will default to doing the minimum amount of scrolling required to show the row.
     * */
    scrollToRow(rowIndex: number, focusField?: string, position?: 'top' | 'bottom' | 'middle'): void;
    /**
     * Selects row nodes by their respective row node IDs.
     * The row node ID is the one you provide from the callback `getRowId(data)`,
     * otherwise the ID is a number auto-generated by the grid when the row data is set.
     */
    selectRows: (rowIds: (string | number)[]) => void;
    /**
     * Deselects row nodes by their respective row node IDs.
     * The row node ID is the one you provide from the callback `getRowId(data)`,
     * otherwise the ID is a number auto-generated by the grid when the row data is set.
     */
    deselectRows: (rowIds: (string | number)[]) => void;
    /**
     * Set a function determining if selection is enabled for each row as it's loaded into the table.
     * Note: Changing this will not affect existing rows that have already been loaded. Additionally,
     * selected rows which are later disabled remain selected.
     */
    setIsRowSelectable?(isRowSelectableFunc: IsRowSelectable): void;
}
type PartialTableApi = Pick<TableApi, 'applyTransaction' | 'applyServerSideTransaction' | 'collapseAll' | 'deselectAll' | 'expandAll' | 'getColumnDefinitions' | 'getDetailGridTableApi' | 'getFilteredAndSortedRowNodes' | 'getRootAggregateData' | 'getRowData' | 'getSelectedRows' | 'getTableConfiguration' | 'refreshCells' | 'scrollToRow' | 'selectAll' | 'setPinnedBottomRowData' | 'setRowData' | 'setRowNodeExpanded' | 'sizeColumnsToFit'>;
type AgDomLayout = 'normal' | 'autoHeight' | 'print' | undefined;
interface IsRowSelectable {
    (node: RowNode): boolean;
}
interface RowSelectionRef {
    affectedRows: AffectedRows;
    enabled?: boolean | ((params: RowSelectablePredicateParams<any>) => boolean);
    getRowId: DataTableProps['getRowId'];
    siblingGroupsRowDisabled?: boolean;
}
interface CellValueChangeParams<TValue> {
    field: string;
    rowData: Record<string, any>;
    newValue: TValue;
    oldValue: TValue;
    rowIndex?: number | null;
}
interface FirstDataRenderedEvent<TData = any, TContext = any> {
    firstRow: number;
    lastRow: number;
    api: GridApi<TData>;
    columnApi: ColumnApi;
    context: TContext;
    type: string;
}
type AgSort = 'asc' | 'desc' | null | undefined;
interface ColumnConfig {
    field: string;
    flex?: number | null | undefined;
    hidden: boolean | null | undefined;
    pinned: ColumnPinnedType;
    rowGroup: boolean | null | undefined;
    rowGroupIndex: number | null | undefined;
    sort: AgSort;
    sortIndex: number | null | undefined;
    width: number | undefined;
}
type ColumnGroupStateConfig = {
    groupId: string;
    open: boolean;
};
type ContextPanelContent = 'configuration' | 'custom' | 'filters' | 'bulkEdit';
interface ContextPanelApi {
    content?: ContextPanelContent;
    hide: () => void;
    isVisible: boolean;
    show: (content: ContextPanelContent) => void;
}
interface CustomFooterConfig {
    height?: RowSize;
    id: string;
}
interface AgGetDetailRowDataParams<TRow = any> {
    /** Row node for the details request */
    node: RowNode;
    /** Data for the current row */
    data: TRow;
    /** Callback to pass the rows back for the grid request */
    successCallback(rowData: any[]): void;
}
interface AvatarStackItemFilter {
    avatarStackItemFilter?: (x: any) => boolean;
}
interface GetDetailRowDataParams<TRow = any> extends Omit<AgGetDetailRowDataParams<TRow>, 'node'> {
}
type GetRowHeightWithFooters = (customFooters: CustomFooterConfig[] | undefined) => (params: Partial<RowHeightParams>) => number;
interface DetailRowConfig<TRow = any> {
    columnDefinitions: ColumnDefinition[];
    getDetailRowData: (params: GetDetailRowDataParams<TRow>) => void;
    height?: 'auto' | number;
    isExpandable?: (rowData: TRow) => boolean;
    customFooters?: CustomFooterConfig[];
    /** See ag-grid docs for more info: https://www.ag-grid.com/javascript-data-grid/master-detail-refresh/ */
    refreshStrategy?: 'everything' | 'rows' | 'nothing';
    rowSelectionEnabled?: boolean | ((params: CheckboxSelectionCallbackParams<TRow>) => boolean);
    rowSelection?: 'multiple' | 'single';
    rowMultiSelectWithClick?: boolean;
    suppressRowClickSelection?: boolean;
}
type CustomRendererCell = {
    component: React.ComponentType<any>;
    editorType?: 'input' | 'select';
    name: string;
    type: 'renderer';
};
type CustomEditorCell = {
    component: React.ForwardRefExoticComponent<any>;
    editorType: 'input' | 'select';
    name: string;
    type: 'editor';
};
type CustomFilter = {
    component: React.FunctionComponent<any>;
    name: string;
};
type CustomBulkEditorFields = {
    [key: string]: {
        component: ComponentWithFieldProp<any, FormFieldValueComponentProps<any>>;
        isEmpty: (value: any, defaultIsEmpty: (value: any) => boolean) => boolean;
    };
};
interface CSVExportConfig {
    fileName: string;
    columnKeys?: string[];
    skipFooters?: boolean;
    skipGroups?: boolean;
    skipPinnedBottom?: boolean;
    skipPinnedTop?: boolean;
}
interface ExcelExportConfig {
    fileName: string;
    columnKeys?: string[];
    sheetName?: string;
}
interface DataTableConfig {
    columnState: ColumnConfig[];
    columnGroupState?: ColumnGroupStateConfig[];
    filters?: {
        [key: string]: any;
    } | undefined;
    rowHeight?: RowSize;
    serverFilters?: IServerFilter[];
}
interface HTMLStringExportConfig {
    header?: React.FunctionComponent;
    preserveColumnWidths?: boolean;
    pageFormat?: ExportPageFormat;
    showTableHeaderOnEveryPage?: boolean;
    totalRowCount?: number;
}
interface IsEditableParams {
    columnDefinition: ColumnDefinition;
    data: Record<string, any>;
    node: RowNode;
}
interface SortModel {
    /** The column that is being sorted */
    field: string;
    /** The sort direction, ascending or descending */
    sort: 'asc' | 'desc';
}
interface ServerSideGetRowsRequest {
    /** The row index of the last row of request data
     * or undefined from all rows */
    endRow: number | undefined;
    /** Array of fields of grouped columns that are currently expanded  */
    groupKeys: string[];
    /** Array of fields of all columns that are grouped */
    rowGroupCols: ColumnDefinition[];
    /** The value entered in the search */
    searchValue: string;
    /** Contains the selected filters; the filter type,
     * and the value being filtered on */
    serverFilters: IServerFilter[];
    /** Array of objects consisting of the field of the column being sorted,
     * along with the sort direction ('asc' or 'desc')
     */
    sortModel: SortModel[];
    /** The row index of the first row of requested data
     * or undefined from all rows */
    startRow: number | undefined;
    /** The list of columns which are being aggregated */
    valueCols: ColumnDefinition[];
}
type SuccessParams = {
    /** The collection of data for a given request */
    rowData: any[];
    /** The total amount of rows */
    rowCount?: number;
    /** @private */
    storeInfo?: any;
};
type UpdateServerSideDataSourceParams = {
    search?: ISearchState;
    filter?: {
        field: string;
        internalFilterState?: any;
        value: any;
    };
};
type ServerSideParamsOptions = {
    /**
     * Enable pagination
     * @default true
     */
    pagination?: boolean;
    /**
     * Enable sorting
     * @default true
     */
    sort?: boolean;
    /**
     * Enable filtering
     * @default true
     */
    filters?: boolean;
    /**
     * Enable searching
     * @default true
     */
    search?: boolean;
    /**
     * Enable grouping
     * @default true
     */
    group?: boolean;
    /**
     * Custom search param key
     * @default filters[search]
     */
    searchKey?: string;
};
type ServerSideGetRowsParams = {
    /** Callback function to indicate that data fetching failed */
    onError(): void;
    /** Callback function to load row data into DataTable */
    onSuccess(params: SuccessParams): void;
    /** The data request object */
    request: ServerSideGetRowsRequest;
    /** Function that returns URL params from current request */
    getParams(options?: ServerSideParamsOptions): URLSearchParams;
};
type RefreshServerSideDataParams = {
    route?: string[];
    purge?: boolean;
};
type RowActivePredicateParams<TRow = any> = {
    data: TRow;
    node: RowNode;
    rowIndex: number;
};
type RowSelectablePredicateParams<TRow = any> = {
    data: TRow;
    node: RowNode;
    rowIndex: number | null;
};
interface DTExcelFormats {
    id: string;
    numberFormat?: {
        format: string;
    };
    dataType?: ExcelDataType;
}
type ISearchState = string;
declare enum SelectAllState {
    All = "all",
    None = "none",
    Partial = "partial"
}
interface TableProps<TRow = any, TBottomRow = any> {
    alwaysShowPseudoEditors?: boolean;
    autoGroupColumnDefinition?: ColumnDefinition;
    /**
     * Overrides internal props for AgGridReact. This is not guaranteed under DataTable SemVer
     * and can break during any upgrade of the ag-grid-react package
     *
     * For documentation see: {@link https://www.ag-grid.com/react-data-grid/grid-options/}
     * The ag-grid changelog can be found here: {@link https://www.ag-grid.com/changelog/}
     *
     * Warning: This can break normal Data Table functionality.
     */
    UNSAFE_internalAGGridOverrides?: AgGridReactProps | AgReactUiProps;
    customFooters?: CustomFooterConfig[];
    columnHeaderMenuOptions?: MenuDropdownOption[];
    /**
     * @deprecated Please use `detailRowConfig` instead
     * @deprecatedSince 11.13.0
     */
    detailRowConfigs?: DetailRowConfig<TRow>[];
    detailRowConfig?: DetailRowConfig<TRow>;
    /**
     * @deprecated Please use `detailRowConfig.rowSelectionEnabled` instead
     * @deprecatedSince 11.13.0
     */
    detailRowSelectionEnabled?: boolean;
    siblingGroupsRowSelectionDisabled?: boolean;
    emptyStateRenderer?: React.FunctionComponent;
    excelDataTypeFormats?: DTExcelFormats[];
    fullWidthCellRenderer?: React.FunctionComponent<ICellRendererParams>;
    getGroupRowAgg?: (nodes: RowNode[], currentGroupsValues: string[]) => TRow;
    getRowNodeId?: (data: TRow) => any;
    getSubtotalLabel?: (columnDefinition: ColumnDefinition, rowData: TRow, value: string | number) => string;
    groupDefaultExpanded?: number;
    groupIncludeFooter?: boolean;
    headerHeight?: number;
    hideActionsOnGroupedRow?: boolean;
    initialGroupOrderComparator?: (nodeA: RowNode, nodeB: RowNode) => number;
    isFullWidth?: (data: TRow) => boolean;
    isRowActive?: (params: RowActivePredicateParams<TRow>) => boolean;
    isRowOverdue?: (params: RowActivePredicateParams<TRow>) => boolean;
    loading?: boolean;
    maxHeight?: number;
    maintainColumnOrder?: boolean;
    modules: Module[];
    onCellValueChanged?: (params: CellValueChangeParams<any>) => void;
    onRowDragEnd?: (row: TRow, endIndex: number, node: Pick<RowNode, 'childIndex' | 'group'>, overNode?: Pick<RowNode, 'childIndex' | 'group' | 'data'>) => void;
    onRowSelected?: (event: RowSelectedEvent) => void;
    onSelectAll?: (param: SelectAllState.All | SelectAllState.None) => void;
    onTableReady?: (tableApi: TableApi, tableApiRef: React.RefObject<TableApi>) => void;
    onColumnEverythingChanged?: (changeEvent: ColumnEverythingChangedEvent) => void;
    onFirstDataRendered?: (event: FirstDataRenderedEvent) => void;
    pagination?: boolean;
    paginationPageSize?: number;
    pinnedBottomRowData?: TBottomRow[];
    popupParent?: HTMLElement;
    rowActions?: React.FunctionComponent<any>[];
    /**
     * @private
     * Unsafe to use.
     *
     * Sets row virtualization buffer
     */
    rowBuffer?: number;
    /**
     * Row data for the table. Only necessary when using client side data
     * model.
     * @see onServerSideDataRequest if using server side data model
     */
    rows?: TRow[];
    rowDragManaged?: boolean;
    rowSelectionEnabled?: boolean | ((params: RowSelectablePredicateParams<TRow>) => boolean);
    selectionSSREnabled?: boolean;
    showExpandableMenuOptions?: boolean;
    showGroupChildCount?: boolean;
    /**
     * Removes border right from column group's last column
     */
    suppressColumnGroupBorders?: boolean;
    suppressColumnVirtualisation?: boolean;
    suppressExpandGroupsButton?: boolean;
    suppressFieldDotNotation?: boolean;
    suppressResetColumnsOption?: boolean;
    suppressRowClickSelection?: boolean;
    stickyExpandedGroupRows?: boolean;
}
type AggregationFunction<TValue> = (params: {
    columnDefinition: ColumnDefinition;
    values: TValue[];
    rowNode: {
        allLeafChildren: {
            data: TValue;
        }[];
    };
    /**
     * If rendering in a nested table, this is the id of the parent row
     */
    parentId: string | undefined;
    /**
     * If rendering in a nested table, this is the data for the parent row
     */
    parentData: any | undefined;
}) => number;
type RowNode = {
    aggData: any;
    childIndex: number;
    childrenAfterFilter: IRowNode[];
    data: any;
    expanded: boolean;
    field: string | null;
    footer?: boolean;
    group?: boolean;
    id: string | undefined;
    key: string | null;
    parent: RowNode | null;
    rowGroupIndex: number | null;
    rowIndex: number | null;
    rowPinned: ColumnPinnedType | 'top' | 'bottom';
};
interface ValueGetterParams {
    columnDefinition: ColumnDefinition;
    data: Record<string, any>;
    node?: RowNode;
}
interface ValueParserParams {
    columnDefinition: ColumnDefinition;
    newValue: any;
    oldValue: any;
}
interface ValueSetterParams {
    columnDefinition: ColumnDefinition;
    data: Record<string, any>;
    node?: RowNode;
    newValue: any;
    oldValue: any;
}
interface ValueValidator<TValue extends any = any> {
    (params: ValueValidatorParams<TValue>): {
        isValid: boolean;
        errorMessage?: string | string[];
        isRequired?: boolean;
    };
}
interface ValueValidatorParams<TValue = any> {
    columnDefinition: ColumnDefinition;
    data: Record<string, any>;
    node?: RowNode;
    value: TValue;
}
interface FrameworkComponents {
    [key: string]: React.ComponentType<any>;
}
interface PinnedBottomRow extends Record<string, any> {
    footerId: 'grandTotal' | string;
    isAggData?: boolean;
}
interface TablePanelProps extends React.HtmlHTMLAttributes<HTMLDivElement> {
    children?: React.ReactNode;
    className?: string;
    style?: React.CSSProperties;
}
interface AnalyticsConfig {
    client: AnalyticsClient;
    clientName: string;
}
interface AnalyticsClient extends IAnalytics {
    sendAllEvents: () => Promise<void>;
    addEvent: IAnalytics['trackEvent'];
}
interface DataTableTranslations {
    loadingLabel?: string;
    searchEmptyStateTitle?: string;
    tableName?: string;
}
interface DataTableProps {
    analytics?: AnalyticsConfig;
    columnDefinitions: (ColumnDefinition | NestedColumnDefinition)[];
    enableGroupEditAndValidation?: boolean;
    enableDynamicRowHeight?: boolean;
    filterGroups?: FilterGroup[];
    getRowId?: (params: GetRowIdParams) => string;
    initialTableConfig?: DataTableConfig;
    onTableConfigChange?: (config: DataTableConfig) => void;
    onServerSideDataRequest?: (params: ServerSideGetRowsParams) => Promise<SuccessParams | void> | void;
    grandTotalsLabelRenderer?: React.FunctionComponent<GrandTotalsLabelRendererProps>;
    /**
     * Callback after bulk edit action is performed.
     * Each object in the array represents a selected row with
     * the updated values
     */
    onBulkEditUpdate?: (rows: BulkEditResult[]) => Promise<void>;
    translations?: DataTableTranslations;
    customBulkEditorFields?: CustomBulkEditorFields;
}
interface ClientSideDataTableProps extends Omit<DataTableProps, 'onServerSideDataRequest'> {
}
interface FilterGroup {
    name: string;
    displayedName: string;
    scrollHeight?: number;
}

interface ListFilter extends IClientSideFilter {
    options: (string | null)[];
    value: (string | null)[];
}
type FilterRecord<TValue = any[] | NumberFilterModel> = {
    field: string;
    instance: IFilter;
    columnDefinition: ColumnDefinition;
    type: 'set' | 'number';
    options?: any[];
    filterValues?: TValue;
};
/**
 * @param columnDefinitons The DataTable column definitions object
 * @param gridApi The api from ag-grid
 * @param enabled Will set the event listeners if true. Should be false when using server side row model
 */
declare function useFilterState({ columnDefinitions, gridApi, enabled, }: {
    columnDefinitions: ColumnDefinition[];
    gridApi?: GridApi;
    enabled?: boolean;
}): {
    allAvailableFilters: FilterRecord<any[] | NumberFilterModel>[];
    filterableColumns: ColumnDefinition<any, React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>, any, React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>, any, any, string | number | NumberFilterValue | LocationFilterOpt | {
        date: Date;
    }, string, any>[];
};

type DateFilterComponentProps = FilterComponentProps<{
    date: Date;
}, Array<{
    date: Date;
}>>;
declare const DateFilterRenderer: (props: DateFilterComponentProps) => React__default.JSX.Element | null;

type LocationFilterProps = FilterComponentProps<LocationOption, LocationOption[]>;
interface LocationOption {
    label?: string;
    name?: string;
    id: string | number;
}
declare const LocationFilterRenderer: (props: LocationFilterProps) => React__default.JSX.Element | null;

declare const MultiSelectFilterRenderer: (props: FilterComponentProps) => React__default.JSX.Element | null;

interface IFilterProps<Opt = any, Val = number | string | null> {
    columnDefinition: ColumnDefinition;
    filter?: FilterRecord;
    getFilterHeadingText?: (columnDefinition: ColumnDefinition) => React.FunctionComponent | string;
    getFilterTokenText?: ({ headerName, value, }: {
        headerName: string;
        value: Val extends string ? string[] : Val extends number ? number[] : unknown[];
    }) => React.FunctionComponent | string;
    getFilterOptions?: () => Promise<Opt[]>;
    getId?: (option: Opt) => Val extends string ? string : Val extends number ? number : unknown;
    getLabel?: (option: Opt) => string;
    groupName?: string;
    index?: number;
    onChange?: (values: any[]) => void;
    onRemove?: () => void;
    placeholder?: string;
}
interface IDateFilterProps<Opt = {
    date: Date;
}, Val = string> extends IFilterProps<Opt, Val> {
    /** Controls the type of filtering: single, range,
     * or up to user choice (either) */
    selectionType?: DateFilterSelectionType;
}
interface ILocationFilterProps<Opt = LocationFilterOpt, Val = string> extends IFilterProps<Opt, Val> {
    onSearch?: (event: React.ChangeEvent<HTMLInputElement>) => void;
}
interface INumberFilterProps<Opt = {
    id: NumberFilterModel['type'];
    label: string;
}, Val = any> extends Omit<IFilterProps<Opt, Val>, 'getFilterOptions'>, Pick<IScalarFilterParams, 'inRangeInclusive' | 'includeBlanksInEquals' | 'includeBlanksInLessThan' | 'includeBlanksInGreaterThan' | 'includeBlanksInRange'> {
    getFilterOptions?: () => ISimpleFilterParams['filterOptions'];
}
interface FilterComponentProps<Opt = any, Val = Opt[] | NumberFilterModel> {
    columnDefinition: ColumnDefinition;
    filter: FilterRecord<Opt[] | NumberFilterModel>;
    filterDef: IFilter;
    getOptions?: () => Promise<boolean>;
    internalFilterState?: any;
    loading: boolean;
    onChange: (value: Opt[] | NumberFilterModel | undefined, internalFilterState?: any) => void;
    onRemove: () => void;
    options: Opt[];
    value: Val;
}
interface IClientSideFilter {
    active: boolean;
    field: string;
    name: string;
    readonly type: 'list' | 'number';
}
interface IFilterMeta<Opt = any, Val = number | string> {
    headerName?: string;
    filterRenderer?: React.FunctionComponent<IFilterProps<Opt, Val>>;
    field: string;
    filterProps?: IFilterProps<Opt, Val>;
}
interface IServerFilter<Opt = any, Val = number | string> extends IFilterState<Opt, Val>, IFilterMeta<Opt, Val> {
}
interface IFilterState<Opt = any, Val = number | string> {
    /**
     * The full selected option shape
     */
    selected: Opt[];
    /**
     * The result of getId from each option
     */
    value: Val[];
    field: string;
    /**
     * Internal config used to set up the filter UI. Primary use case for Quick Filters and
     * Filters Panel Filters to update each others' UI.
     */
    internalFilterState?: any;
}
interface IServerFiltersState {
    [field: string]: IFilterState;
}
interface IFilterStorage<UniversalOpt = any, UniversalVal = number | string> {
    hasDefinedFilters: boolean;
    hasSelectedFilters: boolean;
    getInternalFilterState: (field: string) => any;
    getOptions: (field: string) => UniversalOpt[];
    getSelected: (field: string) => IFilterState<UniversalOpt, UniversalVal>;
    getListFilter: (field: string) => IFilterState<UniversalOpt, UniversalVal>;
    selectedFilters: IServerFiltersState;
    onChangeFilterValue: ({ field, internalFilterState, value, }: {
        field: string;
        internalFilterState?: any;
        value: any;
    }) => void;
    onClearFilter: (field: string) => void;
    onClearAllFilters: React.MouseEventHandler<HTMLButtonElement>;
    possibleFilters: string[];
    setSelectedFilters: (filters: IServerFilter[]) => void;
    waitForStoredOptions: (field: string) => Promise<void>;
    filtersState: IServerFilter[];
}

interface ISearchStorage {
    searchValue: string;
    setSearchValue: (value: string) => void;
}

interface InternalTableContext {
    analytics?: AnalyticsConfig;
    columnApi?: ColumnApi;
    columnDefinitions: ColumnDefinition[];
    contextPanel: ContextPanelApi;
    customBulkEditorFields?: CustomBulkEditorFields;
    enableDynamicRowHeight: boolean;
    enableGroupEditAndValidation: boolean;
    filterGroups?: FilterGroup[];
    getRowHeight: GetRowHeightWithFooters;
    getRowId?: DataTableProps['getRowId'];
    gridApi?: GridApi;
    grandTotalsLabelInnerRenderer?: React__default.FunctionComponent<GrandTotalsLabelRendererProps>;
    initialTableConfig?: DataTableConfig;
    filterState: ReturnType<typeof useFilterState>;
    filterStorage: IFilterStorage;
    onBulkEditUpdate: DataTableProps['onBulkEditUpdate'];
    onServerSideDataRequest?: DataTableProps['onServerSideDataRequest'];
    updateServerSideDataSource: (params: UpdateServerSideDataSourceParams) => void;
    onTableConfigChange: () => void;
    rowHeight: RowSize;
    rowSelectionRef?: React__default.MutableRefObject<RowSelectionRef>;
    searchStorage: ISearchStorage;
    selectedGroupIndex?: string | null;
    setColumnApi: (columnApi: ColumnApi) => void;
    setGridApi: (gridApi: GridApi) => void;
    setRowHeight: (rowHeight: RowSize, createTrackEvent?: boolean, triggerTableConfigChange?: boolean) => void;
    tableRef: React__default.RefObject<TableApi> | null;
    getColumnDefinition: (field: string) => ColumnDefinition | undefined;
    totalRowCount: number;
    setTotalRowCount: React__default.Dispatch<React__default.SetStateAction<number>>;
    setSelectedGroupIndex?: React__default.Dispatch<React__default.SetStateAction<string | null>>;
}
declare const InternalTableContext: React__default.Context<InternalTableContext>;

declare const DateTimeCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;
declare const DateTimeCellEditor: React__default.ForwardRefExoticComponent<_ag_grid_community_core.ICellEditorParams<any, any, any>>;

declare const PersonCellRenderer: React__default.FC<_ag_grid_community_core.ICellRendererParams<any, any, any>>;

interface SearchProps {
    onSearch?: React__default.ChangeEventHandler<HTMLInputElement>;
    /** The placeholder to the Search input */
    placeholder?: string;
    disabled?: boolean;
}

interface QuickControlsProps extends Omit<SearchProps, 'disabled'> {
    style?: React__default.CSSProperties;
    disabledSearch?: boolean;
}

interface ActionButtonProps {
    showLabel?: boolean;
    actionText?: string;
}

interface BulkActionProps {
    /** To not hide the bulk actions bar,
     * even when the row selection is empty it should be displayed. */
    showAlways?: boolean;
    showEditButtonLabel?: boolean;
    editButtonText?: string;
    style?: React__default.CSSProperties;
}

declare const _default$1: (({ analytics, children, columnDefinitions: _columnDefinitions, customBulkEditorFields, enableDynamicRowHeight, enableGroupEditAndValidation, filterGroups, getRowId, initialTableConfig: _initialTableConfig, onBulkEditUpdate, onTableConfigChange, translations, }: React__default.PropsWithChildren<ClientSideDataTableProps>) => React__default.JSX.Element) & {
    BulkActions: React__default.FunctionComponent<React__default.PropsWithChildren<BulkActionProps>>;
    BulkEditActionButton: React__default.FunctionComponent<ActionButtonProps>;
    ConfigPanelButton: React__default.FC<{}>;
    ContextPanel: React__default.FC<TablePanelProps>;
    QuickControls: React__default.FunctionComponent<QuickControlsProps>;
    QuickFilters: React__default.FunctionComponent<{}>;
    RowGroupSelector: React__default.FC<{
        localeText: {
            reset: string;
            placeholder: string;
            selectedItemsPrefix?: string | undefined;
        };
    }>;
    Search: React__default.FunctionComponent<SearchProps>;
    Table: React__default.FC<Omit<TableProps<any, any>, "selectionSSREnabled" | "modules">>;
    FiltersPanel: React__default.FunctionComponent<TablePanelProps>;
    FiltersPanelButton: React__default.FunctionComponent<{}>;
};

type EmptyRendererProps = {
    children?: React__default.ReactNode;
    hasFilters?: boolean;
    hasSearch?: boolean;
    itemsLabel?: string;
};

declare const QuickDateFilterRenderer: (props: ServerSideFilterProps) => React__default.JSX.Element | null;

declare const LocationQuickFilterRenderer: React__default.FC<FilterProps>;

declare const MultiSelectQuickFilterRenderer: (props: FilterProps<any[]>) => React__default.JSX.Element;

declare const _default: (({ analytics, children, columnDefinitions: _columnDefinitions, customBulkEditorFields, enableDynamicRowHeight, enableGroupEditAndValidation, filterGroups, getRowId, initialTableConfig: _initialTableConfig, onBulkEditUpdate, onServerSideDataRequest, onTableConfigChange, translations, }: React__default.PropsWithChildren<DataTableProps>) => React__default.JSX.Element) & {
    BulkActions: React__default.FunctionComponent<React__default.PropsWithChildren<BulkActionProps>>;
    BulkEditActionButton: React__default.FunctionComponent<ActionButtonProps>;
    ConfigPanelButton: React__default.FC<{}>;
    ContextPanel: React__default.FC<TablePanelProps>;
    QuickControls: React__default.FunctionComponent<QuickControlsProps>;
    QuickFilters: React__default.FunctionComponent<{}>;
    RowGroupSelector: React__default.FC<{
        localeText: {
            reset: string;
            placeholder: string;
            selectedItemsPrefix?: string | undefined;
        };
    }>;
    Search: React__default.FunctionComponent<SearchProps>;
    Table: React__default.FC<Omit<TableProps<any, any>, "rows" | "modules">>;
    FiltersPanel: React__default.FunctionComponent<TablePanelProps>;
    FiltersPanelButton: React__default.FunctionComponent<{}>;
};

declare const useRowSelectionState: () => IRowNode<any>[];

declare function withDataTableEditor(Component: React__default.ForwardRefExoticComponent<any>, editorType: 'input' | 'select' | 'date' | 'textarea'): React__default.ForwardRefExoticComponent<ICellEditorParams>;
declare function withDataTableRenderer(Component: React__default.ComponentType<any>, editorType?: 'input' | 'select' | 'date' | 'textarea'): React__default.FC<ICellRendererParams>;

declare const waitForAsyncCondition: (condition: Function, maxAttempts?: number, timeout?: number, attempts?: number) => Promise<void>;

/**
 * **For power users only!**
 *
 * Usage of {@link TableApi} is preferred.
 * Please try using `onTableReady` prop to access `TableApi`
 *
 * @internal This is not under semver and can break during any release
 */
declare const UNSAFE_useTableContext: () => InternalTableContext;

export { type AgDomLayout, type AgGetDetailRowDataParams, type AgSort, type AggregationFunction, type AnalyticsClient, type AnalyticsConfig, type AvatarStackItemFilter, type BooleanCellColumnDefinition, BooleanCellEditor, type BooleanCellEditorProps, BooleanCellRenderer, type BooleanCellRendererProps, type ButtonsCellColumnDefinition, ButtonsCellRenderer, type CSVExportConfig, type CellValueChangeParams, _default$1 as ClientSideDataTable, type ClientSideDataTableProps, type ColumnConfig, type ColumnDefinition, type ColumnGroupStateConfig, type CompanyCellColumnDefinition, CompanyCellRenderer, type CompanyCellRendererProps, type ContextPanelApi, type ContextPanelContent, type CurrencyCellColumnDefinition, CurrencyCellEditor, type CurrencyCellEditorProps, CurrencyCellRenderer, type CurrencyCellRendererProps, type CustomBulkEditorFields, type CustomEditorCell, type CustomFilter, type CustomFooterConfig, type CustomRendererCell, type DTExcelFormats, type DataTableCellEditorProps, type DataTableCellRendererProps, type DataTableConfig, type DataTableProps, type DataTableTranslations, type DateCellColumnDefinition, DateCellEditor, type DateCellEditorProps, DateCellRenderer, type DateCellRendererProps, DateFilterRenderer, type DateFilterSelectionType, QuickDateFilterRenderer as DateQuickFilterRenderer, type DateTimeCellColumnDefinition, DateTimeCellEditor, DateTimeCellRenderer, type DetailRowConfig, type EmptyRendererProps, type ExcelExportConfig, type ExtendedColDef, type FilterGroup, type FrameworkComponents, type GetDetailRowDataParams, type GetRowHeightWithFooters, GrandTotalsLabelRenderer, type GranularPartial, type GranularRequired, type GroupCellColumnDefinition, GroupCellRenderer, type HTMLStringExportConfig, type ISearchState, type IServerFilter, type IsEditableParams, type IsRowSelectable, type LinkCellColumnDefinition, LinkCellRenderer, type LinkCellRendererProps, type LocationColumnDefinition, type LocationFilterOpt, LocationFilterRenderer, LocationQuickFilterRenderer, type MultiSelectCellColumnDefinition, MultiSelectCellRenderer, type MultiSelectCellRendererProps, MultiSelectFilterRenderer, MultiSelectQuickFilterRenderer, type NestedColumnDefinition, type NumberCellColumnDefinition, NumberCellEditor, type NumberCellEditorProps, NumberCellRenderer, type NumberCellRendererProps, NumberFilterRenderer, type PartialTableApi, type PeopleCellColumnDefinition, PeopleCellRenderer, type PeopleCellRendererProps, type PercentCellColumnDefinition, PercentCellEditor, type PercentCellEditorProps, PercentCellRenderer, type PercentCellRendererProps, PersonCellRenderer, type PillCellColumnDefinition, PillCellRenderer, type PillCellRendererProps, PillSelectCellEditor, type PillSelectCellEditorProps, type PinnedBottomRow, type RefreshServerSideDataParams, type RowActivePredicateParams, type RowNode, type RowSelectablePredicateParams, type RowSelectionRef, SelectAllState, type SelectCellColumnDefinition, SelectCellEditor, type SelectCellEditorProps, SelectCellRenderer, type SelectCellRendererProps, _default as ServerSideDataTable, type DataTableProps as ServerSideDataTableProps, type ServerSideGetRowsParams, type ServerSideGetRowsRequest, type ServerSideParamsOptions, type SortModel, type SuccessParams, type TableApi, type TablePanelProps, type TableProps, type TextAreaCellColumnDefinition, type TextAreaCellEditorProps, type TextAreaCellRendererProps, type TextCellColumnDefinition, TextCellEditor, type TextCellEditorProps, TextCellRenderer, type TextCellRendererProps, UNSAFE_useTableContext, type UpdateServerSideDataSourceParams, type ValueGetterParams, type ValueParserParams, type ValueSetterParams, type ValueValidator, type ValueValidatorParams, rowSize, useRowSelectionState, waitForAsyncCondition, withDataTableEditor, withDataTableRenderer };
