mgh-components 1.0.14 → 1.1.0

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

@@ -0,0 +1,708 @@
+import React, { JSX } from 'react';
+export type MGHGridRowId = string | number;
+export type MGHGridValidRowModel = {
+    [key: string]: any;
+};
+export type MGHGridColType = 'string' | 'number' | 'date' | 'dateTime' | 'boolean' | 'singleSelect' | 'actions';
+export type MGHGridSortDirection = 'asc' | 'desc' | null | undefined;
+export type MGHGridAlignment = 'left' | 'center' | 'right';
+export type MGHGridDensity = 'compact' | 'standard' | 'comfortable';
+export type MGHGridPinnedSide = 'left' | 'right';
+export type MGHGridLogicOperator = 'and' | 'or';
+export type MGHGridThemeMode = 'light' | 'dark';
+export type MGHGridCellMode = 'view' | 'edit';
+export type MGHGridAggregationFunctionName = 'sum' | 'avg' | 'min' | 'max' | 'size' | (string & {});
+export interface MGHGridSortItem {
+    field: string;
+    sort: MGHGridSortDirection;
+}
+export type MGHGridSortModel = MGHGridSortItem[];
+export interface MGHGridFilterItem {
+    id?: number | string;
+    field: string;
+    operator: string;
+    value?: any;
+}
+export interface MGHGridFilterModel {
+    items: MGHGridFilterItem[];
+    logicOperator?: MGHGridLogicOperator;
+    quickFilterValues?: any[];
+    quickFilterLogicOperator?: MGHGridLogicOperator;
+    quickFilterExcludeHiddenColumns?: boolean;
+}
+export interface MGHGridPaginationModel {
+    page: number;
+    pageSize: number;
+}
+export type MGHGridColumnVisibilityModel = Record<string, boolean>;
+export interface MGHGridPinnedColumns {
+    left?: string[];
+    right?: string[];
+}
+export interface MGHGridPinnedRows<R extends MGHGridValidRowModel = any> {
+    top?: R[];
+    bottom?: R[];
+}
+export interface MGHGridRowSelectionModel {
+    type: 'include' | 'exclude';
+    ids: Set<MGHGridRowId>;
+}
+export type MGHGridRowSelectionModelInput = MGHGridRowSelectionModel | MGHGridRowId[] | Set<MGHGridRowId>;
+export type MGHGridRowGroupingModel = string[];
+export type MGHGridAggregationModel = Record<string, MGHGridAggregationFunctionName>;
+export interface MGHGridColumnDimensions {
+    width?: number;
+    flex?: number;
+}
+export interface MGHGridInitialState {
+    columns?: {
+        columnVisibilityModel?: MGHGridColumnVisibilityModel;
+        orderedFields?: string[];
+        dimensions?: Record<string, MGHGridColumnDimensions>;
+    };
+    sorting?: {
+        sortModel?: MGHGridSortModel;
+    };
+    filter?: {
+        filterModel?: MGHGridFilterModel;
+    };
+    pagination?: {
+        paginationModel?: Partial<MGHGridPaginationModel>;
+    };
+    pinnedColumns?: MGHGridPinnedColumns;
+    density?: MGHGridDensity;
+    rowGrouping?: {
+        model?: MGHGridRowGroupingModel;
+    };
+    aggregation?: {
+        model?: MGHGridAggregationModel;
+    };
+    detailPanel?: {
+        expandedRowIds?: MGHGridRowId[] | Set<MGHGridRowId>;
+    };
+}
+export interface MGHGridLeafNode {
+    type: 'leaf';
+    id: MGHGridRowId;
+    depth: number;
+    parent: MGHGridRowId | null;
+}
+export interface MGHGridGroupNode {
+    type: 'group';
+    id: MGHGridRowId;
+    depth: number;
+    parent: MGHGridRowId | null;
+    groupingField: string;
+    groupingKey: any;
+    groupingLabel: string;
+    children: MGHGridRowId[];
+    leafIds: MGHGridRowId[];
+    isExpanded: boolean;
+}
+export interface MGHGridPinnedRowNode {
+    type: 'pinnedRow';
+    id: MGHGridRowId;
+    depth: 0;
+    parent: null;
+    position: 'top' | 'bottom';
+}
+export interface MGHGridFooterNode {
+    type: 'footer';
+    id: MGHGridRowId;
+    depth: 0;
+    parent: null;
+}
+export type MGHGridRowNode = MGHGridLeafNode | MGHGridGroupNode | MGHGridPinnedRowNode | MGHGridFooterNode;
+export interface MGHGridCallbackDetails {
+    api: MGHGridApi<any>;
+    reason?: string;
+}
+export interface MGHGridCellParams<R extends MGHGridValidRowModel = any, V = any, F = V> {
+    id: MGHGridRowId;
+    field: string;
+    value: V;
+    formattedValue: F;
+    row: R;
+    rowNode: MGHGridRowNode;
+    colDef: MGHGridColDef<R, V, F>;
+    api: MGHGridApi<R>;
+    hasFocus: boolean;
+    tabIndex: 0 | -1;
+    cellMode: MGHGridCellMode;
+    isEditable: boolean;
+}
+export type MGHGridRenderCellParams<R extends MGHGridValidRowModel = any, V = any, F = V> = MGHGridCellParams<R, V, F>;
+export interface MGHGridRenderEditCellParams<R extends MGHGridValidRowModel = any, V = any, F = V> extends MGHGridCellParams<R, V, F> {
+    /** Current (uncommitted) editing value. */
+    editValue: any;
+    /** Update the editing value. */
+    onValueChange: (value: any) => void;
+    /** Commit the edit. */
+    commit: () => void;
+    /** Cancel the edit. */
+    cancel: () => void;
+}
+export interface MGHGridColumnHeaderParams<R extends MGHGridValidRowModel = any> {
+    field: string;
+    colDef: MGHGridColDef<R>;
+    api: MGHGridApi<R>;
+}
+export interface MGHGridRowParams<R extends MGHGridValidRowModel = any> {
+    id: MGHGridRowId;
+    row: R;
+    columns: MGHGridColDef<R>[];
+    api: MGHGridApi<R>;
+}
+export interface MGHGridRowClassNameParams<R extends MGHGridValidRowModel = any> extends MGHGridRowParams<R> {
+    indexRelativeToCurrentPage: number;
+    isFirstVisible: boolean;
+    isLastVisible: boolean;
+    rowNode: MGHGridRowNode;
+}
+export interface MGHGridRowHeightParams<R extends MGHGridValidRowModel = any> {
+    id: MGHGridRowId;
+    model: R;
+    densityFactor: number;
+}
+export type MGHGridRowHeightReturnValue = number | 'auto' | null | undefined;
+export interface MGHGridDetailPanelHeightParams<R extends MGHGridValidRowModel = any> {
+    id: MGHGridRowId;
+    row: R;
+}
+export interface MGHGridSortCellParams {
+    id: MGHGridRowId;
+    field: string;
+    value: any;
+    row: any;
+    api: MGHGridApi<any>;
+}
+export interface MGHGridColumnOrderChangeParams {
+    column: MGHGridColDef;
+    targetIndex: number;
+    oldIndex: number;
+}
+export interface MGHGridColumnResizeParams {
+    colDef: MGHGridColDef;
+    width: number;
+}
+export interface MGHGridRowEditStopParams<R extends MGHGridValidRowModel = any> {
+    id: MGHGridRowId;
+    field: string;
+    row: R;
+    reason: 'enterKeyDown' | 'escapeKeyDown' | 'cellFocusOut' | 'tabKeyDown' | 'api';
+}
+export interface MGHGridValueOptionObject {
+    value: any;
+    label: string;
+}
+export type MGHGridValueOption = string | number | MGHGridValueOptionObject;
+export interface MGHGridValueOptionsParams<R extends MGHGridValidRowModel = any> {
+    field: string;
+    id?: MGHGridRowId;
+    row?: R;
+}
+export type MGHGridFilterInputType = 'text' | 'number' | 'date' | 'datetime-local' | 'select' | 'multiselect' | 'boolean' | 'none';
+export interface MGHGridFilterInputProps {
+    item: MGHGridFilterItem;
+    column: MGHGridColDef;
+    applyValue: (item: MGHGridFilterItem) => void;
+    api: MGHGridApi;
+}
+export type MGHGridApplyFilterFn<R extends MGHGridValidRowModel = any, V = any> = (value: V, row: R, column: MGHGridColDef<R, V>, api: MGHGridApi<R>) => boolean;
+export interface MGHGridFilterOperator<R extends MGHGridValidRowModel = any, V = any> {
+    value: string;
+    label?: string;
+    headerLabel?: string;
+    /** Return null to skip the filter (e.g. empty value). */
+    getApplyFilterFn: (filterItem: MGHGridFilterItem, column: MGHGridColDef<R, V>) => MGHGridApplyFilterFn<R, V> | null;
+    /** Which input the filter panel should render for this operator. */
+    inputType?: MGHGridFilterInputType;
+    /** Custom input component for the filter panel. */
+    InputComponent?: React.ComponentType<MGHGridFilterInputProps>;
+    /** Defaults to true (except for isEmpty / isNotEmpty). */
+    requiresFilterValue?: boolean;
+}
+export type MGHGridValueGetter<R extends MGHGridValidRowModel = any, V = any> = (value: any, row: R, column: MGHGridColDef<R, V>, api: MGHGridApi<R>) => V;
+export type MGHGridValueFormatter<R extends MGHGridValidRowModel = any, V = any, F = V> = (value: V, row: R, column: MGHGridColDef<R, V, F>, api: MGHGridApi<R>) => F;
+export type MGHGridValueSetter<R extends MGHGridValidRowModel = any, V = any> = (value: V, row: R, column: MGHGridColDef<R, V>, api: MGHGridApi<R>) => R;
+export type MGHGridValueParser<R extends MGHGridValidRowModel = any, V = any> = (value: any, row: R | undefined, column: MGHGridColDef<R, V>, api: MGHGridApi<R>) => V;
+export type MGHGridComparatorFn<V = any> = (v1: V, v2: V, cellParams1: MGHGridSortCellParams, cellParams2: MGHGridSortCellParams) => number;
+export interface MGHGridColDef<R extends MGHGridValidRowModel = any, V = any, F = V> {
+    field: string;
+    headerName?: string;
+    description?: string;
+    type?: MGHGridColType;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    align?: MGHGridAlignment;
+    headerAlign?: MGHGridAlignment;
+    sortable?: boolean;
+    filterable?: boolean;
+    hideable?: boolean;
+    resizable?: boolean;
+    pinnable?: boolean;
+    groupable?: boolean;
+    aggregable?: boolean;
+    editable?: boolean;
+    disableColumnMenu?: boolean;
+    disableExport?: boolean;
+    disableReorder?: boolean;
+    sortingOrder?: MGHGridSortDirection[];
+    display?: 'text' | 'flex';
+    valueGetter?: MGHGridValueGetter<R, V>;
+    valueSetter?: MGHGridValueSetter<R, V>;
+    valueFormatter?: MGHGridValueFormatter<R, V, F>;
+    valueParser?: MGHGridValueParser<R, V>;
+    /** Used for row grouping instead of the cell value when provided. */
+    groupingValueGetter?: MGHGridValueGetter<R, any>;
+    renderCell?: (params: MGHGridRenderCellParams<R, V, F>) => React.ReactNode;
+    renderEditCell?: (params: MGHGridRenderEditCellParams<R, V, F>) => React.ReactNode;
+    renderHeader?: (params: MGHGridColumnHeaderParams<R>) => React.ReactNode;
+    sortComparator?: MGHGridComparatorFn<V>;
+    filterOperators?: MGHGridFilterOperator<R, V>[];
+    getApplyQuickFilterFn?: (value: any, column: MGHGridColDef<R, V, F>, api: MGHGridApi<R>) => MGHGridApplyFilterFn<R, V> | null;
+    valueOptions?: MGHGridValueOption[] | ((params: MGHGridValueOptionsParams<R>) => MGHGridValueOption[]);
+    getOptionLabel?: (option: MGHGridValueOption) => string;
+    getOptionValue?: (option: MGHGridValueOption) => any;
+    getActions?: (params: MGHGridRowParams<R>) => React.ReactElement[];
+    cellClassName?: string | ((params: MGHGridCellParams<R, V, F>) => string);
+    headerClassName?: string | ((params: MGHGridColumnHeaderParams<R>) => string);
+    availableAggregationFunctions?: string[];
+}
+export interface MGHGridGroupingColDefOverrides extends Partial<Omit<MGHGridColDef, 'field'>> {
+    /** Hide the descendant count shown next to each group label. */
+    hideDescendantCount?: boolean;
+}
+export interface MGHGridAggregationFunction {
+    /** Apply the aggregation to the list of values. */
+    apply: (params: {
+        values: any[];
+        field: string;
+    }) => any;
+    /** Label displayed under the aggregated value in the footer. */
+    label?: string;
+    /** Column types this function is available for (all if omitted). */
+    columnTypes?: MGHGridColType[];
+    /** Format the aggregated value with the column value formatter (default true). */
+    valueFormatter?: (value: any) => any;
+}
+export interface MGHGridExportOptions {
+    fileName?: string;
+    /** Export all columns, including hidden ones (default false). */
+    allColumns?: boolean;
+    /** Explicit list of fields to export (overrides allColumns / visibility). */
+    fields?: string[];
+    /** Include the header row (default true). */
+    includeHeaders?: boolean;
+    /** Return the ids of the rows to export. Defaults to the sorted & filtered rows. */
+    getRowsToExport?: (params: {
+        api: MGHGridApi;
+    }) => MGHGridRowId[];
+}
+export interface MGHGridCsvExportOptions extends MGHGridExportOptions {
+    delimiter?: string;
+    utf8WithBom?: boolean;
+    /** Use the raw cell value instead of the formatted value. */
+    useRawValues?: boolean;
+}
+export interface MGHGridExcelExportOptions extends MGHGridExportOptions {
+    sheetName?: string;
+    /** Column widths (in characters) keyed by field. */
+    columnsStyles?: Record<string, {
+        width?: number;
+    }>;
+}
+export interface MGHGridPrintExportOptions extends MGHGridExportOptions {
+    hideToolbar?: boolean;
+    hideFooter?: boolean;
+    /** Title printed above the table. Defaults to the grid header. */
+    title?: string;
+    /** Extra CSS injected in the print document. */
+    pageStyle?: string;
+}
+export type MGHGridPreferencePanelValue = 'columns' | 'filters';
+export interface MGHGridPreferencePanelState {
+    open: boolean;
+    openedPanelValue?: MGHGridPreferencePanelValue;
+    targetField?: string;
+}
+export interface MGHGridState {
+    sortModel: MGHGridSortModel;
+    filterModel: MGHGridFilterModel;
+    paginationModel: MGHGridPaginationModel;
+    pageCount: number;
+    /** Number of leaf rows after filtering. */
+    rowCount: number;
+    /** Total number of leaf rows before filtering. */
+    totalRowCount: number;
+    columnVisibilityModel: MGHGridColumnVisibilityModel;
+    orderedFields: string[];
+    columnWidths: Record<string, number>;
+    pinnedColumns: MGHGridPinnedColumns;
+    density: MGHGridDensity;
+    densityFactor: number;
+    rowSelectionModel: MGHGridRowSelectionModel;
+    rowGroupingModel: MGHGridRowGroupingModel;
+    aggregationModel: MGHGridAggregationModel;
+    expandedDetailPanels: Set<MGHGridRowId>;
+    preferencePanel: MGHGridPreferencePanelState;
+    filterCount: number;
+    quickFilterValues: any[];
+}
+export interface MGHGridApi<R extends MGHGridValidRowModel = any> {
+    getRow: (id: MGHGridRowId) => R | null;
+    getRowModels: () => Map<MGHGridRowId, R>;
+    getAllRowIds: () => MGHGridRowId[];
+    getRowNode: (id: MGHGridRowId) => MGHGridRowNode | null;
+    /** Leaf rows after filtering & sorting (all pages). */
+    getSortedRows: () => R[];
+    getSortedRowIds: () => MGHGridRowId[];
+    /** Rows displayed on the current page (leaf rows only). */
+    getVisibleRows: () => {
+        id: MGHGridRowId;
+        model: R;
+    }[];
+    getRowIndexRelativeToVisibleRows: (id: MGHGridRowId) => number;
+    updateRows: (updates: Partial<R>[]) => void;
+    getAllColumns: () => MGHGridColDef<R>[];
+    getVisibleColumns: () => MGHGridColDef<R>[];
+    getColumn: (field: string) => MGHGridColDef<R> | undefined;
+    getColumnIndex: (field: string, useVisibleColumns?: boolean) => number;
+    getColumnVisibilityModel: () => MGHGridColumnVisibilityModel;
+    setColumnVisibility: (field: string, isVisible: boolean) => void;
+    setColumnVisibilityModel: (model: MGHGridColumnVisibilityModel) => void;
+    setColumnWidth: (field: string, width: number) => void;
+    setColumnIndex: (field: string, targetIndex: number) => void;
+    autosizeColumns: (options?: {
+        columns?: string[];
+        includeHeaders?: boolean;
+        expand?: boolean;
+    }) => void;
+    pinColumn: (field: string, side: MGHGridPinnedSide) => void;
+    unpinColumn: (field: string) => void;
+    isColumnPinned: (field: string) => MGHGridPinnedSide | false;
+    getPinnedColumns: () => MGHGridPinnedColumns;
+    setPinnedColumns: (model: MGHGridPinnedColumns) => void;
+    getSortModel: () => MGHGridSortModel;
+    setSortModel: (model: MGHGridSortModel) => void;
+    sortColumn: (field: string, direction?: MGHGridSortDirection, allowMultipleSorting?: boolean) => void;
+    getFilterModel: () => MGHGridFilterModel;
+    setFilterModel: (model: MGHGridFilterModel) => void;
+    upsertFilterItem: (item: MGHGridFilterItem) => void;
+    upsertFilterItems: (items: MGHGridFilterItem[]) => void;
+    deleteFilterItem: (item: MGHGridFilterItem) => void;
+    setFilterLogicOperator: (operator: MGHGridLogicOperator) => void;
+    setQuickFilterValues: (values: any[]) => void;
+    showFilterPanel: (targetColumnField?: string, anchorEl?: HTMLElement | null) => void;
+    hideFilterPanel: () => void;
+    showPreferences: (panel: MGHGridPreferencePanelValue, anchorEl?: HTMLElement | null, targetField?: string) => void;
+    hidePreferences: () => void;
+    getSelectedRows: () => Map<MGHGridRowId, R>;
+    getRowSelectionModel: () => MGHGridRowSelectionModel;
+    setRowSelectionModel: (model: MGHGridRowSelectionModelInput) => void;
+    selectRow: (id: MGHGridRowId, isSelected?: boolean, resetSelection?: boolean) => void;
+    selectRows: (ids: MGHGridRowId[], isSelected?: boolean, resetSelection?: boolean) => void;
+    isRowSelected: (id: MGHGridRowId) => boolean;
+    isRowSelectable: (id: MGHGridRowId) => boolean;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    setPaginationModel: (model: MGHGridPaginationModel) => void;
+    setDensity: (density: MGHGridDensity) => void;
+    getDataAsCsv: (options?: MGHGridCsvExportOptions) => string;
+    exportDataAsCsv: (options?: MGHGridCsvExportOptions) => void;
+    exportDataAsExcel: (options?: MGHGridExcelExportOptions) => Promise<void>;
+    exportDataAsPrint: (options?: MGHGridPrintExportOptions) => void;
+    toggleDetailPanel: (id: MGHGridRowId) => void;
+    setExpandedDetailPanels: (ids: MGHGridRowId[]) => void;
+    getExpandedDetailPanels: () => MGHGridRowId[];
+    getRowGroupingModel: () => MGHGridRowGroupingModel;
+    setRowGroupingModel: (model: MGHGridRowGroupingModel) => void;
+    addRowGroupingCriteria: (field: string, groupingIndex?: number) => void;
+    removeRowGroupingCriteria: (field: string) => void;
+    setRowChildrenExpansion: (id: MGHGridRowId, isExpanded: boolean) => void;
+    getRowGroupChildren: (params: {
+        groupId: MGHGridRowId;
+    }) => MGHGridRowId[];
+    getAggregationModel: () => MGHGridAggregationModel;
+    setAggregationModel: (model: MGHGridAggregationModel) => void;
+    startCellEditMode: (params: {
+        id: MGHGridRowId;
+        field: string;
+    }) => void;
+    stopCellEditMode: (params: {
+        id: MGHGridRowId;
+        field: string;
+        ignoreModifications?: boolean;
+    }) => void;
+    getCellMode: (id: MGHGridRowId, field: string) => MGHGridCellMode;
+    setEditCellValue: (params: {
+        id: MGHGridRowId;
+        field: string;
+        value: any;
+    }) => void;
+    getCellValue: (id: MGHGridRowId, field: string) => any;
+    getCellParams: (id: MGHGridRowId, field: string) => MGHGridCellParams<R>;
+    setCellFocus: (id: MGHGridRowId, field: string) => void;
+    scrollToIndexes: (params: {
+        rowIndex?: number;
+        colIndex?: number;
+    }) => boolean;
+    scroll: (params: {
+        left?: number;
+        top?: number;
+    }) => void;
+    getScrollPosition: () => {
+        left: number;
+        top: number;
+    };
+    readonly state: MGHGridState;
+    forceUpdate: () => void;
+    rootElementRef: React.RefObject<HTMLDivElement | null>;
+}
+export interface MGHGridNoRowsOverlayProps {
+    text?: string;
+    /** Optional image rendered above the text. Defaults to an inline illustration. */
+    imageSrc?: string;
+    /** Compatibility with the legacy CustomNoRowsOverlay. */
+    useSettingsContext?: () => {
+        themeMode?: string;
+    };
+    themeMode?: MGHGridThemeMode;
+}
+export interface MGHGridLoadingOverlayProps {
+    text?: string;
+}
+export interface MGHGridToolbarProps {
+    showColumnsButton?: boolean;
+    showFilterButton?: boolean;
+    showExportButton?: boolean;
+    showQuickFilter?: boolean;
+    showDensitySelector?: boolean;
+    showCsvOption?: boolean;
+    showExcelOption?: boolean;
+    showPrintOption?: boolean;
+    csvOptions?: MGHGridCsvExportOptions;
+    excelOptions?: MGHGridExcelExportOptions;
+    printOptions?: MGHGridPrintExportOptions;
+    renderOtherButtons?: React.ReactNode;
+    renderDateRange?: React.ReactNode;
+    /** Extra items rendered at the top of the export menu. */
+    customMenuItem?: JSX.Element[] | JSX.Element;
+    /** Placeholder for the quick filter input. */
+    quickFilterPlaceholder?: string;
+    /** Debounce (ms) for the quick filter. */
+    quickFilterDebounceMs?: number;
+    /** Escape hatch for consumer-specific toolbar props (ignored by the default toolbar). */
+    [key: string]: any;
+}
+export interface MGHGridFooterProps {
+    /** Provided by the grid. */
+    api?: MGHGridApi;
+}
+export interface MGHGridSlots {
+    toolbar?: React.ComponentType<any> | null;
+    noRowsOverlay?: React.ComponentType<any>;
+    loadingOverlay?: React.ComponentType<any>;
+    footer?: React.ComponentType<any> | null;
+}
+export interface MGHGridSlotProps {
+    toolbar?: MGHGridToolbarProps & Record<string, any>;
+    noRowsOverlay?: MGHGridNoRowsOverlayProps & Record<string, any>;
+    loadingOverlay?: MGHGridLoadingOverlayProps & Record<string, any>;
+    footer?: Record<string, any>;
+}
+export interface MGHGridLocaleText {
+    noRowsLabel: string;
+    loadingLabel: string;
+    toolbarColumns: string;
+    toolbarFilters: string;
+    toolbarExport: string;
+    toolbarDensity: string;
+    toolbarQuickFilterPlaceholder: string;
+    toolbarQuickFilterLabel: string;
+    toolbarExportCSV: string;
+    toolbarExportExcel: string;
+    toolbarExportPrint: string;
+    densityCompact: string;
+    densityStandard: string;
+    densityComfortable: string;
+    columnsPanelSearchPlaceholder: string;
+    columnsPanelShowAll: string;
+    columnsPanelHideAll: string;
+    columnsPanelReset: string;
+    filterPanelAddFilter: string;
+    filterPanelRemoveAll: string;
+    filterPanelDeleteIcon: string;
+    filterPanelColumns: string;
+    filterPanelOperator: string;
+    filterPanelValue: string;
+    filterPanelInputPlaceholder: string;
+    filterPanelLogicOperator: string;
+    filterPanelOperatorAnd: string;
+    filterPanelOperatorOr: string;
+    columnMenuSortAsc: string;
+    columnMenuSortDesc: string;
+    columnMenuUnsort: string;
+    columnMenuFilter: string;
+    columnMenuHideColumn: string;
+    columnMenuManageColumns: string;
+    columnMenuPinLeft: string;
+    columnMenuPinRight: string;
+    columnMenuUnpin: string;
+    columnMenuGroup: (name: string) => string;
+    columnMenuUngroup: (name: string) => string;
+    columnMenuAggregation: string;
+    aggregationMenuItemHeader: string;
+    aggregationFunctionLabelNone: string;
+    aggregationFunctionLabelSum: string;
+    aggregationFunctionLabelAvg: string;
+    aggregationFunctionLabelMin: string;
+    aggregationFunctionLabelMax: string;
+    aggregationFunctionLabelSize: string;
+    footerRowSelected: (count: number) => string;
+    footerTotalRows: string;
+    footerPaginationRowsPerPage: string;
+    footerPaginationDisplayedRows: (from: number, to: number, count: number) => string;
+    footerPaginationFirstPage: string;
+    footerPaginationPreviousPage: string;
+    footerPaginationNextPage: string;
+    footerPaginationLastPage: string;
+    checkboxSelectionHeaderName: string;
+    checkboxSelectionSelectAllRows: string;
+    checkboxSelectionUnselectAllRows: string;
+    checkboxSelectionSelectRow: string;
+    checkboxSelectionUnselectRow: string;
+    booleanCellTrueLabel: string;
+    booleanCellFalseLabel: string;
+    detailPanelToggle: string;
+    expandDetailPanel: string;
+    collapseDetailPanel: string;
+    groupingColumnHeaderName: string;
+    groupColumn: (name: string) => string;
+    unGroupColumn: (name: string) => string;
+    actionsCellMore: string;
+    columnHeaderSortIconLabel: string;
+    columnMenuLabel: string;
+    clearSearch: string;
+}
+export type MGHGridRowEventHandler<R extends MGHGridValidRowModel = any> = (params: MGHGridRowParams<R>, event: React.MouseEvent<HTMLElement>, details: MGHGridCallbackDetails) => void;
+export type MGHGridCellEventHandler<R extends MGHGridValidRowModel = any> = (params: MGHGridCellParams<R>, event: React.MouseEvent<HTMLElement>, details: MGHGridCallbackDetails) => void;
+export interface MGHGridProps<R extends MGHGridValidRowModel = any> {
+    rows: R[];
+    columns: MGHGridColDef<R>[];
+    getRowId?: (row: R) => MGHGridRowId;
+    loading?: boolean;
+    header?: React.ReactNode;
+    renderHeaderEndContent?: React.ReactNode;
+    renderHeaderCenterContent?: React.ReactNode;
+    /** Render the grid without the surrounding card & header. */
+    disableCard?: boolean;
+    className?: string;
+    cardClassName?: string;
+    boxClassName?: string;
+    /** Inline style for the outer card. (`cardSx` is accepted as an alias for legacy code.) */
+    cardStyle?: React.CSSProperties;
+    cardSx?: React.CSSProperties;
+    /** Inline style for the box wrapping the grid. (`boxSx` is accepted as an alias for legacy code.) */
+    boxStyle?: React.CSSProperties;
+    boxSx?: React.CSSProperties;
+    /** Inline style for the grid root. (`sx` is accepted as an alias for legacy code.) */
+    style?: React.CSSProperties;
+    sx?: React.CSSProperties;
+    /** 'light' (default) or 'dark'. */
+    themeMode?: MGHGridThemeMode;
+    /** Override any `--mgh-grid-*` CSS variable. */
+    themeVars?: Record<string, string>;
+    showToolbar?: boolean;
+    toolbarProps?: MGHGridToolbarProps & Record<string, any>;
+    slots?: MGHGridSlots;
+    slotProps?: MGHGridSlotProps;
+    noRowsText?: string;
+    localeText?: Partial<MGHGridLocaleText>;
+    rowHeight?: number;
+    columnHeaderHeight?: number;
+    getRowHeight?: (params: MGHGridRowHeightParams<R>) => MGHGridRowHeightReturnValue;
+    autoHeight?: boolean;
+    disableVirtualization?: boolean;
+    density?: MGHGridDensity;
+    onDensityChange?: (density: MGHGridDensity, details: MGHGridCallbackDetails) => void;
+    disableDensitySelector?: boolean;
+    pagination?: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    paginationModel?: MGHGridPaginationModel;
+    onPaginationModelChange?: (model: MGHGridPaginationModel, details: MGHGridCallbackDetails) => void;
+    hideFooter?: boolean;
+    hideFooterPagination?: boolean;
+    hideFooterRowCount?: boolean;
+    hideFooterSelectedRowCount?: boolean;
+    sortModel?: MGHGridSortModel;
+    onSortModelChange?: (model: MGHGridSortModel, details: MGHGridCallbackDetails) => void;
+    sortingOrder?: MGHGridSortDirection[];
+    disableMultipleColumnsSorting?: boolean;
+    disableColumnSorting?: boolean;
+    filterModel?: MGHGridFilterModel;
+    onFilterModelChange?: (model: MGHGridFilterModel, details: MGHGridCallbackDetails) => void;
+    disableColumnFilter?: boolean;
+    disableMultipleColumnsFiltering?: boolean;
+    /** Debounce (ms) applied to the quick filter. Default 150. */
+    quickFilterDebounceMs?: number;
+    columnVisibilityModel?: MGHGridColumnVisibilityModel;
+    onColumnVisibilityModelChange?: (model: MGHGridColumnVisibilityModel, details: MGHGridCallbackDetails) => void;
+    columnVisibilityStorageKey?: string;
+    columnOrderStorageKey?: string;
+    columnWidthStorageKey?: string;
+    pinnedColumnsStorageKey?: string;
+    onColumnOrderChange?: (params: MGHGridColumnOrderChangeParams, event: React.DragEvent | null, details: MGHGridCallbackDetails) => void;
+    onColumnWidthChange?: (params: MGHGridColumnResizeParams, details: MGHGridCallbackDetails) => void;
+    disableColumnMenu?: boolean;
+    disableColumnSelector?: boolean;
+    disableColumnResize?: boolean;
+    disableColumnReorder?: boolean;
+    disableColumnPinning?: boolean;
+    pinnedColumns?: MGHGridPinnedColumns;
+    onPinnedColumnsChange?: (model: MGHGridPinnedColumns, details: MGHGridCallbackDetails) => void;
+    checkboxSelection?: boolean;
+    checkboxSelectionVisibleOnly?: boolean;
+    disableRowSelectionOnClick?: boolean;
+    disableMultipleRowSelection?: boolean;
+    rowSelectionModel?: MGHGridRowSelectionModelInput;
+    onRowSelectionModelChange?: (model: MGHGridRowSelectionModel, details: MGHGridCallbackDetails) => void;
+    isRowSelectable?: (params: MGHGridRowParams<R>) => boolean;
+    keepNonExistentRowsSelected?: boolean;
+    getRowClassName?: (params: MGHGridRowClassNameParams<R>) => string;
+    onRowClick?: MGHGridRowEventHandler<R>;
+    onRowDoubleClick?: MGHGridRowEventHandler<R>;
+    onCellClick?: MGHGridCellEventHandler<R>;
+    onCellDoubleClick?: MGHGridCellEventHandler<R>;
+    pinnedRows?: MGHGridPinnedRows<R>;
+    getDetailPanelContent?: (params: MGHGridRowParams<R>) => React.ReactNode;
+    getDetailPanelHeight?: (params: MGHGridDetailPanelHeightParams<R>) => number | 'auto';
+    detailPanelExpandedRowIds?: MGHGridRowId[] | Set<MGHGridRowId>;
+    onDetailPanelExpandedRowIdsChange?: (ids: MGHGridRowId[], details: MGHGridCallbackDetails) => void;
+    rowGroupingModel?: MGHGridRowGroupingModel;
+    onRowGroupingModelChange?: (model: MGHGridRowGroupingModel, details: MGHGridCallbackDetails) => void;
+    defaultGroupingExpansionDepth?: number;
+    groupingColDef?: MGHGridGroupingColDefOverrides;
+    disableRowGrouping?: boolean;
+    isGroupExpandedByDefault?: (node: MGHGridGroupNode) => boolean;
+    aggregationModel?: MGHGridAggregationModel;
+    onAggregationModelChange?: (model: MGHGridAggregationModel, details: MGHGridCallbackDetails) => void;
+    aggregationFunctions?: Record<string, MGHGridAggregationFunction>;
+    disableAggregation?: boolean;
+    /** Where to show aggregated values: in the footer, on group rows, or both (default 'both'). */
+    aggregationPosition?: 'footer' | 'inline' | 'both';
+    processRowUpdate?: (newRow: R, oldRow: R, params: {
+        rowId: MGHGridRowId;
+    }) => R | Promise<R>;
+    onProcessRowUpdateError?: (error: any) => void;
+    onCellEditStop?: (params: MGHGridRowEditStopParams<R>, details: MGHGridCallbackDetails) => void;
+    isCellEditable?: (params: MGHGridCellParams<R>) => boolean;
+    initialState?: MGHGridInitialState;
+    apiRef?: React.MutableRefObject<MGHGridApi<R> | null>;
+    onStateChange?: (state: MGHGridState, details: MGHGridCallbackDetails) => void;
+    /** Any legacy / unknown props are accepted and ignored so migration is painless. */
+    [legacyProp: string]: any;
+}