@procore/data-table 14.4.2 → 14.4.3-next.0

package/dist/types.d.ts

@@ -0,0 +1,684 @@
+/// <reference types="react" />
+import { CheckboxSelectionCallbackParams, ColDef, Column, ColumnApi, ColumnEverythingChangedEvent, ColumnPinnedType, ExcelDataType, GetRowIdParams, GridApi, ICellEditor, ICellEditorParams, ICellRendererParams, IRowNode, Module, RefreshCellsParams, RowDataTransaction, RowGroupOpenedEvent, RowHeightParams, RowNode as AGRowNode, RowNodeTransaction, RowSelectedEvent, SelectionEventSourceType, ServerSideTransaction } from '@ag-grid-community/core';
+import { AgGridReactProps, AgReactUiProps } from '@ag-grid-community/react';
+import type { ComponentWithFieldProp, FormFieldValueComponentProps } from '@procore/core-react';
+import { AnalyticsConfig } from './Analytics/types';
+import { GrandTotalsLabelRendererProps } from './CellRenderers/GrandTotalsLabel';
+import { ColumnSort, PinColumnSide, RowSize } from './constants';
+import { FilterComponentProps, IDateFilterProps, IFilterProps, ILocationFilterProps, INumberFilterProps, IServerFilter } from './FilterRenderers';
+import { NumberFilterModel, NumberFilterValue } from './FilterRenderers/NumberFilterRenderer';
+import { MenuDropdownOption } from './GenericHeader/GenericHeader';
+import { BulkEditResult } from './Panels/BulkEdit';
+import { ClientSideFilterProps, ServerSideFilterProps } from './QuickFilterRenderers/types';
+import { ListFilter } from './state/useFilterState';
+import { ExportPageFormat } from './utils/generateHTMLString';
+import { AffectedRows } from './utils/rowSelectionHelpers';
+export type GranularRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type GranularPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** Column Definitions */
+export 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'];
+}
+export 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;
+}
+export 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) */
+export type DateFilterSelectionType = 'single' | 'range' | 'either';
+export 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;
+}
+export interface LocationFilterOpt {
+    id: number | string;
+    label: string;
+}
+export interface LocationColumnDefinition extends Omit<ColumnDefinition, 'filterProps'> {
+    filterProps?: ILocationFilterProps<LocationFilterOpt, string>;
+}
+export * from './Analytics/types';
+export type { BooleanCellColumnDefinition, BooleanCellEditorProps, BooleanCellRendererProps, } from './CellRenderers/BooleanCell';
+export type { ButtonsCellColumnDefinition } from './CellRenderers/ButtonsCell';
+export type { CompanyCellColumnDefinition, CompanyCellRendererProps, } from './CellRenderers/CompanyCell';
+export type { CurrencyCellColumnDefinition, CurrencyCellEditorProps, CurrencyCellRendererProps, } from './CellRenderers/CurrencyCell';
+export type { DataTableCellEditorProps, DataTableCellRendererProps, } from './CellRenderers/DataTableCell';
+export type { DateCellColumnDefinition, DateCellEditorProps, DateCellRendererProps, } from './CellRenderers/DateCell';
+export type { GroupCellColumnDefinition } from './CellRenderers/GroupCell';
+export type { LinkCellColumnDefinition, LinkCellRendererProps, } from './CellRenderers/LinkCell';
+export type { MultiSelectCellColumnDefinition, MultiSelectCellRendererProps, } from './CellRenderers/MultiSelectCell';
+export type { NumberCellColumnDefinition, NumberCellEditorProps, NumberCellRendererProps, } from './CellRenderers/NumberCell';
+export type { PeopleCellColumnDefinition, PeopleCellRendererProps, } from './CellRenderers/PeopleCell';
+export type { PercentCellColumnDefinition, PercentCellEditorProps, PercentCellRendererProps, } from './CellRenderers/PercentCell';
+export type { PillCellColumnDefinition, PillCellRendererProps, PillSelectCellEditorProps, } from './CellRenderers/PillCell';
+export type { SelectCellColumnDefinition, SelectCellEditorProps, SelectCellRendererProps, } from './CellRenderers/SelectCell';
+export type { TextAreaCellColumnDefinition, TextAreaCellEditorProps, TextAreaCellRendererProps, } from './CellRenderers/TextAreaCell';
+export type { TextCellColumnDefinition, TextCellEditorProps, TextCellRendererProps, } from './CellRenderers/TextCell';
+/** End Column Definitions */
+export 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: AGRowNode, 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)[], source?: SelectionEventSourceType) => 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)[], source?: SelectionEventSourceType) => 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;
+}
+export type PartialTableApi = Pick<TableApi, 'applyTransaction' | 'applyServerSideTransaction' | 'collapseAll' | 'deselectAll' | 'expandAll' | 'getColumnDefinitions' | 'getDetailGridTableApi' | 'getFilteredAndSortedRowNodes' | 'getRootAggregateData' | 'getRowData' | 'getSelectedRows' | 'getTableConfiguration' | 'refreshCells' | 'scrollToRow' | 'selectAll' | 'setPinnedBottomRowData' | 'setRowData' | 'setRowNodeExpanded' | 'sizeColumnsToFit'>;
+export type AgDomLayout = 'normal' | 'autoHeight' | 'print' | undefined;
+export interface IsRowSelectable {
+    (node: RowNode): boolean;
+}
+export interface RowSelectionRef {
+    affectedRows: AffectedRows;
+    enabled?: boolean | ((params: RowSelectablePredicateParams<any>) => boolean);
+    getRowId: DataTableProps['getRowId'];
+    siblingGroupsRowDisabled?: boolean;
+}
+export 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;
+}
+export type AgSort = 'asc' | 'desc' | null | undefined;
+export 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;
+}
+export type ColumnGroupStateConfig = {
+    groupId: string;
+    open: boolean;
+};
+export type ContextPanelContent = 'configuration' | 'custom' | 'filters' | 'bulkEdit';
+export interface ContextPanelApi {
+    content?: ContextPanelContent;
+    hide: () => void;
+    isVisible: boolean;
+    show: (content: ContextPanelContent) => void;
+}
+export interface CustomFooterConfig {
+    height?: RowSize;
+    id: string;
+}
+export 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;
+}
+export interface AvatarStackItemFilter {
+    avatarStackItemFilter?: (x: any) => boolean;
+}
+export interface GetDetailRowDataParams<TRow = any> extends Omit<AgGetDetailRowDataParams<TRow>, 'node'> {
+}
+export type GetRowHeightWithFooters = (customFooters: CustomFooterConfig[] | undefined) => (params: Partial<RowHeightParams>) => number;
+export interface DetailRowConfig<TRow = any> {
+    autoGroupColumnDefinition?: ColumnDefinition;
+    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;
+}
+export type CustomRendererCell = {
+    component: React.ComponentType<any>;
+    editorType?: 'input' | 'select';
+    name: string;
+    type: 'renderer';
+};
+export type CustomEditorCell = {
+    component: React.ForwardRefExoticComponent<any>;
+    editorType: 'input' | 'select';
+    name: string;
+    type: 'editor';
+};
+export type CustomFilter = {
+    component: React.FunctionComponent<any>;
+    name: string;
+};
+export type CustomBulkEditorFields = {
+    [key: string]: {
+        component: ComponentWithFieldProp<any, FormFieldValueComponentProps<any>>;
+        isEmpty: (value: any, defaultIsEmpty: (value: any) => boolean) => boolean;
+    };
+};
+export interface CSVExportConfig {
+    fileName: string;
+    columnKeys?: string[];
+    skipFooters?: boolean;
+    skipGroups?: boolean;
+    skipPinnedBottom?: boolean;
+    skipPinnedTop?: boolean;
+}
+export interface ExcelExportConfig {
+    fileName: string;
+    columnKeys?: string[];
+    sheetName?: string;
+}
+export interface DataTableConfig {
+    columnState: ColumnConfig[];
+    columnGroupState?: ColumnGroupStateConfig[];
+    filters?: {
+        [key: string]: any;
+    } | undefined;
+    rowHeight?: RowSize;
+    serverFilters?: IServerFilter[];
+}
+export interface HTMLStringExportConfig {
+    header?: React.FunctionComponent;
+    preserveColumnWidths?: boolean;
+    pageFormat?: ExportPageFormat;
+    showTableHeaderOnEveryPage?: boolean;
+    totalRowCount?: number;
+}
+export interface IsEditableParams {
+    columnDefinition: ColumnDefinition;
+    data: Record<string, any>;
+    node: RowNode;
+}
+export interface SortModel {
+    /** The column that is being sorted */
+    field: string;
+    /** The sort direction, ascending or descending */
+    sort: 'asc' | 'desc';
+}
+export 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[];
+}
+export type SuccessParams = {
+    /** The collection of data for a given request */
+    rowData: any[];
+    /** The total amount of rows */
+    rowCount?: number;
+    /** @private */
+    storeInfo?: any;
+};
+export type UpdateServerSideDataSourceParams = {
+    search?: ISearchState;
+    filter?: {
+        field: string;
+        value: any;
+    };
+};
+export 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;
+};
+export interface RowActionsConfig extends Omit<ColDef, 'field' | 'pinned' | 'lockPinned' | 'lockVisible'> {
+}
+export 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;
+};
+export type RefreshServerSideDataParams = {
+    route?: string[];
+    purge?: boolean;
+};
+export type RowActivePredicateParams<TRow = any> = {
+    data: TRow;
+    node: RowNode;
+    rowIndex: number;
+};
+export type RowSelectablePredicateParams<TRow = any> = {
+    data: TRow;
+    node: RowNode;
+    rowIndex: number | null;
+};
+export interface DTExcelFormats {
+    id: string;
+    numberFormat?: {
+        format: string;
+    };
+    dataType?: ExcelDataType;
+}
+export type ISearchState = string;
+export declare enum SelectAllState {
+    All = "all",
+    None = "none",
+    Partial = "partial"
+}
+export type RowGroupToggledEvent<TRow> = Pick<RowGroupOpenedEvent<TRow>, 'expanded' | 'rowIndex'> & {
+    node: RowNode;
+};
+export interface TableProps<TRow = any, TBottomRow = any> {
+    alwaysShowPseudoEditors?: boolean;
+    autoGroupColumnDefinition?: ColumnDefinition;
+    rowActionsConfig?: RowActionsConfig;
+    /**
+     * 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;
+    onRowGroupOpened?: (event: RowGroupToggledEvent<TRow>) => 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;
+}
+export 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;
+export 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';
+};
+export interface ValueGetterParams {
+    columnDefinition: ColumnDefinition;
+    data: Record<string, any>;
+    node?: RowNode;
+}
+export interface ValueParserParams {
+    columnDefinition: ColumnDefinition;
+    newValue: any;
+    oldValue: any;
+}
+export interface ValueSetterParams {
+    columnDefinition: ColumnDefinition;
+    data: Record<string, any>;
+    node?: RowNode;
+    newValue: any;
+    oldValue: any;
+}
+export interface ValueValidator<TValue extends any = any> {
+    (params: ValueValidatorParams<TValue>): {
+        isValid: boolean;
+        errorMessage?: string | string[];
+        isRequired?: boolean;
+    };
+}
+export interface ValueValidatorParams<TValue = any> {
+    columnDefinition: ColumnDefinition;
+    data: Record<string, any>;
+    node?: RowNode;
+    value: TValue;
+}
+export interface FrameworkComponents {
+    [key: string]: React.ComponentType<any>;
+}
+export interface PinnedBottomRow extends Record<string, any> {
+    footerId: 'grandTotal' | string;
+    isAggData?: boolean;
+}
+export interface TablePanelProps extends React.HtmlHTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface DataTableTranslations {
+    loadingLabel?: string;
+    searchEmptyStateTitle?: string;
+    tableName?: string;
+}
+export 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;
+    enableCellTextSelection?: boolean;
+}
+export interface ClientSideDataTableProps extends Omit<DataTableProps, 'onServerSideDataRequest'> {
+}
+export interface FilterGroup {
+    name: string;
+    displayedName: string;
+    scrollHeight?: number;
+}

package/dist/utils/ContactItem.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { RowSize } from '../constants';
+interface ContactItemProps {
+    description?: string;
+    icon?: React.ReactNode;
+    imageUrl?: string;
+    initials?: string;
+    title: string;
+    rowHeight: RowSize;
+}
+export declare function ContactItem({ description, icon, imageUrl, initials, title, rowHeight, }: ContactItemProps): React.JSX.Element;
+export {};