@mui/x-data-grid 5.3.0 → 5.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/x-data-grid.d.ts CHANGED
@@ -17,13 +17,11 @@ import { InternalStandardProps } from '@mui/material';
17
17
  import { TextFieldProps } from '@mui/material/TextField';
18
18
  import { ButtonProps } from '@mui/material/Button';
19
19
  import { TooltipProps } from '@mui/material/Tooltip';
20
- import * as reselect from 'reselect';
21
20
 
22
21
  interface GridBodyProps {
23
22
  children?: React$1.ReactNode;
24
23
  VirtualScrollerComponent: React$1.JSXElementConstructor<React$1.HTMLAttributes<HTMLDivElement> & {
25
24
  ref: React$1.Ref<HTMLDivElement>;
26
- selectionLookup: {};
27
25
  disableVirtualization: boolean;
28
26
  }>;
29
27
  ColumnHeadersComponent: React$1.JSXElementConstructor<React$1.HTMLAttributes<HTMLDivElement> & {
@@ -208,6 +206,7 @@ declare function checkGridRowIdIsValid(id: GridRowId, row: GridRowModel | Partia
208
206
 
209
207
  interface GridEditCellProps {
210
208
  value: GridCellValue;
209
+ isValidating?: boolean;
211
210
  [prop: string]: any;
212
211
  }
213
212
  declare type GridEditRowProps = {
@@ -291,7 +290,20 @@ interface GridRowParams<R extends GridRowModel = GridRowModel> {
291
290
  * @deprecated Use `params.row` to directly access the fields you want instead.
292
291
  */
293
292
  getValue: (id: GridRowId, field: string) => GridCellValue;
294
- }
293
+ }
294
+ /**
295
+ * Object passed as parameter in the row getRowHeight callback.
296
+ */
297
+ interface GridRowHeightParams extends GridRowEntry {
298
+ /**
299
+ * The grid current density factor.
300
+ */
301
+ densityFactor: number;
302
+ }
303
+ /**
304
+ * The getRowHeight return value.
305
+ */
306
+ declare type GridRowHeightReturnValue = number | null | undefined;
295
307
 
296
308
  interface GridParamsApi {
297
309
  /**
@@ -826,306 +838,24 @@ interface GridColumnMenuState {
826
838
  field?: string;
827
839
  }
828
840
 
829
- declare const gridColumnMenuSelector: (state: GridState) => GridColumnMenuState;
830
-
831
- interface GridColumnResizeState {
832
- resizingColumnField: string;
841
+ interface OutputSelector<Result> {
842
+ (stateOrApiRef: GridApiRef | GridState): Result;
843
+ cache: object;
833
844
  }
834
845
 
835
- declare const gridColumnResizeSelector: (state: GridState) => GridColumnResizeState;
836
- declare const gridResizingColumnFieldSelector: ((state: {
837
- rows: GridRowsState;
838
- editRows: GridEditRowsModel;
839
- pagination: GridPaginationState;
840
- columns: GridColumnsState;
841
- columnReorder: GridColumnReorderState;
842
- columnResize: GridColumnResizeState;
843
- columnMenu: GridColumnMenuState;
844
- sorting: GridSortingState;
845
- focus: GridFocusState;
846
- tabIndex: GridTabIndexState;
847
- selection: GridSelectionModel;
848
- filter: GridFilterState;
849
- preferencePanel: GridPreferencePanelState;
850
- density: GridDensityState;
851
- rowGrouping: GridRowGroupingState;
852
- error?: any;
853
- pinnedColumns: GridPinnedColumns;
854
- }) => string) & reselect.OutputSelectorFields<(args_0: GridColumnResizeState) => string & {
855
- clearCache: () => void;
856
- }> & {
857
- clearCache: () => void;
858
- };
859
-
860
- declare const gridPinnedColumnsSelector: (state: GridState) => GridPinnedColumns;
861
-
862
- interface GridPinnedColumns {
863
- left?: string[];
864
- right?: string[];
865
- }
866
- declare enum GridPinnedPosition {
867
- left = "left",
868
- right = "right"
846
+ interface GridColumnReorderState {
847
+ dragCol: string;
869
848
  }
870
- /**
871
- * The column pinning API interface that is available in the grid [[apiRef]].
872
- */
873
- interface GridColumnPinningApi {
874
- /**
875
- * Pins a column to the left or right side of the grid.
876
- * @param {string} field The column field to pin.
877
- * @param {GridPinnedPosition} side Which side to pin the column.
878
- */
879
- pinColumn: (field: string, side: GridPinnedPosition) => void;
880
- /**
881
- * Unpins a column.
882
- * @param {string} field The column field to unpin.
883
- */
884
- unpinColumn: (field: string) => void;
885
- /**
886
- * Returns which columns are pinned.
887
- * @returns {GridPinnedColumns} An object containing the pinned columns.
888
- */
889
- getPinnedColumns: () => GridPinnedColumns;
890
- /**
891
- * Changes the pinned columns.
892
- * @param {GridPinnedColumns} pinnedColumns An object containing the columns to pin.
893
- */
894
- setPinnedColumns: (pinnedColumns: GridPinnedColumns) => void;
895
- /**
896
- * Returns which side a column is pinned to.
897
- * @param {string} field The column field to check.
898
- * @returns {string | false} Which side the column is pinned or `false` if not pinned.
899
- */
900
- isColumnPinned: (field: string) => GridPinnedPosition | false;
849
+ interface GridCanBeReorderedPreProcessingContext {
850
+ targetIndex: number;
901
851
  }
902
852
 
903
- declare type GridColumnPinningState = GridPinnedColumns;
904
-
905
- declare const gridColumnsSelector: (state: GridState) => GridColumnsState;
906
- declare const allGridColumnsFieldsSelector: (state: GridState) => string[];
907
- declare const gridColumnLookupSelector: (state: GridState) => GridColumnLookup;
908
- declare const allGridColumnsSelector: ((state: {
909
- rows: GridRowsState;
910
- editRows: GridEditRowsModel;
911
- pagination: GridPaginationState;
912
- columns: GridColumnsState;
913
- columnReorder: GridColumnReorderState;
914
- columnResize: GridColumnResizeState;
915
- columnMenu: GridColumnMenuState;
916
- sorting: GridSortingState;
917
- focus: GridFocusState;
918
- tabIndex: GridTabIndexState;
919
- selection: GridSelectionModel;
920
- filter: GridFilterState;
921
- preferencePanel: GridPreferencePanelState;
922
- density: GridDensityState;
923
- rowGrouping: GridRowGroupingState;
924
- error?: any;
925
- pinnedColumns: GridPinnedColumns;
926
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: string[], args_1: GridColumnLookup) => GridStateColDef[] & {
927
- clearCache: () => void;
928
- }> & {
929
- clearCache: () => void;
930
- };
931
- declare const gridColumnVisibilityModelSelector: ((state: {
932
- rows: GridRowsState;
933
- editRows: GridEditRowsModel;
934
- pagination: GridPaginationState;
935
- columns: GridColumnsState;
936
- columnReorder: GridColumnReorderState;
937
- columnResize: GridColumnResizeState;
938
- columnMenu: GridColumnMenuState;
939
- sorting: GridSortingState;
940
- focus: GridFocusState;
941
- tabIndex: GridTabIndexState;
942
- selection: GridSelectionModel;
943
- filter: GridFilterState;
944
- preferencePanel: GridPreferencePanelState;
945
- density: GridDensityState;
946
- rowGrouping: GridRowGroupingState;
947
- error?: any;
948
- pinnedColumns: GridPinnedColumns;
949
- }) => GridColumnVisibilityModel) & reselect.OutputSelectorFields<(args_0: GridColumnsState) => GridColumnVisibilityModel & {
950
- clearCache: () => void;
951
- }> & {
952
- clearCache: () => void;
953
- };
954
- declare const visibleGridColumnsSelector: ((state: {
955
- rows: GridRowsState;
956
- editRows: GridEditRowsModel;
957
- pagination: GridPaginationState;
958
- columns: GridColumnsState;
959
- columnReorder: GridColumnReorderState;
960
- columnResize: GridColumnResizeState;
961
- columnMenu: GridColumnMenuState;
962
- sorting: GridSortingState;
963
- focus: GridFocusState;
964
- tabIndex: GridTabIndexState;
965
- selection: GridSelectionModel;
966
- filter: GridFilterState;
967
- preferencePanel: GridPreferencePanelState;
968
- density: GridDensityState;
969
- rowGrouping: GridRowGroupingState;
970
- error?: any;
971
- pinnedColumns: GridPinnedColumns;
972
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[], args_1: GridColumnVisibilityModel) => GridStateColDef[] & {
973
- clearCache: () => void;
974
- }> & {
975
- clearCache: () => void;
976
- };
977
- declare const gridVisibleColumnFieldsSelector: ((state: {
978
- rows: GridRowsState;
979
- editRows: GridEditRowsModel;
980
- pagination: GridPaginationState;
981
- columns: GridColumnsState;
982
- columnReorder: GridColumnReorderState;
983
- columnResize: GridColumnResizeState;
984
- columnMenu: GridColumnMenuState;
985
- sorting: GridSortingState;
986
- focus: GridFocusState;
987
- tabIndex: GridTabIndexState;
988
- selection: GridSelectionModel;
989
- filter: GridFilterState;
990
- preferencePanel: GridPreferencePanelState;
991
- density: GridDensityState;
992
- rowGrouping: GridRowGroupingState;
993
- error?: any;
994
- pinnedColumns: GridPinnedColumns;
995
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => string[] & {
996
- clearCache: () => void;
997
- }> & {
998
- clearCache: () => void;
999
- };
1000
- declare const gridColumnsMetaSelector: ((state: {
1001
- rows: GridRowsState;
1002
- editRows: GridEditRowsModel;
1003
- pagination: GridPaginationState;
1004
- columns: GridColumnsState;
1005
- columnReorder: GridColumnReorderState;
1006
- columnResize: GridColumnResizeState;
1007
- columnMenu: GridColumnMenuState;
1008
- sorting: GridSortingState;
1009
- focus: GridFocusState;
1010
- tabIndex: GridTabIndexState;
1011
- selection: GridSelectionModel;
1012
- filter: GridFilterState;
1013
- preferencePanel: GridPreferencePanelState;
1014
- density: GridDensityState;
1015
- rowGrouping: GridRowGroupingState;
1016
- error?: any;
1017
- pinnedColumns: GridPinnedColumns;
1018
- }) => {
1019
- totalWidth: number;
1020
- positions: number[];
1021
- }) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => {
1022
- totalWidth: number;
1023
- positions: number[];
1024
- } & {
1025
- clearCache: () => void;
1026
- }> & {
1027
- clearCache: () => void;
1028
- };
1029
- declare const filterableGridColumnsSelector: ((state: {
1030
- rows: GridRowsState;
1031
- editRows: GridEditRowsModel;
1032
- pagination: GridPaginationState;
1033
- columns: GridColumnsState;
1034
- columnReorder: GridColumnReorderState;
1035
- columnResize: GridColumnResizeState;
1036
- columnMenu: GridColumnMenuState;
1037
- sorting: GridSortingState;
1038
- focus: GridFocusState;
1039
- tabIndex: GridTabIndexState;
1040
- selection: GridSelectionModel;
1041
- filter: GridFilterState;
1042
- preferencePanel: GridPreferencePanelState;
1043
- density: GridDensityState;
1044
- rowGrouping: GridRowGroupingState;
1045
- error?: any;
1046
- pinnedColumns: GridPinnedColumns;
1047
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => GridStateColDef[] & {
1048
- clearCache: () => void;
1049
- }> & {
1050
- clearCache: () => void;
1051
- };
1052
- declare const filterableGridColumnsIdsSelector: ((state: {
1053
- rows: GridRowsState;
1054
- editRows: GridEditRowsModel;
1055
- pagination: GridPaginationState;
1056
- columns: GridColumnsState;
1057
- columnReorder: GridColumnReorderState;
1058
- columnResize: GridColumnResizeState;
1059
- columnMenu: GridColumnMenuState;
1060
- sorting: GridSortingState;
1061
- focus: GridFocusState;
1062
- tabIndex: GridTabIndexState;
1063
- selection: GridSelectionModel;
1064
- filter: GridFilterState;
1065
- preferencePanel: GridPreferencePanelState;
1066
- density: GridDensityState;
1067
- rowGrouping: GridRowGroupingState;
1068
- error?: any;
1069
- pinnedColumns: GridPinnedColumns;
1070
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => string[] & {
1071
- clearCache: () => void;
1072
- }> & {
1073
- clearCache: () => void;
1074
- };
1075
- declare const visibleGridColumnsLengthSelector: ((state: {
1076
- rows: GridRowsState;
1077
- editRows: GridEditRowsModel;
1078
- pagination: GridPaginationState;
1079
- columns: GridColumnsState;
1080
- columnReorder: GridColumnReorderState;
1081
- columnResize: GridColumnResizeState;
1082
- columnMenu: GridColumnMenuState;
1083
- sorting: GridSortingState;
1084
- focus: GridFocusState;
1085
- tabIndex: GridTabIndexState;
1086
- selection: GridSelectionModel;
1087
- filter: GridFilterState;
1088
- preferencePanel: GridPreferencePanelState;
1089
- density: GridDensityState;
1090
- rowGrouping: GridRowGroupingState;
1091
- error?: any;
1092
- pinnedColumns: GridPinnedColumns;
1093
- }) => number) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => number & {
1094
- clearCache: () => void;
1095
- }> & {
1096
- clearCache: () => void;
1097
- };
1098
- declare const gridColumnsTotalWidthSelector: ((state: {
1099
- rows: GridRowsState;
1100
- editRows: GridEditRowsModel;
1101
- pagination: GridPaginationState;
1102
- columns: GridColumnsState;
1103
- columnReorder: GridColumnReorderState;
1104
- columnResize: GridColumnResizeState;
1105
- columnMenu: GridColumnMenuState;
1106
- sorting: GridSortingState;
1107
- focus: GridFocusState;
1108
- tabIndex: GridTabIndexState;
1109
- selection: GridSelectionModel;
1110
- filter: GridFilterState;
1111
- preferencePanel: GridPreferencePanelState;
1112
- density: GridDensityState;
1113
- rowGrouping: GridRowGroupingState;
1114
- error?: any;
1115
- pinnedColumns: GridPinnedColumns;
1116
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1117
- totalWidth: number;
1118
- positions: number[];
1119
- }) => number & {
1120
- clearCache: () => void;
1121
- }> & {
1122
- clearCache: () => void;
1123
- };
853
+ declare const gridColumnReorderSelector: (state: GridState) => GridColumnReorderState;
854
+ declare const gridColumnReorderDragColSelector: OutputSelector<string>;
1124
855
 
1125
- /**
1126
- * @deprecated Should have been internal only, you can inline the logic.
1127
- */
1128
- declare const getGridColDef: (columnTypes: GridColumnTypesRecord, type: GridColType | undefined) => GridColTypeDef;
856
+ interface GridColumnResizeState {
857
+ resizingColumnField: string;
858
+ }
1129
859
 
1130
860
  /**
1131
861
  * Available densities.
@@ -1144,80 +874,182 @@ interface GridDensityState {
1144
874
  value: GridDensity;
1145
875
  rowHeight: number;
1146
876
  headerHeight: number;
877
+ factor: number;
1147
878
  }
1148
879
 
1149
- declare const gridDensitySelector: (state: GridState) => GridDensityState;
1150
- declare const gridDensityValueSelector: ((state: {
1151
- rows: GridRowsState;
1152
- editRows: GridEditRowsModel;
1153
- pagination: GridPaginationState;
1154
- columns: GridColumnsState;
1155
- columnReorder: GridColumnReorderState;
1156
- columnResize: GridColumnResizeState;
1157
- columnMenu: GridColumnMenuState;
1158
- sorting: GridSortingState;
1159
- focus: GridFocusState;
1160
- tabIndex: GridTabIndexState;
1161
- selection: GridSelectionModel;
1162
- filter: GridFilterState;
1163
- preferencePanel: GridPreferencePanelState;
1164
- density: GridDensityState;
1165
- rowGrouping: GridRowGroupingState;
1166
- error?: any;
1167
- pinnedColumns: GridPinnedColumns;
1168
- }) => GridDensity) & reselect.OutputSelectorFields<(args_0: GridDensityState) => GridDensity & {
1169
- clearCache: () => void;
1170
- }> & {
1171
- clearCache: () => void;
880
+ declare type GridCellIdentifier = {
881
+ id: GridRowId;
882
+ field: string;
1172
883
  };
1173
- declare const gridDensityRowHeightSelector: ((state: {
1174
- rows: GridRowsState;
1175
- editRows: GridEditRowsModel;
1176
- pagination: GridPaginationState;
1177
- columns: GridColumnsState;
1178
- columnReorder: GridColumnReorderState;
1179
- columnResize: GridColumnResizeState;
1180
- columnMenu: GridColumnMenuState;
1181
- sorting: GridSortingState;
1182
- focus: GridFocusState;
1183
- tabIndex: GridTabIndexState;
1184
- selection: GridSelectionModel;
1185
- filter: GridFilterState;
1186
- preferencePanel: GridPreferencePanelState;
1187
- density: GridDensityState;
1188
- rowGrouping: GridRowGroupingState;
1189
- error?: any;
1190
- pinnedColumns: GridPinnedColumns;
1191
- }) => number) & reselect.OutputSelectorFields<(args_0: GridDensityState) => number & {
1192
- clearCache: () => void;
1193
- }> & {
1194
- clearCache: () => void;
884
+ declare type GridColumnIdentifier = {
885
+ field: string;
1195
886
  };
1196
- declare const gridDensityHeaderHeightSelector: ((state: {
1197
- rows: GridRowsState;
1198
- editRows: GridEditRowsModel;
1199
- pagination: GridPaginationState;
1200
- columns: GridColumnsState;
1201
- columnReorder: GridColumnReorderState;
1202
- columnResize: GridColumnResizeState;
1203
- columnMenu: GridColumnMenuState;
1204
- sorting: GridSortingState;
1205
- focus: GridFocusState;
1206
- tabIndex: GridTabIndexState;
1207
- selection: GridSelectionModel;
1208
- filter: GridFilterState;
1209
- preferencePanel: GridPreferencePanelState;
1210
- density: GridDensityState;
1211
- rowGrouping: GridRowGroupingState;
1212
- error?: any;
1213
- pinnedColumns: GridPinnedColumns;
1214
- }) => number) & reselect.OutputSelectorFields<(args_0: GridDensityState) => number & {
1215
- clearCache: () => void;
1216
- }> & {
1217
- clearCache: () => void;
887
+ interface GridFocusState {
888
+ cell: GridCellIdentifier | null;
889
+ columnHeader: GridColumnIdentifier | null;
890
+ }
891
+ interface GridTabIndexState {
892
+ cell: GridCellIdentifier | null;
893
+ columnHeader: GridColumnIdentifier | null;
894
+ }
895
+
896
+ declare enum GridPreferencePanelsValue {
897
+ filters = "filters",
898
+ columns = "columns"
899
+ }
900
+
901
+ interface GridPreferencePanelState {
902
+ open: boolean;
903
+ openedPanelValue?: GridPreferencePanelsValue;
904
+ }
905
+ declare type GridPreferencePanelInitialState = GridPreferencePanelState;
906
+
907
+ interface GridRowGroupParams {
908
+ ids: GridRowId[];
909
+ idRowsLookup: GridRowsLookup;
910
+ previousTree: GridRowTreeConfig | null;
911
+ }
912
+ interface GridRowGroupingResult {
913
+ /**
914
+ * Name of the algorithm used to group the rows
915
+ * It is useful to decide which filtering / sorting algorithm to apply, to avoid applying tree-data filtering on a grouping-by-column dataset for instance.
916
+ */
917
+ groupingName: string;
918
+ tree: GridRowTreeConfig;
919
+ treeDepth: number;
920
+ ids: GridRowId[];
921
+ idRowsLookup: GridRowsLookup;
922
+ }
923
+ declare type GridRowGroupingPreProcessing = (params: GridRowGroupParams) => GridRowGroupingResult | null;
924
+ interface GridRowGroupsPreProcessingApi {
925
+ /**
926
+ * Register a column pre-processing and emit an event to re-apply the row grouping pre-processing.
927
+ * @param {string} processingName Name of the pre-processing. Used to clean the previous version of the pre-processing.
928
+ * @param {GridRowGroupingPreProcessing} columnsPreProcessing Pre-processing to register.
929
+ * @ignore - do not document.
930
+ */
931
+ unstable_registerRowGroupsBuilder: (processingName: string, groupingFunction: GridRowGroupingPreProcessing | null) => void;
932
+ /**
933
+ * Apply the first row grouping pre-processing that does not return null.
934
+ * @param {GridRowsLookup} rowsLookup. Lookup of the rows to group.
935
+ * @param {GridRowId[]} List of the rows IDs.
936
+ * @returns {GridRowGroupingResult} The grouped rows.
937
+ * @ignore - do not document.
938
+ */
939
+ unstable_groupRows: (params: GridRowGroupParams) => GridRowGroupingResult;
940
+ }
941
+
942
+ interface GridRowsState extends GridRowGroupingResult {
943
+ /**
944
+ * Amount of rows before applying the filtering.
945
+ * It also count the expanded and collapsed children rows.
946
+ */
947
+ totalRowCount: number;
948
+ /**
949
+ * Amount of rows before applying the filtering.
950
+ * It does not count the expanded children rows.
951
+ */
952
+ totalTopLevelRowCount: number;
953
+ }
954
+
955
+ declare type GridInputSelectionModel = GridRowId[] | GridRowId;
956
+ declare type GridSelectionModel = GridRowId[];
957
+
958
+ interface GridSortingState {
959
+ sortedRows: GridRowId[];
960
+ sortModel: GridSortModel;
961
+ }
962
+ interface GridSortingInitialState {
963
+ sortModel?: GridSortModel;
964
+ }
965
+ declare type GridSortingModelApplier = (rowList: GridRowTreeNodeConfig[]) => GridRowId[];
966
+ interface GridSortingParams {
967
+ sortRowList: GridSortingModelApplier | null;
968
+ }
969
+ declare type GridSortingMethod = (params: GridSortingParams) => GridRowId[];
970
+ declare type GridSortingMethodCollection = {
971
+ [methodName: string]: GridSortingMethod;
1218
972
  };
1219
973
 
1220
- declare const gridEditRowsStateSelector: (state: GridState) => GridEditRowsModel;
974
+ interface GridPaginationState {
975
+ pageSize: number;
976
+ page: number;
977
+ pageCount: number;
978
+ rowCount: number;
979
+ }
980
+ interface GridPaginationInitialState {
981
+ pageSize?: number;
982
+ page?: number;
983
+ }
984
+ /**
985
+ * The apiRef methods handled by `useGridPageSize`
986
+ */
987
+ interface GridPageSizeApi {
988
+ /**
989
+ * Sets the number of displayed rows to the value given by `pageSize`.
990
+ * @param {number} pageSize The new number of displayed rows.
991
+ */
992
+ setPageSize: (pageSize: number) => void;
993
+ }
994
+ /**
995
+ * The apiRef methods handled by `useGridPage`
996
+ */
997
+ interface GridPageApi {
998
+ /**
999
+ * Sets the displayed page to the value given by `page`.
1000
+ * @param {number} page The new page number.
1001
+ */
1002
+ setPage: (page: number) => void;
1003
+ }
1004
+ /**
1005
+ * The pagination API interface that is available in the grid [[apiRef]].
1006
+ */
1007
+ interface GridPaginationApi extends GridPageApi, GridPageSizeApi {
1008
+ }
1009
+
1010
+ /**
1011
+ * @category Pagination
1012
+ * @ignore - do not document.
1013
+ */
1014
+ declare const gridPaginationSelector: (state: GridState) => GridPaginationState;
1015
+ /**
1016
+ * Get the index of the page to render if the pagination is enabled
1017
+ * @category Pagination
1018
+ */
1019
+ declare const gridPageSelector: OutputSelector<number>;
1020
+ /**
1021
+ * Get the maximum amount of rows to display on a single page if the pagination is enabled
1022
+ * @category Pagination
1023
+ */
1024
+ declare const gridPageSizeSelector: OutputSelector<number>;
1025
+ /**
1026
+ * Get the amount of pages needed to display all the rows if the pagination is enabled
1027
+ * @category Pagination
1028
+ */
1029
+ declare const gridPageCountSelector: OutputSelector<number>;
1030
+ /**
1031
+ * Get the index of the first and the last row to include in the current page if the pagination is enabled.
1032
+ * @category Pagination
1033
+ */
1034
+ declare const gridPaginationRowRangeSelector: OutputSelector<{
1035
+ firstRowIndex: number;
1036
+ lastRowIndex: number;
1037
+ } | null>;
1038
+ /**
1039
+ * Get the id and the model of each row to include in the current page if the pagination is enabled.
1040
+ * @category Pagination
1041
+ */
1042
+ declare const gridPaginatedVisibleSortedGridRowEntriesSelector: OutputSelector<{
1043
+ id: GridRowId;
1044
+ model: {
1045
+ [key: string]: any;
1046
+ };
1047
+ }[]>;
1048
+ /**
1049
+ * Get the id of each row to include in the current page if the pagination is enabled.
1050
+ * @category Pagination
1051
+ */
1052
+ declare const gridPaginatedVisibleSortedGridRowIdsSelector: OutputSelector<GridRowId[]>;
1221
1053
 
1222
1054
  /**
1223
1055
  * Model describing the filters to apply to the grid.
@@ -1238,9 +1070,16 @@ interface GridFilterModel {
1238
1070
  declare const getDefaultGridFilterModel: () => GridFilterModel;
1239
1071
  interface GridFilterState {
1240
1072
  filterModel: GridFilterModel;
1073
+ /**
1074
+ * Filtering status for each row.
1075
+ * A row is filtered if it is passing the filters, whether its parents are expanded or not.
1076
+ * If a row is not registered in this lookup, it is filtered.
1077
+ * This is the equivalent of the `visibleRowsLookup` if all the groups were expanded.
1078
+ */
1079
+ filteredRowsLookup: Record<GridRowId, boolean>;
1241
1080
  /**
1242
1081
  * Visibility status for each row.
1243
- * A row is visible if it is passing the filters AND if its parent is expanded.
1082
+ * A row is visible if it is passing the filters AND if its parents are expanded.
1244
1083
  * If a row is not registered in this lookup, it is visible.
1245
1084
  */
1246
1085
  visibleRowsLookup: Record<GridRowId, boolean>;
@@ -1263,221 +1102,46 @@ declare type GridAggregatedFilterItemApplier = (rowId: GridRowId, shouldApplyIte
1263
1102
  interface GridFilteringParams {
1264
1103
  isRowMatchingFilters: GridAggregatedFilterItemApplier | null;
1265
1104
  }
1266
- declare type GridFilteringMethod = (params: GridFilteringParams) => Pick<GridFilterState, 'visibleRowsLookup' | 'filteredDescendantCountLookup'>;
1105
+ declare type GridFilteringMethod = (params: GridFilteringParams) => Omit<GridFilterState, 'filterModel'>;
1267
1106
  declare type GridFilteringMethodCollection = {
1268
1107
  [methodName: string]: GridFilteringMethod;
1269
1108
  };
1270
1109
 
1271
- interface GridRowGroupParams {
1272
- ids: GridRowId[];
1273
- idRowsLookup: GridRowsLookup;
1274
- previousTree: GridRowTreeConfig | null;
1110
+ declare type GridRowGroupingModel = string[];
1111
+ interface GridRowGroupingState {
1112
+ model: GridRowGroupingModel;
1275
1113
  }
1276
- interface GridRowGroupingResult {
1277
- /**
1278
- * Name of the algorithm used to group the rows
1279
- * It is useful to decide which filtering / sorting algorithm to apply, to avoid applying tree-data filtering on a grouping-by-column dataset for instance.
1280
- */
1281
- groupingName: string;
1282
- tree: GridRowTreeConfig;
1283
- treeDepth: number;
1284
- ids: GridRowId[];
1285
- idRowsLookup: GridRowsLookup;
1114
+ interface GridRowGroupingInitialState {
1115
+ model?: GridRowGroupingModel;
1286
1116
  }
1287
- declare type GridRowGroupingPreProcessing = (params: GridRowGroupParams) => GridRowGroupingResult | null;
1288
- interface GridRowGroupsPreProcessingApi {
1117
+ interface GridRowGroupingApi {
1289
1118
  /**
1290
- * Register a column pre-processing and emit an event to re-apply the row grouping pre-processing.
1291
- * @param {string} processingName Name of the pre-processing. Used to clean the previous version of the pre-processing.
1292
- * @param {GridRowGroupingPreProcessing} columnsPreProcessing Pre-processing to register.
1293
- * @ignore - do not document.
1119
+ * Sets the columns to use as grouping criteria.
1120
+ * @param {GridRowGroupingModel} model The columns to use as grouping criteria.
1294
1121
  */
1295
- unstable_registerRowGroupsBuilder: (processingName: string, groupingFunction: GridRowGroupingPreProcessing | null) => void;
1122
+ setRowGroupingModel: (model: GridRowGroupingModel) => void;
1296
1123
  /**
1297
- * Apply the first row grouping pre-processing that does not return null.
1298
- * @param {GridRowsLookup} rowsLookup. Lookup of the rows to group.
1299
- * @param {GridRowId[]} List of the rows IDs.
1300
- * @returns {GridRowGroupingResult} The grouped rows.
1301
- * @ignore - do not document.
1124
+ * Adds the field to the row grouping model.
1125
+ * @param {string} groupingCriteriaField The field from which we want to group the rows.
1126
+ * @param {number | undefined} groupingIndex The grouping index at which we want to insert the new grouping criteria. By default, it will be inserted at the end of the model.
1302
1127
  */
1303
- unstable_groupRows: (params: GridRowGroupParams) => GridRowGroupingResult;
1304
- }
1305
-
1306
- interface GridRowsState extends GridRowGroupingResult {
1128
+ addRowGroupingCriteria: (groupingCriteriaField: string, groupingIndex?: number) => void;
1307
1129
  /**
1308
- * Amount of rows before applying the filtering.
1309
- * It also count the expanded and collapsed children rows.
1130
+ * sRemove the field from the row grouping model.
1131
+ * @param {string} groupingCriteriaField The field from which we want to stop grouping the rows.
1310
1132
  */
1311
- totalRowCount: number;
1133
+ removeRowGroupingCriteria: (groupingCriteriaField: string) => void;
1312
1134
  /**
1313
- * Amount of rows before applying the filtering.
1314
- * It does not count the expanded children rows.
1135
+ * Sets the grouping index of a grouping criteria.
1136
+ * @param {string} groupingCriteriaField The field of the grouping criteria from which we want to change the grouping index.
1137
+ * @param {number} groupingIndex The new grouping index of this grouping criteria.
1315
1138
  */
1316
- totalTopLevelRowCount: number;
1139
+ setRowGroupingCriteriaIndex: (groupingCriteriaField: string, groupingIndex: number) => void;
1317
1140
  }
1318
1141
 
1319
- declare const gridRowsStateSelector: (state: GridState) => GridRowsState;
1320
- declare const gridRowCountSelector: ((state: {
1321
- rows: GridRowsState;
1322
- editRows: GridEditRowsModel;
1323
- pagination: GridPaginationState;
1324
- columns: GridColumnsState;
1325
- columnReorder: GridColumnReorderState;
1326
- columnResize: GridColumnResizeState;
1327
- columnMenu: GridColumnMenuState;
1328
- sorting: GridSortingState;
1329
- focus: GridFocusState;
1330
- tabIndex: GridTabIndexState;
1331
- selection: GridSelectionModel;
1332
- filter: GridFilterState;
1333
- preferencePanel: GridPreferencePanelState;
1334
- density: GridDensityState;
1335
- rowGrouping: GridRowGroupingState;
1336
- error?: any;
1337
- pinnedColumns: GridPinnedColumns;
1338
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1339
- clearCache: () => void;
1340
- }> & {
1341
- clearCache: () => void;
1342
- };
1343
- declare const gridTopLevelRowCountSelector: ((state: {
1344
- rows: GridRowsState;
1345
- editRows: GridEditRowsModel;
1346
- pagination: GridPaginationState;
1347
- columns: GridColumnsState;
1348
- columnReorder: GridColumnReorderState;
1349
- columnResize: GridColumnResizeState;
1350
- columnMenu: GridColumnMenuState;
1351
- sorting: GridSortingState;
1352
- focus: GridFocusState;
1353
- tabIndex: GridTabIndexState;
1354
- selection: GridSelectionModel;
1355
- filter: GridFilterState;
1356
- preferencePanel: GridPreferencePanelState;
1357
- density: GridDensityState;
1358
- rowGrouping: GridRowGroupingState;
1359
- error?: any;
1360
- pinnedColumns: GridPinnedColumns;
1361
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1362
- clearCache: () => void;
1363
- }> & {
1364
- clearCache: () => void;
1365
- };
1366
- declare const gridRowsLookupSelector: ((state: {
1367
- rows: GridRowsState;
1368
- editRows: GridEditRowsModel;
1369
- pagination: GridPaginationState;
1370
- columns: GridColumnsState;
1371
- columnReorder: GridColumnReorderState;
1372
- columnResize: GridColumnResizeState;
1373
- columnMenu: GridColumnMenuState;
1374
- sorting: GridSortingState;
1375
- focus: GridFocusState;
1376
- tabIndex: GridTabIndexState;
1377
- selection: GridSelectionModel;
1378
- filter: GridFilterState;
1379
- preferencePanel: GridPreferencePanelState;
1380
- density: GridDensityState;
1381
- rowGrouping: GridRowGroupingState;
1382
- error?: any;
1383
- pinnedColumns: GridPinnedColumns;
1384
- }) => GridRowsLookup) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowsLookup & {
1385
- clearCache: () => void;
1386
- }> & {
1387
- clearCache: () => void;
1388
- };
1389
- declare const gridRowTreeSelector: ((state: {
1390
- rows: GridRowsState;
1391
- editRows: GridEditRowsModel;
1392
- pagination: GridPaginationState;
1393
- columns: GridColumnsState;
1394
- columnReorder: GridColumnReorderState;
1395
- columnResize: GridColumnResizeState;
1396
- columnMenu: GridColumnMenuState;
1397
- sorting: GridSortingState;
1398
- focus: GridFocusState;
1399
- tabIndex: GridTabIndexState;
1400
- selection: GridSelectionModel;
1401
- filter: GridFilterState;
1402
- preferencePanel: GridPreferencePanelState;
1403
- density: GridDensityState;
1404
- rowGrouping: GridRowGroupingState;
1405
- error?: any;
1406
- pinnedColumns: GridPinnedColumns;
1407
- }) => GridRowTreeConfig) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowTreeConfig & {
1408
- clearCache: () => void;
1409
- }> & {
1410
- clearCache: () => void;
1411
- };
1412
- declare const gridRowGroupingNameSelector: ((state: {
1413
- rows: GridRowsState;
1414
- editRows: GridEditRowsModel;
1415
- pagination: GridPaginationState;
1416
- columns: GridColumnsState;
1417
- columnReorder: GridColumnReorderState;
1418
- columnResize: GridColumnResizeState;
1419
- columnMenu: GridColumnMenuState;
1420
- sorting: GridSortingState;
1421
- focus: GridFocusState;
1422
- tabIndex: GridTabIndexState;
1423
- selection: GridSelectionModel;
1424
- filter: GridFilterState;
1425
- preferencePanel: GridPreferencePanelState;
1426
- density: GridDensityState;
1427
- rowGrouping: GridRowGroupingState;
1428
- error?: any;
1429
- pinnedColumns: GridPinnedColumns;
1430
- }) => string) & reselect.OutputSelectorFields<(args_0: GridRowsState) => string & {
1431
- clearCache: () => void;
1432
- }> & {
1433
- clearCache: () => void;
1434
- };
1435
- declare const gridRowTreeDepthSelector: ((state: {
1436
- rows: GridRowsState;
1437
- editRows: GridEditRowsModel;
1438
- pagination: GridPaginationState;
1439
- columns: GridColumnsState;
1440
- columnReorder: GridColumnReorderState;
1441
- columnResize: GridColumnResizeState;
1442
- columnMenu: GridColumnMenuState;
1443
- sorting: GridSortingState;
1444
- focus: GridFocusState;
1445
- tabIndex: GridTabIndexState;
1446
- selection: GridSelectionModel;
1447
- filter: GridFilterState;
1448
- preferencePanel: GridPreferencePanelState;
1449
- density: GridDensityState;
1450
- rowGrouping: GridRowGroupingState;
1451
- error?: any;
1452
- pinnedColumns: GridPinnedColumns;
1453
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1454
- clearCache: () => void;
1455
- }> & {
1456
- clearCache: () => void;
1457
- };
1458
- declare const gridRowIdsSelector: ((state: {
1459
- rows: GridRowsState;
1460
- editRows: GridEditRowsModel;
1461
- pagination: GridPaginationState;
1462
- columns: GridColumnsState;
1463
- columnReorder: GridColumnReorderState;
1464
- columnResize: GridColumnResizeState;
1465
- columnMenu: GridColumnMenuState;
1466
- sorting: GridSortingState;
1467
- focus: GridFocusState;
1468
- tabIndex: GridTabIndexState;
1469
- selection: GridSelectionModel;
1470
- filter: GridFilterState;
1471
- preferencePanel: GridPreferencePanelState;
1472
- density: GridDensityState;
1473
- rowGrouping: GridRowGroupingState;
1474
- error?: any;
1475
- pinnedColumns: GridPinnedColumns;
1476
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowId[] & {
1477
- clearCache: () => void;
1478
- }> & {
1479
- clearCache: () => void;
1480
- };
1142
+ declare const gridRowGroupingStateSelector: (state: GridState) => GridRowGroupingState;
1143
+ declare const gridRowGroupingModelSelector: OutputSelector<GridRowGroupingModel>;
1144
+ declare const gridRowGroupingSanitizedModelSelector: OutputSelector<string[]>;
1481
1145
 
1482
1146
  /**
1483
1147
  * @category Filtering
@@ -1488,1064 +1152,95 @@ declare const gridFilterStateSelector: (state: GridState) => GridFilterState;
1488
1152
  * Get the current filter model.
1489
1153
  * @category Filtering
1490
1154
  */
1491
- declare const gridFilterModelSelector: ((state: {
1492
- rows: GridRowsState;
1493
- editRows: GridEditRowsModel;
1494
- pagination: GridPaginationState;
1495
- columns: GridColumnsState;
1496
- columnReorder: GridColumnReorderState;
1497
- columnResize: GridColumnResizeState;
1498
- columnMenu: GridColumnMenuState;
1499
- sorting: GridSortingState;
1500
- focus: GridFocusState;
1501
- tabIndex: GridTabIndexState;
1502
- selection: GridSelectionModel;
1503
- filter: GridFilterState;
1504
- preferencePanel: GridPreferencePanelState;
1505
- density: GridDensityState;
1506
- rowGrouping: GridRowGroupingState;
1507
- error?: any;
1508
- pinnedColumns: GridPinnedColumns;
1509
- }) => GridFilterModel) & reselect.OutputSelectorFields<(args_0: GridFilterState) => GridFilterModel & {
1510
- clearCache: () => void;
1511
- }> & {
1512
- clearCache: () => void;
1513
- };
1155
+ declare const gridFilterModelSelector: OutputSelector<GridFilterModel>;
1514
1156
  /**
1515
1157
  * @category Filtering
1516
1158
  * @ignore - do not document.
1517
1159
  */
1518
- declare const gridVisibleRowsLookupSelector: ((state: {
1519
- rows: GridRowsState;
1520
- editRows: GridEditRowsModel;
1521
- pagination: GridPaginationState;
1522
- columns: GridColumnsState;
1523
- columnReorder: GridColumnReorderState;
1524
- columnResize: GridColumnResizeState;
1525
- columnMenu: GridColumnMenuState;
1526
- sorting: GridSortingState;
1527
- focus: GridFocusState;
1528
- tabIndex: GridTabIndexState;
1529
- selection: GridSelectionModel;
1530
- filter: GridFilterState;
1531
- preferencePanel: GridPreferencePanelState;
1532
- density: GridDensityState;
1533
- rowGrouping: GridRowGroupingState;
1534
- error?: any;
1535
- pinnedColumns: GridPinnedColumns;
1536
- }) => Record<GridRowId, boolean>) & reselect.OutputSelectorFields<(args_0: GridFilterState) => Record<GridRowId, boolean> & {
1537
- clearCache: () => void;
1538
- }> & {
1539
- clearCache: () => void;
1540
- };
1160
+ declare const gridVisibleRowsLookupSelector: OutputSelector<Record<GridRowId, boolean>>;
1541
1161
  /**
1542
1162
  * @category Filtering
1543
1163
  * @ignore - do not document.
1544
1164
  */
1545
- declare const gridFilteredDescendantCountLookupSelector: ((state: {
1546
- rows: GridRowsState;
1547
- editRows: GridEditRowsModel;
1548
- pagination: GridPaginationState;
1549
- columns: GridColumnsState;
1550
- columnReorder: GridColumnReorderState;
1551
- columnResize: GridColumnResizeState;
1552
- columnMenu: GridColumnMenuState;
1553
- sorting: GridSortingState;
1554
- focus: GridFocusState;
1555
- tabIndex: GridTabIndexState;
1556
- selection: GridSelectionModel;
1557
- filter: GridFilterState;
1558
- preferencePanel: GridPreferencePanelState;
1559
- density: GridDensityState;
1560
- rowGrouping: GridRowGroupingState;
1561
- error?: any;
1562
- pinnedColumns: GridPinnedColumns;
1563
- }) => Record<GridRowId, number>) & reselect.OutputSelectorFields<(args_0: GridFilterState) => Record<GridRowId, number> & {
1564
- clearCache: () => void;
1565
- }> & {
1566
- clearCache: () => void;
1567
- };
1165
+ declare const gridFilteredRowsLookupSelector: OutputSelector<Record<GridRowId, boolean>>;
1166
+ /**
1167
+ * @category Filtering
1168
+ * @ignore - do not document.
1169
+ */
1170
+ declare const gridFilteredDescendantCountLookupSelector: OutputSelector<Record<GridRowId, number>>;
1568
1171
  /**
1569
1172
  * Get the id and the model of the rows accessible after the filtering process.
1173
+ * Does not contain the collapsed children.
1570
1174
  * @category Filtering
1571
1175
  */
1572
- declare const gridVisibleSortedRowEntriesSelector: ((state: {
1573
- rows: GridRowsState;
1574
- editRows: GridEditRowsModel;
1575
- pagination: GridPaginationState;
1576
- columns: GridColumnsState;
1577
- columnReorder: GridColumnReorderState;
1578
- columnResize: GridColumnResizeState;
1579
- columnMenu: GridColumnMenuState;
1580
- sorting: GridSortingState;
1581
- focus: GridFocusState;
1582
- tabIndex: GridTabIndexState;
1583
- selection: GridSelectionModel;
1584
- filter: GridFilterState;
1585
- preferencePanel: GridPreferencePanelState;
1586
- density: GridDensityState;
1587
- rowGrouping: GridRowGroupingState;
1588
- error?: any;
1589
- pinnedColumns: GridPinnedColumns;
1590
- }) => {
1591
- id: GridRowId;
1592
- model: {
1593
- [key: string]: any;
1594
- };
1595
- }[]) & reselect.OutputSelectorFields<(args_0: Record<GridRowId, boolean>, args_1: {
1596
- id: GridRowId;
1597
- model: {
1598
- [key: string]: any;
1599
- };
1600
- }[]) => {
1176
+ declare const gridVisibleSortedRowEntriesSelector: OutputSelector<{
1601
1177
  id: GridRowId;
1602
1178
  model: {
1603
1179
  [key: string]: any;
1604
1180
  };
1605
- }[] & {
1606
- clearCache: () => void;
1607
- }> & {
1608
- clearCache: () => void;
1609
- };
1181
+ }[]>;
1610
1182
  /**
1611
1183
  * Get the id of the rows accessible after the filtering process.
1184
+ * Does not contain the collapsed children.
1612
1185
  * @category Filtering
1613
1186
  */
1614
- declare const gridVisibleSortedRowIdsSelector: ((state: {
1615
- rows: GridRowsState;
1616
- editRows: GridEditRowsModel;
1617
- pagination: GridPaginationState;
1618
- columns: GridColumnsState;
1619
- columnReorder: GridColumnReorderState;
1620
- columnResize: GridColumnResizeState;
1621
- columnMenu: GridColumnMenuState;
1622
- sorting: GridSortingState;
1623
- focus: GridFocusState;
1624
- tabIndex: GridTabIndexState;
1625
- selection: GridSelectionModel;
1626
- filter: GridFilterState;
1627
- preferencePanel: GridPreferencePanelState;
1628
- density: GridDensityState;
1629
- rowGrouping: GridRowGroupingState;
1630
- error?: any;
1631
- pinnedColumns: GridPinnedColumns;
1632
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: {
1187
+ declare const gridVisibleSortedRowIdsSelector: OutputSelector<GridRowId[]>;
1188
+ /**
1189
+ * Get the id and the model of the rows accessible after the filtering process.
1190
+ * Contains the collapsed children.
1191
+ * @category Filtering
1192
+ */
1193
+ declare const gridFilteredSortedRowEntriesSelector: OutputSelector<{
1633
1194
  id: GridRowId;
1634
1195
  model: {
1635
1196
  [key: string]: any;
1636
1197
  };
1637
- }[]) => GridRowId[] & {
1638
- clearCache: () => void;
1639
- }> & {
1640
- clearCache: () => void;
1641
- };
1198
+ }[]>;
1199
+ /**
1200
+ * Get the id of the rows accessible after the filtering process.
1201
+ * Contains the collapsed children.
1202
+ * @category Filtering
1203
+ */
1204
+ declare const gridFilteredSortedRowIdsSelector: OutputSelector<GridRowId[]>;
1642
1205
  /**
1643
1206
  * @category Filtering
1644
1207
  * @deprecated Use `gridVisibleSortedRowIdsSelector` instead
1645
1208
  * @ignore - do not document.
1646
1209
  */
1647
- declare const gridVisibleRowsSelector: ((state: {
1648
- rows: GridRowsState;
1649
- editRows: GridEditRowsModel;
1650
- pagination: GridPaginationState;
1651
- columns: GridColumnsState;
1652
- columnReorder: GridColumnReorderState;
1653
- columnResize: GridColumnResizeState;
1654
- columnMenu: GridColumnMenuState;
1655
- sorting: GridSortingState;
1656
- focus: GridFocusState;
1657
- tabIndex: GridTabIndexState;
1658
- selection: GridSelectionModel;
1659
- filter: GridFilterState;
1660
- preferencePanel: GridPreferencePanelState;
1661
- density: GridDensityState;
1662
- rowGrouping: GridRowGroupingState;
1663
- error?: any;
1664
- pinnedColumns: GridPinnedColumns;
1665
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: {
1210
+ declare const gridVisibleRowsSelector: OutputSelector<GridRowId[]>;
1211
+ /**
1212
+ * Get the id and the model of the top level rows accessible after the filtering process.
1213
+ * @category Filtering
1214
+ */
1215
+ declare const gridVisibleSortedTopLevelRowEntriesSelector: OutputSelector<{
1666
1216
  id: GridRowId;
1667
1217
  model: {
1668
1218
  [key: string]: any;
1669
1219
  };
1670
- }[]) => GridRowId[] & {
1671
- clearCache: () => void;
1672
- }> & {
1673
- clearCache: () => void;
1674
- };
1220
+ }[]>;
1675
1221
  /**
1676
- * Get the id and the model of the top level rows accessible after the filtering process.
1222
+ * Get the amount of rows accessible after the filtering process.
1677
1223
  * @category Filtering
1678
1224
  */
1679
- declare const gridVisibleSortedTopLevelRowEntriesSelector: ((state: {
1680
- rows: GridRowsState;
1681
- editRows: GridEditRowsModel;
1682
- pagination: GridPaginationState;
1683
- columns: GridColumnsState;
1684
- columnReorder: GridColumnReorderState;
1685
- columnResize: GridColumnResizeState;
1686
- columnMenu: GridColumnMenuState;
1687
- sorting: GridSortingState;
1688
- focus: GridFocusState;
1689
- tabIndex: GridTabIndexState;
1690
- selection: GridSelectionModel;
1691
- filter: GridFilterState;
1692
- preferencePanel: GridPreferencePanelState;
1693
- density: GridDensityState;
1694
- rowGrouping: GridRowGroupingState;
1695
- error?: any;
1696
- pinnedColumns: GridPinnedColumns;
1697
- }) => {
1698
- id: GridRowId;
1699
- model: {
1700
- [key: string]: any;
1701
- };
1702
- }[]) & reselect.OutputSelectorFields<(args_0: {
1703
- id: GridRowId;
1704
- model: {
1705
- [key: string]: any;
1706
- };
1707
- }[], args_1: GridRowTreeConfig, args_2: number) => {
1708
- id: GridRowId;
1709
- model: {
1710
- [key: string]: any;
1711
- };
1712
- }[] & {
1713
- clearCache: () => void;
1714
- }> & {
1715
- clearCache: () => void;
1716
- };
1717
- /**
1718
- * Get the amount of rows accessible after the filtering process.
1719
- * @category Filtering
1720
- */
1721
- declare const gridVisibleRowCountSelector: ((state: {
1722
- rows: GridRowsState;
1723
- editRows: GridEditRowsModel;
1724
- pagination: GridPaginationState;
1725
- columns: GridColumnsState;
1726
- columnReorder: GridColumnReorderState;
1727
- columnResize: GridColumnResizeState;
1728
- columnMenu: GridColumnMenuState;
1729
- sorting: GridSortingState;
1730
- focus: GridFocusState;
1731
- tabIndex: GridTabIndexState;
1732
- selection: GridSelectionModel;
1733
- filter: GridFilterState;
1734
- preferencePanel: GridPreferencePanelState;
1735
- density: GridDensityState;
1736
- rowGrouping: GridRowGroupingState;
1737
- error?: any;
1738
- pinnedColumns: GridPinnedColumns;
1739
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1740
- id: GridRowId;
1741
- model: {
1742
- [key: string]: any;
1743
- };
1744
- }[]) => number & {
1745
- clearCache: () => void;
1746
- }> & {
1747
- clearCache: () => void;
1748
- };
1749
- /**
1750
- * Get the amount of top level rows accessible after the filtering process.
1751
- * @category Filtering
1752
- */
1753
- declare const gridVisibleTopLevelRowCountSelector: ((state: {
1754
- rows: GridRowsState;
1755
- editRows: GridEditRowsModel;
1756
- pagination: GridPaginationState;
1757
- columns: GridColumnsState;
1758
- columnReorder: GridColumnReorderState;
1759
- columnResize: GridColumnResizeState;
1760
- columnMenu: GridColumnMenuState;
1761
- sorting: GridSortingState;
1762
- focus: GridFocusState;
1763
- tabIndex: GridTabIndexState;
1764
- selection: GridSelectionModel;
1765
- filter: GridFilterState;
1766
- preferencePanel: GridPreferencePanelState;
1767
- density: GridDensityState;
1768
- rowGrouping: GridRowGroupingState;
1769
- error?: any;
1770
- pinnedColumns: GridPinnedColumns;
1771
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1772
- id: GridRowId;
1773
- model: {
1774
- [key: string]: any;
1775
- };
1776
- }[]) => number & {
1777
- clearCache: () => void;
1778
- }> & {
1779
- clearCache: () => void;
1780
- };
1781
- /**
1782
- * @category Filtering
1783
- * @ignore - do not document.
1784
- */
1785
- declare const gridFilterActiveItemsSelector: ((state: {
1786
- rows: GridRowsState;
1787
- editRows: GridEditRowsModel;
1788
- pagination: GridPaginationState;
1789
- columns: GridColumnsState;
1790
- columnReorder: GridColumnReorderState;
1791
- columnResize: GridColumnResizeState;
1792
- columnMenu: GridColumnMenuState;
1793
- sorting: GridSortingState;
1794
- focus: GridFocusState;
1795
- tabIndex: GridTabIndexState;
1796
- selection: GridSelectionModel;
1797
- filter: GridFilterState;
1798
- preferencePanel: GridPreferencePanelState;
1799
- density: GridDensityState;
1800
- rowGrouping: GridRowGroupingState;
1801
- error?: any;
1802
- pinnedColumns: GridPinnedColumns;
1803
- }) => GridFilterItem[]) & reselect.OutputSelectorFields<(args_0: GridFilterModel, args_1: GridColumnLookup) => GridFilterItem[] & {
1804
- clearCache: () => void;
1805
- }> & {
1806
- clearCache: () => void;
1807
- };
1808
- declare type GridFilterActiveItemsLookup = {
1809
- [columnField: string]: GridFilterItem[];
1810
- };
1811
- /**
1812
- * @category Filtering
1813
- * @ignore - do not document.
1814
- */
1815
- declare const gridFilterActiveItemsLookupSelector: ((state: {
1816
- rows: GridRowsState;
1817
- editRows: GridEditRowsModel;
1818
- pagination: GridPaginationState;
1819
- columns: GridColumnsState;
1820
- columnReorder: GridColumnReorderState;
1821
- columnResize: GridColumnResizeState;
1822
- columnMenu: GridColumnMenuState;
1823
- sorting: GridSortingState;
1824
- focus: GridFocusState;
1825
- tabIndex: GridTabIndexState;
1826
- selection: GridSelectionModel;
1827
- filter: GridFilterState;
1828
- preferencePanel: GridPreferencePanelState;
1829
- density: GridDensityState;
1830
- rowGrouping: GridRowGroupingState;
1831
- error?: any;
1832
- pinnedColumns: GridPinnedColumns;
1833
- }) => GridFilterActiveItemsLookup) & reselect.OutputSelectorFields<(args_0: GridFilterItem[]) => GridFilterActiveItemsLookup & {
1834
- clearCache: () => void;
1835
- }> & {
1836
- clearCache: () => void;
1837
- };
1838
-
1839
- declare type GridCellIdentifier = {
1840
- id: GridRowId;
1841
- field: string;
1842
- };
1843
- declare type GridColumnIdentifier = {
1844
- field: string;
1845
- };
1846
- interface GridFocusState {
1847
- cell: GridCellIdentifier | null;
1848
- columnHeader: GridColumnIdentifier | null;
1849
- }
1850
- interface GridTabIndexState {
1851
- cell: GridCellIdentifier | null;
1852
- columnHeader: GridColumnIdentifier | null;
1853
- }
1854
-
1855
- declare const gridFocusStateSelector: (state: GridState) => GridFocusState;
1856
- declare const gridFocusCellSelector: ((state: {
1857
- rows: GridRowsState;
1858
- editRows: GridEditRowsModel;
1859
- pagination: GridPaginationState;
1860
- columns: GridColumnsState;
1861
- columnReorder: GridColumnReorderState;
1862
- columnResize: GridColumnResizeState;
1863
- columnMenu: GridColumnMenuState;
1864
- sorting: GridSortingState;
1865
- focus: GridFocusState;
1866
- tabIndex: GridTabIndexState;
1867
- selection: GridSelectionModel;
1868
- filter: GridFilterState;
1869
- preferencePanel: GridPreferencePanelState;
1870
- density: GridDensityState;
1871
- rowGrouping: GridRowGroupingState;
1872
- error?: any;
1873
- pinnedColumns: GridPinnedColumns;
1874
- }) => GridCellIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridFocusState) => GridCellIdentifier & {
1875
- clearCache: () => void;
1876
- }> & {
1877
- clearCache: () => void;
1878
- };
1879
- declare const gridFocusColumnHeaderSelector: ((state: {
1880
- rows: GridRowsState;
1881
- editRows: GridEditRowsModel;
1882
- pagination: GridPaginationState;
1883
- columns: GridColumnsState;
1884
- columnReorder: GridColumnReorderState;
1885
- columnResize: GridColumnResizeState;
1886
- columnMenu: GridColumnMenuState;
1887
- sorting: GridSortingState;
1888
- focus: GridFocusState;
1889
- tabIndex: GridTabIndexState;
1890
- selection: GridSelectionModel;
1891
- filter: GridFilterState;
1892
- preferencePanel: GridPreferencePanelState;
1893
- density: GridDensityState;
1894
- rowGrouping: GridRowGroupingState;
1895
- error?: any;
1896
- pinnedColumns: GridPinnedColumns;
1897
- }) => GridColumnIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridFocusState) => GridColumnIdentifier & {
1898
- clearCache: () => void;
1899
- }> & {
1900
- clearCache: () => void;
1901
- };
1902
- declare const gridTabIndexStateSelector: (state: GridState) => GridTabIndexState;
1903
- declare const gridTabIndexCellSelector: ((state: {
1904
- rows: GridRowsState;
1905
- editRows: GridEditRowsModel;
1906
- pagination: GridPaginationState;
1907
- columns: GridColumnsState;
1908
- columnReorder: GridColumnReorderState;
1909
- columnResize: GridColumnResizeState;
1910
- columnMenu: GridColumnMenuState;
1911
- sorting: GridSortingState;
1912
- focus: GridFocusState;
1913
- tabIndex: GridTabIndexState;
1914
- selection: GridSelectionModel;
1915
- filter: GridFilterState;
1916
- preferencePanel: GridPreferencePanelState;
1917
- density: GridDensityState;
1918
- rowGrouping: GridRowGroupingState;
1919
- error?: any;
1920
- pinnedColumns: GridPinnedColumns;
1921
- }) => GridCellIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridTabIndexState) => GridCellIdentifier & {
1922
- clearCache: () => void;
1923
- }> & {
1924
- clearCache: () => void;
1925
- };
1926
- declare const gridTabIndexColumnHeaderSelector: ((state: {
1927
- rows: GridRowsState;
1928
- editRows: GridEditRowsModel;
1929
- pagination: GridPaginationState;
1930
- columns: GridColumnsState;
1931
- columnReorder: GridColumnReorderState;
1932
- columnResize: GridColumnResizeState;
1933
- columnMenu: GridColumnMenuState;
1934
- sorting: GridSortingState;
1935
- focus: GridFocusState;
1936
- tabIndex: GridTabIndexState;
1937
- selection: GridSelectionModel;
1938
- filter: GridFilterState;
1939
- preferencePanel: GridPreferencePanelState;
1940
- density: GridDensityState;
1941
- rowGrouping: GridRowGroupingState;
1942
- error?: any;
1943
- pinnedColumns: GridPinnedColumns;
1944
- }) => GridColumnIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridTabIndexState) => GridColumnIdentifier & {
1945
- clearCache: () => void;
1946
- }> & {
1947
- clearCache: () => void;
1948
- };
1949
-
1950
- interface GridPaginationState {
1951
- pageSize: number;
1952
- page: number;
1953
- pageCount: number;
1954
- rowCount: number;
1955
- }
1956
- interface GridPaginationInitialState {
1957
- pageSize?: number;
1958
- page?: number;
1959
- }
1960
- /**
1961
- * The apiRef methods handled by `useGridPageSize`
1962
- */
1963
- interface GridPageSizeApi {
1964
- /**
1965
- * Sets the number of displayed rows to the value given by `pageSize`.
1966
- * @param {number} pageSize The new number of displayed rows.
1967
- */
1968
- setPageSize: (pageSize: number) => void;
1969
- }
1970
- /**
1971
- * The apiRef methods handled by `useGridPage`
1972
- */
1973
- interface GridPageApi {
1974
- /**
1975
- * Sets the displayed page to the value given by `page`.
1976
- * @param {number} page The new page number.
1977
- */
1978
- setPage: (page: number) => void;
1979
- }
1980
- /**
1981
- * The pagination API interface that is available in the grid [[apiRef]].
1982
- */
1983
- interface GridPaginationApi extends GridPageApi, GridPageSizeApi {
1984
- }
1985
-
1986
- /**
1987
- * @category Pagination
1988
- * @ignore - do not document.
1989
- */
1990
- declare const gridPaginationSelector: (state: GridState) => GridPaginationState;
1991
- /**
1992
- * Get the index of the page to render if the pagination is enabled
1993
- * @category Pagination
1994
- */
1995
- declare const gridPageSelector: ((state: {
1996
- rows: GridRowsState;
1997
- editRows: GridEditRowsModel;
1998
- pagination: GridPaginationState;
1999
- columns: GridColumnsState;
2000
- columnReorder: GridColumnReorderState;
2001
- columnResize: GridColumnResizeState;
2002
- columnMenu: GridColumnMenuState;
2003
- sorting: GridSortingState;
2004
- focus: GridFocusState;
2005
- tabIndex: GridTabIndexState;
2006
- selection: GridSelectionModel;
2007
- filter: GridFilterState;
2008
- preferencePanel: GridPreferencePanelState;
2009
- density: GridDensityState;
2010
- rowGrouping: GridRowGroupingState;
2011
- error?: any;
2012
- pinnedColumns: GridPinnedColumns;
2013
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2014
- clearCache: () => void;
2015
- }> & {
2016
- clearCache: () => void;
2017
- };
2018
- /**
2019
- * Get the maximum amount of rows to display on a single page if the pagination is enabled
2020
- * @category Pagination
2021
- */
2022
- declare const gridPageSizeSelector: ((state: {
2023
- rows: GridRowsState;
2024
- editRows: GridEditRowsModel;
2025
- pagination: GridPaginationState;
2026
- columns: GridColumnsState;
2027
- columnReorder: GridColumnReorderState;
2028
- columnResize: GridColumnResizeState;
2029
- columnMenu: GridColumnMenuState;
2030
- sorting: GridSortingState;
2031
- focus: GridFocusState;
2032
- tabIndex: GridTabIndexState;
2033
- selection: GridSelectionModel;
2034
- filter: GridFilterState;
2035
- preferencePanel: GridPreferencePanelState;
2036
- density: GridDensityState;
2037
- rowGrouping: GridRowGroupingState;
2038
- error?: any;
2039
- pinnedColumns: GridPinnedColumns;
2040
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2041
- clearCache: () => void;
2042
- }> & {
2043
- clearCache: () => void;
2044
- };
2045
- /**
2046
- * Get the amount of pages needed to display all the rows if the pagination is enabled
2047
- * @category Pagination
2048
- */
2049
- declare const gridPageCountSelector: ((state: {
2050
- rows: GridRowsState;
2051
- editRows: GridEditRowsModel;
2052
- pagination: GridPaginationState;
2053
- columns: GridColumnsState;
2054
- columnReorder: GridColumnReorderState;
2055
- columnResize: GridColumnResizeState;
2056
- columnMenu: GridColumnMenuState;
2057
- sorting: GridSortingState;
2058
- focus: GridFocusState;
2059
- tabIndex: GridTabIndexState;
2060
- selection: GridSelectionModel;
2061
- filter: GridFilterState;
2062
- preferencePanel: GridPreferencePanelState;
2063
- density: GridDensityState;
2064
- rowGrouping: GridRowGroupingState;
2065
- error?: any;
2066
- pinnedColumns: GridPinnedColumns;
2067
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2068
- clearCache: () => void;
2069
- }> & {
2070
- clearCache: () => void;
2071
- };
2072
- /**
2073
- * Get the index of the first and the last row to include in the current page if the pagination is enabled.
2074
- * @category Pagination
2075
- */
2076
- declare const gridPaginationRowRangeSelector: ((state: {
2077
- rows: GridRowsState;
2078
- editRows: GridEditRowsModel;
2079
- pagination: GridPaginationState;
2080
- columns: GridColumnsState;
2081
- columnReorder: GridColumnReorderState;
2082
- columnResize: GridColumnResizeState;
2083
- columnMenu: GridColumnMenuState;
2084
- sorting: GridSortingState;
2085
- focus: GridFocusState;
2086
- tabIndex: GridTabIndexState;
2087
- selection: GridSelectionModel;
2088
- filter: GridFilterState;
2089
- preferencePanel: GridPreferencePanelState;
2090
- density: GridDensityState;
2091
- rowGrouping: GridRowGroupingState;
2092
- error?: any;
2093
- pinnedColumns: GridPinnedColumns;
2094
- }) => {
2095
- firstRowIndex: number;
2096
- lastRowIndex: number;
2097
- } | null) & reselect.OutputSelectorFields<(args_0: GridPaginationState, args_1: GridRowTreeConfig, args_2: number, args_3: {
2098
- id: GridRowId;
2099
- model: {
2100
- [key: string]: any;
2101
- };
2102
- }[], args_4: {
2103
- id: GridRowId;
2104
- model: {
2105
- [key: string]: any;
2106
- };
2107
- }[]) => {
2108
- firstRowIndex: number;
2109
- lastRowIndex: number;
2110
- } & {
2111
- clearCache: () => void;
2112
- }> & {
2113
- clearCache: () => void;
2114
- };
2115
- /**
2116
- * Get the id and the model of each row to include in the current page if the pagination is enabled.
2117
- * @category Pagination
2118
- */
2119
- declare const gridPaginatedVisibleSortedGridRowEntriesSelector: ((state: {
2120
- rows: GridRowsState;
2121
- editRows: GridEditRowsModel;
2122
- pagination: GridPaginationState;
2123
- columns: GridColumnsState;
2124
- columnReorder: GridColumnReorderState;
2125
- columnResize: GridColumnResizeState;
2126
- columnMenu: GridColumnMenuState;
2127
- sorting: GridSortingState;
2128
- focus: GridFocusState;
2129
- tabIndex: GridTabIndexState;
2130
- selection: GridSelectionModel;
2131
- filter: GridFilterState;
2132
- preferencePanel: GridPreferencePanelState;
2133
- density: GridDensityState;
2134
- rowGrouping: GridRowGroupingState;
2135
- error?: any;
2136
- pinnedColumns: GridPinnedColumns;
2137
- }) => {
2138
- id: GridRowId;
2139
- model: {
2140
- [key: string]: any;
2141
- };
2142
- }[]) & reselect.OutputSelectorFields<(args_0: {
2143
- id: GridRowId;
2144
- model: {
2145
- [key: string]: any;
2146
- };
2147
- }[], args_1: {
2148
- firstRowIndex: number;
2149
- lastRowIndex: number;
2150
- } | null) => {
2151
- id: GridRowId;
2152
- model: {
2153
- [key: string]: any;
2154
- };
2155
- }[] & {
2156
- clearCache: () => void;
2157
- }> & {
2158
- clearCache: () => void;
2159
- };
2160
- /**
2161
- * Get the id of each row to include in the current page if the pagination is enabled.
2162
- * @category Pagination
2163
- */
2164
- declare const gridPaginatedVisibleSortedGridRowIdsSelector: ((state: {
2165
- rows: GridRowsState;
2166
- editRows: GridEditRowsModel;
2167
- pagination: GridPaginationState;
2168
- columns: GridColumnsState;
2169
- columnReorder: GridColumnReorderState;
2170
- columnResize: GridColumnResizeState;
2171
- columnMenu: GridColumnMenuState;
2172
- sorting: GridSortingState;
2173
- focus: GridFocusState;
2174
- tabIndex: GridTabIndexState;
2175
- selection: GridSelectionModel;
2176
- filter: GridFilterState;
2177
- preferencePanel: GridPreferencePanelState;
2178
- density: GridDensityState;
2179
- rowGrouping: GridRowGroupingState;
2180
- error?: any;
2181
- pinnedColumns: GridPinnedColumns;
2182
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridRowId[], args_1: {
2183
- firstRowIndex: number;
2184
- lastRowIndex: number;
2185
- } | null) => GridRowId[] & {
2186
- clearCache: () => void;
2187
- }> & {
2188
- clearCache: () => void;
2189
- };
2190
-
2191
- declare enum GridPreferencePanelsValue {
2192
- filters = "filters",
2193
- columns = "columns"
2194
- }
2195
-
2196
- interface GridPreferencePanelState {
2197
- open: boolean;
2198
- openedPanelValue?: GridPreferencePanelsValue;
2199
- }
2200
- declare type GridPreferencePanelInitialState = GridPreferencePanelState;
2201
-
2202
- declare const gridPreferencePanelStateSelector: (state: GridState) => GridPreferencePanelState;
2203
-
2204
- declare const gridSelectionStateSelector: (state: GridState) => GridSelectionModel;
2205
- declare const selectedGridRowsCountSelector: ((state: {
2206
- rows: GridRowsState;
2207
- editRows: GridEditRowsModel;
2208
- pagination: GridPaginationState;
2209
- columns: GridColumnsState;
2210
- columnReorder: GridColumnReorderState;
2211
- columnResize: GridColumnResizeState;
2212
- columnMenu: GridColumnMenuState;
2213
- sorting: GridSortingState;
2214
- focus: GridFocusState;
2215
- tabIndex: GridTabIndexState;
2216
- selection: GridSelectionModel;
2217
- filter: GridFilterState;
2218
- preferencePanel: GridPreferencePanelState;
2219
- density: GridDensityState;
2220
- rowGrouping: GridRowGroupingState;
2221
- error?: any;
2222
- pinnedColumns: GridPinnedColumns;
2223
- }) => number) & reselect.OutputSelectorFields<(args_0: GridSelectionModel) => number & {
2224
- clearCache: () => void;
2225
- }> & {
2226
- clearCache: () => void;
2227
- };
2228
- declare const selectedGridRowsSelector: ((state: {
2229
- rows: GridRowsState;
2230
- editRows: GridEditRowsModel;
2231
- pagination: GridPaginationState;
2232
- columns: GridColumnsState;
2233
- columnReorder: GridColumnReorderState;
2234
- columnResize: GridColumnResizeState;
2235
- columnMenu: GridColumnMenuState;
2236
- sorting: GridSortingState;
2237
- focus: GridFocusState;
2238
- tabIndex: GridTabIndexState;
2239
- selection: GridSelectionModel;
2240
- filter: GridFilterState;
2241
- preferencePanel: GridPreferencePanelState;
2242
- density: GridDensityState;
2243
- rowGrouping: GridRowGroupingState;
2244
- error?: any;
2245
- pinnedColumns: GridPinnedColumns;
2246
- }) => Map<GridRowId, {
2247
- [key: string]: any;
2248
- }>) & reselect.OutputSelectorFields<(args_0: GridSelectionModel, args_1: GridRowsLookup) => Map<GridRowId, {
2249
- [key: string]: any;
2250
- }> & {
2251
- clearCache: () => void;
2252
- }> & {
2253
- clearCache: () => void;
2254
- };
2255
- declare const selectedIdsLookupSelector: ((state: {
2256
- rows: GridRowsState;
2257
- editRows: GridEditRowsModel;
2258
- pagination: GridPaginationState;
2259
- columns: GridColumnsState;
2260
- columnReorder: GridColumnReorderState;
2261
- columnResize: GridColumnResizeState;
2262
- columnMenu: GridColumnMenuState;
2263
- sorting: GridSortingState;
2264
- focus: GridFocusState;
2265
- tabIndex: GridTabIndexState;
2266
- selection: GridSelectionModel;
2267
- filter: GridFilterState;
2268
- preferencePanel: GridPreferencePanelState;
2269
- density: GridDensityState;
2270
- rowGrouping: GridRowGroupingState;
2271
- error?: any;
2272
- pinnedColumns: GridPinnedColumns;
2273
- }) => {}) & reselect.OutputSelectorFields<(args_0: GridSelectionModel) => {
2274
- clearCache: () => void;
2275
- }> & {
2276
- clearCache: () => void;
2277
- };
2278
-
2279
- interface GridSortingState {
2280
- sortedRows: GridRowId[];
2281
- sortModel: GridSortModel;
2282
- }
2283
- interface GridSortingInitialState {
2284
- sortModel?: GridSortModel;
2285
- }
2286
- declare type GridSortingModelApplier = (rowList: GridRowTreeNodeConfig[]) => GridRowId[];
2287
- interface GridSortingParams {
2288
- sortRowList: GridSortingModelApplier | null;
2289
- }
2290
- declare type GridSortingMethod = (params: GridSortingParams) => GridRowId[];
2291
- declare type GridSortingMethodCollection = {
2292
- [methodName: string]: GridSortingMethod;
2293
- };
2294
-
2295
- /**
2296
- * Get the id of the rows after the sorting process.
2297
- * @category Sorting
2298
- */
2299
- declare const gridSortedRowIdsSelector: ((state: {
2300
- rows: GridRowsState;
2301
- editRows: GridEditRowsModel;
2302
- pagination: GridPaginationState;
2303
- columns: GridColumnsState;
2304
- columnReorder: GridColumnReorderState;
2305
- columnResize: GridColumnResizeState;
2306
- columnMenu: GridColumnMenuState;
2307
- sorting: GridSortingState;
2308
- focus: GridFocusState;
2309
- tabIndex: GridTabIndexState;
2310
- selection: GridSelectionModel;
2311
- filter: GridFilterState;
2312
- preferencePanel: GridPreferencePanelState;
2313
- density: GridDensityState;
2314
- rowGrouping: GridRowGroupingState;
2315
- error?: any;
2316
- pinnedColumns: GridPinnedColumns;
2317
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridSortingState) => GridRowId[] & {
2318
- clearCache: () => void;
2319
- }> & {
2320
- clearCache: () => void;
2321
- };
2322
- /**
2323
- * Get the id and the model of the rows after the sorting process.
2324
- * @category Sorting
2325
- */
2326
- declare const gridSortedRowEntriesSelector: ((state: {
2327
- rows: GridRowsState;
2328
- editRows: GridEditRowsModel;
2329
- pagination: GridPaginationState;
2330
- columns: GridColumnsState;
2331
- columnReorder: GridColumnReorderState;
2332
- columnResize: GridColumnResizeState;
2333
- columnMenu: GridColumnMenuState;
2334
- sorting: GridSortingState;
2335
- focus: GridFocusState;
2336
- tabIndex: GridTabIndexState;
2337
- selection: GridSelectionModel;
2338
- filter: GridFilterState;
2339
- preferencePanel: GridPreferencePanelState;
2340
- density: GridDensityState;
2341
- rowGrouping: GridRowGroupingState;
2342
- error?: any;
2343
- pinnedColumns: GridPinnedColumns;
2344
- }) => {
2345
- id: GridRowId;
2346
- model: {
2347
- [key: string]: any;
2348
- };
2349
- }[]) & reselect.OutputSelectorFields<(args_0: GridRowId[], args_1: GridRowsLookup) => {
2350
- id: GridRowId;
2351
- model: {
2352
- [key: string]: any;
2353
- };
2354
- }[] & {
2355
- clearCache: () => void;
2356
- }> & {
2357
- clearCache: () => void;
2358
- };
2359
- /**
2360
- * Get the current sorting model.
2361
- * @category Sorting
2362
- */
2363
- declare const gridSortModelSelector: ((state: {
2364
- rows: GridRowsState;
2365
- editRows: GridEditRowsModel;
2366
- pagination: GridPaginationState;
2367
- columns: GridColumnsState;
2368
- columnReorder: GridColumnReorderState;
2369
- columnResize: GridColumnResizeState;
2370
- columnMenu: GridColumnMenuState;
2371
- sorting: GridSortingState;
2372
- focus: GridFocusState;
2373
- tabIndex: GridTabIndexState;
2374
- selection: GridSelectionModel;
2375
- filter: GridFilterState;
2376
- preferencePanel: GridPreferencePanelState;
2377
- density: GridDensityState;
2378
- rowGrouping: GridRowGroupingState;
2379
- error?: any;
2380
- pinnedColumns: GridPinnedColumns;
2381
- }) => GridSortModel) & reselect.OutputSelectorFields<(args_0: GridSortingState) => GridSortModel & {
2382
- clearCache: () => void;
2383
- }> & {
2384
- clearCache: () => void;
2385
- };
2386
- declare type GridSortColumnLookup = Record<string, {
2387
- sortDirection: GridSortDirection;
2388
- sortIndex?: number;
2389
- }>;
2390
- /**
2391
- * @category Sorting
2392
- * @ignore - do not document.
2393
- */
2394
- declare const gridSortColumnLookupSelector: ((state: {
2395
- rows: GridRowsState;
2396
- editRows: GridEditRowsModel;
2397
- pagination: GridPaginationState;
2398
- columns: GridColumnsState;
2399
- columnReorder: GridColumnReorderState;
2400
- columnResize: GridColumnResizeState;
2401
- columnMenu: GridColumnMenuState;
2402
- sorting: GridSortingState;
2403
- focus: GridFocusState;
2404
- tabIndex: GridTabIndexState;
2405
- selection: GridSelectionModel;
2406
- filter: GridFilterState;
2407
- preferencePanel: GridPreferencePanelState;
2408
- density: GridDensityState;
2409
- rowGrouping: GridRowGroupingState;
2410
- error?: any;
2411
- pinnedColumns: GridPinnedColumns;
2412
- }) => GridSortColumnLookup) & reselect.OutputSelectorFields<(args_0: GridSortModel) => GridSortColumnLookup & {
2413
- clearCache: () => void;
2414
- }> & {
2415
- clearCache: () => void;
2416
- };
2417
-
2418
- /**
2419
- * The size of a container.
2420
- */
2421
- interface ElementSize {
2422
- /**
2423
- * The height of a container or HTMLElement.
2424
- */
2425
- height: number;
2426
- /**
2427
- * The width of a container or HTMLElement.
2428
- */
2429
- width: number;
2430
- }
2431
-
2432
- interface GridDimensions {
2433
- /**
2434
- * The viewport size including scrollbars.
2435
- */
2436
- viewportOuterSize: ElementSize;
2437
- /**
2438
- * The viewport size not including scrollbars.
2439
- */
2440
- viewportInnerSize: ElementSize;
2441
- /**
2442
- * Indicates if a scroll is currently needed to go from the beginning of the first column to the end of the last column.
2443
- */
2444
- hasScrollX: boolean;
2445
- /**
2446
- * Indicates if a scroll is currently needed to go from the beginning of the first row to the end of the last row.
2447
- */
2448
- hasScrollY: boolean;
2449
- }
2450
- interface GridDimensionsApi {
2451
- /**
2452
- * Triggers a resize of the component and recalculation of width and height.
2453
- */
2454
- resize: () => void;
2455
- /**
2456
- * Returns the dimensions of the grid
2457
- * @returns {GridDimensions | null} The dimension information of the grid. If `null`, the grid is not ready yet.
2458
- */
2459
- getRootDimensions: () => GridDimensions | null;
2460
- /**
2461
- * Returns the amount of rows that are currently visible in the viewport
2462
- * @returns {number} The amount of rows visible in the viewport
2463
- * @ignore - do not document.
2464
- */
2465
- unstable_getViewportPageSize: () => number;
2466
- }
2467
-
2468
- declare const GRID_TREE_DATA_GROUPING_FIELD = "__tree_data_group__";
2469
-
2470
- declare type GridRowGroupingModel = string[];
2471
- interface GridRowGroupingState {
2472
- model: GridRowGroupingModel;
2473
- }
2474
- interface GridRowGroupingInitialState {
2475
- model?: GridRowGroupingModel;
2476
- }
2477
- interface GridRowGroupingApi {
2478
- /**
2479
- * Sets the columns to use as grouping criteria.
2480
- * @param {GridRowGroupingModel} model The columns to use as grouping criteria.
2481
- */
2482
- setRowGroupingModel: (model: GridRowGroupingModel) => void;
2483
- /**
2484
- * Adds the field to the row grouping model.
2485
- * @param {string} groupingCriteriaField The field from which we want to group the rows.
2486
- * @param {number | undefined} groupingIndex The grouping index at which we want to insert the new grouping criteria. By default, it will be inserted at the end of the model.
2487
- */
2488
- addRowGroupingCriteria: (groupingCriteriaField: string, groupingIndex?: number) => void;
2489
- /**
2490
- * sRemove the field from the row grouping model.
2491
- * @param {string} groupingCriteriaField The field from which we want to stop grouping the rows.
2492
- */
2493
- removeRowGroupingCriteria: (groupingCriteriaField: string) => void;
2494
- /**
2495
- * Sets the grouping index of a grouping criteria.
2496
- * @param {string} groupingCriteriaField The field of the grouping criteria from which we want to change the grouping index.
2497
- * @param {number} groupingIndex The new grouping index of this grouping criteria.
2498
- */
2499
- setRowGroupingCriteriaIndex: (groupingCriteriaField: string, groupingIndex: number) => void;
2500
- }
2501
-
2502
- declare const gridRowGroupingStateSelector: (state: GridState) => GridRowGroupingState;
2503
- declare const gridRowGroupingModelSelector: ((state: {
2504
- rows: GridRowsState;
2505
- editRows: GridEditRowsModel;
2506
- pagination: GridPaginationState;
2507
- columns: GridColumnsState;
2508
- columnReorder: GridColumnReorderState;
2509
- columnResize: GridColumnResizeState;
2510
- columnMenu: GridColumnMenuState;
2511
- sorting: GridSortingState;
2512
- focus: GridFocusState;
2513
- tabIndex: GridTabIndexState;
2514
- selection: GridSelectionModel;
2515
- filter: GridFilterState;
2516
- preferencePanel: GridPreferencePanelState;
2517
- density: GridDensityState;
2518
- rowGrouping: GridRowGroupingState;
2519
- error?: any;
2520
- pinnedColumns: GridPinnedColumns;
2521
- }) => GridRowGroupingModel) & reselect.OutputSelectorFields<(args_0: GridRowGroupingState) => GridRowGroupingModel & {
2522
- clearCache: () => void;
2523
- }> & {
2524
- clearCache: () => void;
1225
+ declare const gridVisibleRowCountSelector: OutputSelector<number>;
1226
+ /**
1227
+ * Get the amount of top level rows accessible after the filtering process.
1228
+ * @category Filtering
1229
+ */
1230
+ declare const gridVisibleTopLevelRowCountSelector: OutputSelector<number>;
1231
+ /**
1232
+ * @category Filtering
1233
+ * @ignore - do not document.
1234
+ */
1235
+ declare const gridFilterActiveItemsSelector: OutputSelector<GridFilterItem[]>;
1236
+ declare type GridFilterActiveItemsLookup = {
1237
+ [columnField: string]: GridFilterItem[];
2525
1238
  };
2526
- declare const gridRowGroupingSanitizedModelSelector: ((state: {
2527
- rows: GridRowsState;
2528
- editRows: GridEditRowsModel;
2529
- pagination: GridPaginationState;
2530
- columns: GridColumnsState;
2531
- columnReorder: GridColumnReorderState;
2532
- columnResize: GridColumnResizeState;
2533
- columnMenu: GridColumnMenuState;
2534
- sorting: GridSortingState;
2535
- focus: GridFocusState;
2536
- tabIndex: GridTabIndexState;
2537
- selection: GridSelectionModel;
2538
- filter: GridFilterState;
2539
- preferencePanel: GridPreferencePanelState;
2540
- density: GridDensityState;
2541
- rowGrouping: GridRowGroupingState;
2542
- error?: any;
2543
- pinnedColumns: GridPinnedColumns;
2544
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridRowGroupingModel, args_1: GridColumnLookup) => string[] & {
2545
- clearCache: () => void;
2546
- }> & {
2547
- clearCache: () => void;
2548
- };
1239
+ /**
1240
+ * @category Filtering
1241
+ * @ignore - do not document.
1242
+ */
1243
+ declare const gridFilterActiveItemsLookupSelector: OutputSelector<GridFilterActiveItemsLookup>;
2549
1244
 
2550
1245
  declare const GridFeatureModeConstant: {
2551
1246
  client: "client";
@@ -3029,6 +1724,18 @@ interface GridClasses {
3029
1724
  * Styles applied to the right pinned columns.
3030
1725
  */
3031
1726
  'pinnedColumns--right': string;
1727
+ /**
1728
+ * Styles applied to the pinned column headers.
1729
+ */
1730
+ pinnedColumnHeaders: string;
1731
+ /**
1732
+ * Styles applied to the left pinned column headers.
1733
+ */
1734
+ 'pinnedColumnHeaders--left': string;
1735
+ /**
1736
+ * Styles applied to the right pinned column headers.
1737
+ */
1738
+ 'pinnedColumnHeaders--right': string;
3032
1739
  /**
3033
1740
  * Styles applied to the root element.
3034
1741
  */
@@ -3093,10 +1800,7 @@ interface GridClasses {
3093
1800
  }
3094
1801
  declare type GridClassKey = keyof GridClasses;
3095
1802
  declare function getDataGridUtilityClass(slot: string): string;
3096
- declare const gridClasses: Record<"actionsCell" | "autoHeight" | "booleanCell" | "cell--editable" | "cell--editing" | "cell--textCenter" | "cell--textLeft" | "cell--textRight" | "cell--withRenderer" | "cell" | "cellCheckbox" | "checkboxInput" | "columnHeader--alignCenter" | "columnHeader--alignLeft" | "columnHeader--alignRight" | "columnHeader--dragging" | "columnHeader--moving" | "columnHeader--numeric" | "columnHeader--sortable" | "columnHeader--sorted" | "columnHeader" | "columnHeaderCheckbox" | "columnHeaderDraggableContainer" | "columnHeaderDropZone" | "columnHeaderTitle" | "columnHeaderTitleContainer" | "columnHeaders" | "columnHeadersInner" | "columnHeadersInner--scrollable" | "columnSeparator--resizable" | "columnSeparator--resizing" | "columnSeparator--sideLeft" | "columnSeparator--sideRight" | "columnSeparator" | "columnsPanel" | "columnsPanelRow" | "panel" | "panelHeader" | "panelWrapper" | "panelContent" | "panelFooter" | "paper" | "editBooleanCell" | "editInputCell" | "filterForm" | "filterIcon" | "footerContainer" | "iconButtonContainer" | "iconSeparator" | "main" | "menu" | "menuIcon" | "menuIconButton" | "menuOpen" | "menuList" | "overlay" | "root" | "row--editable" | "row--editing" | "row" | "rowCount" | "scrollArea--left" | "scrollArea--right" | "scrollArea" | "selectedRowCount" | "sortIcon" | "toolbarContainer" | "toolbarFilterList" | "virtualScroller" | "virtualScrollerContent" | "virtualScrollerRenderZone" | "pinnedColumns" | "pinnedColumns--left" | "pinnedColumns--right" | "withBorder" | "treeDataGroupingCell" | "treeDataGroupingCellToggle" | "groupingCriteriaCell" | "groupingCriteriaCellToggle", string>;
3097
-
3098
- declare type GridInputSelectionModel = GridRowId[] | GridRowId;
3099
- declare type GridSelectionModel = GridRowId[];
1803
+ declare const gridClasses: Record<"actionsCell" | "autoHeight" | "booleanCell" | "cell--editable" | "cell--editing" | "cell--textCenter" | "cell--textLeft" | "cell--textRight" | "cell--withRenderer" | "cell" | "cellCheckbox" | "checkboxInput" | "columnHeader--alignCenter" | "columnHeader--alignLeft" | "columnHeader--alignRight" | "columnHeader--dragging" | "columnHeader--moving" | "columnHeader--numeric" | "columnHeader--sortable" | "columnHeader--sorted" | "columnHeader" | "columnHeaderCheckbox" | "columnHeaderDraggableContainer" | "columnHeaderDropZone" | "columnHeaderTitle" | "columnHeaderTitleContainer" | "columnHeaders" | "columnHeadersInner" | "columnHeadersInner--scrollable" | "columnSeparator--resizable" | "columnSeparator--resizing" | "columnSeparator--sideLeft" | "columnSeparator--sideRight" | "columnSeparator" | "columnsPanel" | "columnsPanelRow" | "panel" | "panelHeader" | "panelWrapper" | "panelContent" | "panelFooter" | "paper" | "editBooleanCell" | "editInputCell" | "filterForm" | "filterIcon" | "footerContainer" | "iconButtonContainer" | "iconSeparator" | "main" | "menu" | "menuIcon" | "menuIconButton" | "menuOpen" | "menuList" | "overlay" | "root" | "row--editable" | "row--editing" | "row" | "rowCount" | "scrollArea--left" | "scrollArea--right" | "scrollArea" | "selectedRowCount" | "sortIcon" | "toolbarContainer" | "toolbarFilterList" | "virtualScroller" | "virtualScrollerContent" | "virtualScrollerRenderZone" | "pinnedColumns" | "pinnedColumns--left" | "pinnedColumns--right" | "pinnedColumnHeaders" | "pinnedColumnHeaders--left" | "pinnedColumnHeaders--right" | "withBorder" | "treeDataGroupingCell" | "treeDataGroupingCellToggle" | "groupingCriteriaCell" | "groupingCriteriaCellToggle", string>;
3100
1804
 
3101
1805
  /**
3102
1806
  * Overrideable components props dynamically passed to the component at rendering.
@@ -3127,6 +1831,12 @@ interface GridSlotsComponentsProps {
3127
1831
  toolbar?: any;
3128
1832
  }
3129
1833
 
1834
+ interface GridExperimentalFeatures {
1835
+ /**
1836
+ * Will be part of the premium-plan when fully ready.
1837
+ */
1838
+ preventCommitWhileValidating: boolean;
1839
+ }
3130
1840
  /**
3131
1841
  * The props users can give to the `DataGrid` component.
3132
1842
  */
@@ -3418,6 +2128,12 @@ interface DataGridPropsWithoutDefaultValue extends CommonProps {
3418
2128
  * @returns {string} The CSS class to apply to the row.
3419
2129
  */
3420
2130
  getRowClassName?: (params: GridRowParams) => string;
2131
+ /**
2132
+ * Function that sets the row height per row.
2133
+ * @param {GridRowHeightParams} params With all properties from [[GridRowHeightParams]].
2134
+ * @returns {GridRowHeightReturnValue} The row height value. If `null` or `undefined` then the default row height is applied.
2135
+ */
2136
+ getRowHeight?: (params: GridRowHeightParams) => GridRowHeightReturnValue;
3421
2137
  /**
3422
2138
  * Callback fired when a cell is rendered, returns true if the cell is editable.
3423
2139
  * @param {GridCellParams} params With all properties from [[GridCellParams]].
@@ -3717,6 +2433,11 @@ interface DataGridPropsWithoutDefaultValue extends CommonProps {
3717
2433
  * The system prop that allows defining system overrides as well as additional CSS styles.
3718
2434
  */
3719
2435
  sx?: SxProps<Theme>;
2436
+ /**
2437
+ * Features under development.
2438
+ * For each feature, if the flag is not explicitly set to `true`, the feature will be fully disabled and any property / method call will not have any effect.
2439
+ */
2440
+ experimentalFeatures?: Partial<GridExperimentalFeatures>;
3720
2441
  }
3721
2442
 
3722
2443
  /**
@@ -3839,43 +2560,69 @@ interface DataGridProPropsWithoutDefaultValue extends DataGridPropsWithoutDefaul
3839
2560
  declare const GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = "__row_group_by_columns_group__";
3840
2561
  declare const getRowGroupingFieldFromGroupingCriteria: (groupingCriteria: string | null) => string;
3841
2562
 
3842
- interface GridColumnReorderState {
3843
- dragCol: string;
2563
+ interface GridPinnedColumns {
2564
+ left?: string[];
2565
+ right?: string[];
3844
2566
  }
3845
- interface GridCanBeReorderedPreProcessingContext {
3846
- targetIndex: number;
2567
+ declare enum GridPinnedPosition {
2568
+ left = "left",
2569
+ right = "right"
2570
+ }
2571
+ /**
2572
+ * The column pinning API interface that is available in the grid [[apiRef]].
2573
+ */
2574
+ interface GridColumnPinningApi {
2575
+ /**
2576
+ * Pins a column to the left or right side of the grid.
2577
+ * @param {string} field The column field to pin.
2578
+ * @param {GridPinnedPosition} side Which side to pin the column.
2579
+ */
2580
+ pinColumn: (field: string, side: GridPinnedPosition) => void;
2581
+ /**
2582
+ * Unpins a column.
2583
+ * @param {string} field The column field to unpin.
2584
+ */
2585
+ unpinColumn: (field: string) => void;
2586
+ /**
2587
+ * Returns which columns are pinned.
2588
+ * @returns {GridPinnedColumns} An object containing the pinned columns.
2589
+ */
2590
+ getPinnedColumns: () => GridPinnedColumns;
2591
+ /**
2592
+ * Changes the pinned columns.
2593
+ * @param {GridPinnedColumns} pinnedColumns An object containing the columns to pin.
2594
+ */
2595
+ setPinnedColumns: (pinnedColumns: GridPinnedColumns) => void;
2596
+ /**
2597
+ * Returns which side a column is pinned to.
2598
+ * @param {string} field The column field to check.
2599
+ * @returns {string | false} Which side the column is pinned or `false` if not pinned.
2600
+ */
2601
+ isColumnPinned: (field: string) => GridPinnedPosition | false;
3847
2602
  }
3848
2603
 
3849
- declare const gridColumnReorderSelector: (state: GridState) => GridColumnReorderState;
3850
- declare const gridColumnReorderDragColSelector: ((state: {
3851
- rows: GridRowsState;
3852
- editRows: GridEditRowsModel;
3853
- pagination: GridPaginationState;
3854
- columns: GridColumnsState;
3855
- columnReorder: GridColumnReorderState;
3856
- columnResize: GridColumnResizeState;
3857
- columnMenu: GridColumnMenuState;
3858
- sorting: GridSortingState;
3859
- focus: GridFocusState;
3860
- tabIndex: GridTabIndexState;
3861
- selection: GridSelectionModel;
3862
- filter: GridFilterState;
3863
- preferencePanel: GridPreferencePanelState;
3864
- density: GridDensityState;
3865
- rowGrouping: GridRowGroupingState;
3866
- error?: any;
3867
- pinnedColumns: GridPinnedColumns;
3868
- }) => string) & reselect.OutputSelectorFields<(args_0: GridColumnReorderState) => string & {
3869
- clearCache: () => void;
3870
- }> & {
3871
- clearCache: () => void;
3872
- };
2604
+ declare type GridColumnPinningState = GridPinnedColumns;
2605
+
2606
+ /**
2607
+ * The grid rows total height and row possitions.
2608
+ */
2609
+ interface GridRowsMetaState {
2610
+ /**
2611
+ * The sum of of all visible grid rows in the current rows.
2612
+ */
2613
+ currentPageTotalHeight: number;
2614
+ /**
2615
+ * The grid rows possitions.
2616
+ */
2617
+ positions: number[];
2618
+ }
3873
2619
 
3874
2620
  /**
3875
2621
  * TODO: Distinguish pro and community states
3876
2622
  */
3877
2623
  interface GridState {
3878
2624
  rows: GridRowsState;
2625
+ rowsMeta: GridRowsMetaState;
3879
2626
  editRows: GridEditRowsModel;
3880
2627
  pagination: GridPaginationState;
3881
2628
  columns: GridColumnsState;
@@ -3935,6 +2682,20 @@ interface GridValueOptionsParams {
3935
2682
  row?: GridRowModel;
3936
2683
  }
3937
2684
 
2685
+ /**
2686
+ * The size of a container.
2687
+ */
2688
+ interface ElementSize {
2689
+ /**
2690
+ * The height of a container or HTMLElement.
2691
+ */
2692
+ height: number;
2693
+ /**
2694
+ * The width of a container or HTMLElement.
2695
+ */
2696
+ width: number;
2697
+ }
2698
+
3938
2699
  declare type PreProcessorCallback = (value: any, params?: any) => any;
3939
2700
  declare enum GridPreProcessingGroup {
3940
2701
  hydrateColumns = "hydrateColumns",
@@ -4373,6 +3134,11 @@ interface GridCoreApi {
4373
3134
  * @param {any} props Props to be passed to the `ErrorOverlay` component.
4374
3135
  */
4375
3136
  showError: (props: any) => void;
3137
+ /**
3138
+ * Unique identifier for each component instance in a page.
3139
+ * @ignore - do not document.
3140
+ */
3141
+ instanceId: number;
4376
3142
  }
4377
3143
 
4378
3144
  interface GridDensityOption {
@@ -4444,8 +3210,9 @@ interface GridEditRowApi {
4444
3210
  * Commonly used inside the edit cell component.
4445
3211
  * @param {GridEditCellValueParams} params Contains the id, field and value to set.
4446
3212
  * @param {React.SyntheticEvent} event The event to pass forward.
3213
+ * @returns {Promise<boolean> | void} A promise with the validation status if `preventCommitWhileValidating` is `true`. Otherwise, void.
4447
3214
  */
4448
- setEditCellValue: (params: GridEditCellValueParams, event?: MuiBaseEvent) => void;
3215
+ setEditCellValue: (params: GridEditCellValueParams, event?: MuiBaseEvent) => Promise<boolean> | void;
4449
3216
  /**
4450
3217
  * Updates the field at the given id with the value stored in the edit row model.
4451
3218
  * @param {GridCommitCellChangeParams} params The id and field to commit to.
@@ -4511,6 +3278,19 @@ interface GridRowApi {
4511
3278
  setRowChildrenExpansion: (id: GridRowId, isExpanded: boolean) => void;
4512
3279
  }
4513
3280
 
3281
+ /**
3282
+ * The Row Meta API interface that is available in the grid `apiRef`.
3283
+ */
3284
+ interface GridRowsMetaApi {
3285
+ /**
3286
+ * Gets target row height.
3287
+ * @param {GridRowId} id The id of the row.
3288
+ * @returns {number} The target row height.
3289
+ * @ignore - do not document.
3290
+ */
3291
+ unstable_getRowHeight: (id: GridRowId) => number;
3292
+ }
3293
+
4514
3294
  /**
4515
3295
  * The selection API interface that is available in the grid [[apiRef]].
4516
3296
  */
@@ -4690,6 +3470,7 @@ interface GridLocaleText {
4690
3470
  filterOperatorOnOrBefore: string;
4691
3471
  filterOperatorIsEmpty: string;
4692
3472
  filterOperatorIsNotEmpty: string;
3473
+ filterOperatorIsAnyOf: string;
4693
3474
  filterValueAny: string;
4694
3475
  filterValueTrue: string;
4695
3476
  filterValueFalse: string;
@@ -4735,7 +3516,7 @@ interface GridLocaleTextApi {
4735
3516
  }
4736
3517
 
4737
3518
  /**
4738
- * The options to apply an export.
3519
+ * The options applicable to any export format.
4739
3520
  */
4740
3521
  interface GridExportOptions {
4741
3522
  /**
@@ -4749,6 +3530,12 @@ interface GridExportOptions {
4749
3530
  */
4750
3531
  allColumns?: boolean;
4751
3532
  }
3533
+ interface GridCsvGetRowsToExportParams {
3534
+ /**
3535
+ * The API of the grid.
3536
+ */
3537
+ apiRef: GridApiRef;
3538
+ }
4752
3539
  /**
4753
3540
  * The options to apply on the CSV export.
4754
3541
  */
@@ -4774,6 +3561,12 @@ interface GridCsvExportOptions extends GridExportOptions {
4774
3561
  * @default true
4775
3562
  */
4776
3563
  includeHeaders?: boolean;
3564
+ /**
3565
+ * Function that returns the id of the rows to export on the order they should be exported.
3566
+ * @param {GridCsvGetRowsToExportParams} params With all properties from [[GridCsvGetRowsToExportParams]].
3567
+ * @returns {GridRowId[]} The id of the rows to export.
3568
+ */
3569
+ getRowsToExport?: (params: GridCsvGetRowsToExportParams) => GridRowId[];
4777
3570
  }
4778
3571
  /**
4779
3572
  * The options to apply on the Print export.
@@ -4990,6 +3783,15 @@ interface GridScrollApi {
4990
3783
  scrollToIndexes: (params: Partial<GridCellIndexCoordinates>) => boolean;
4991
3784
  }
4992
3785
 
3786
+ interface GridVirtualScrollerApi {
3787
+ /**
3788
+ * Get the current grid rendering context.
3789
+ * @returns {GridRenderContext} The `GridRenderContext`.
3790
+ * @ignore - do not document.
3791
+ */
3792
+ unstable_getRenderContext: () => GridRenderContext;
3793
+ }
3794
+
4993
3795
  declare type GridSortDirection = 'asc' | 'desc' | null | undefined;
4994
3796
  interface GridSortCellParams {
4995
3797
  id: GridRowId;
@@ -5386,10 +4188,46 @@ interface GridLoggerApi {
5386
4188
  getLogger: (name: string) => Logger;
5387
4189
  }
5388
4190
 
4191
+ interface GridDimensions {
4192
+ /**
4193
+ * The viewport size including scrollbars.
4194
+ */
4195
+ viewportOuterSize: ElementSize;
4196
+ /**
4197
+ * The viewport size not including scrollbars.
4198
+ */
4199
+ viewportInnerSize: ElementSize;
4200
+ /**
4201
+ * Indicates if a scroll is currently needed to go from the beginning of the first column to the end of the last column.
4202
+ */
4203
+ hasScrollX: boolean;
4204
+ /**
4205
+ * Indicates if a scroll is currently needed to go from the beginning of the first row to the end of the last row.
4206
+ */
4207
+ hasScrollY: boolean;
4208
+ }
4209
+ interface GridDimensionsApi {
4210
+ /**
4211
+ * Triggers a resize of the component and recalculation of width and height.
4212
+ */
4213
+ resize: () => void;
4214
+ /**
4215
+ * Returns the dimensions of the grid
4216
+ * @returns {GridDimensions | null} The dimension information of the grid. If `null`, the grid is not ready yet.
4217
+ */
4218
+ getRootDimensions: () => GridDimensions | null;
4219
+ /**
4220
+ * Returns the amount of rows that are currently visible in the viewport
4221
+ * @returns {number} The amount of rows visible in the viewport
4222
+ * @ignore - do not document.
4223
+ */
4224
+ unstable_getViewportPageSize: () => number;
4225
+ }
4226
+
5389
4227
  /**
5390
4228
  * The full grid API.
5391
4229
  */
5392
- interface GridApi extends GridCoreApi, GridStateApi, GridLoggerApi, GridPreProcessingApi, GridRowGroupsPreProcessingApi, GridDensityApi, GridDimensionsApi, GridRowApi, GridEditRowApi, GridParamsApi, GridColumnApi, GridSelectionApi, GridSortApi, GridPaginationApi, GridCsvExportApi, GridFocusApi, GridFilterApi, GridColumnMenuApi, GridPreferencesPanelApi, GridPrintExportApi, GridDisableVirtualizationApi, GridLocaleTextApi, GridClipboardApi, GridScrollApi, GridRowGroupingApi, GridColumnPinningApi {
4230
+ interface GridApi extends GridCoreApi, GridStateApi, GridLoggerApi, GridPreProcessingApi, GridRowGroupsPreProcessingApi, GridDensityApi, GridDimensionsApi, GridRowApi, GridRowsMetaApi, GridEditRowApi, GridParamsApi, GridColumnApi, GridSelectionApi, GridSortApi, GridPaginationApi, GridCsvExportApi, GridFocusApi, GridFilterApi, GridColumnMenuApi, GridPreferencesPanelApi, GridPrintExportApi, GridDisableVirtualizationApi, GridLocaleTextApi, GridClipboardApi, GridScrollApi, GridRowGroupingApi, GridVirtualScrollerApi, GridColumnPinningApi {
5393
4231
  }
5394
4232
 
5395
4233
  /**
@@ -5537,7 +4375,7 @@ interface GridValueFormatterParams {
5537
4375
  */
5538
4376
  field: string;
5539
4377
  /**
5540
- * The cell value, but if the column has valueGetter, use getValue.
4378
+ * The cell value, if the column has valueGetter it is the value returned by it.
5541
4379
  */
5542
4380
  value: GridCellValue;
5543
4381
  /**
@@ -6191,6 +5029,110 @@ declare const GRID_EXPERIMENTAL_ENABLED: boolean;
6191
5029
 
6192
5030
  declare const GRID_DEFAULT_LOCALE_TEXT: GridLocaleText;
6193
5031
 
5032
+ declare const gridColumnMenuSelector: (state: GridState) => GridColumnMenuState;
5033
+
5034
+ declare const gridColumnResizeSelector: (state: GridState) => GridColumnResizeState;
5035
+ declare const gridResizingColumnFieldSelector: OutputSelector<string>;
5036
+
5037
+ declare const gridPinnedColumnsSelector: (state: GridState) => GridPinnedColumns;
5038
+
5039
+ declare const gridColumnsSelector: (state: GridState) => GridColumnsState;
5040
+ declare const allGridColumnsFieldsSelector: (state: GridState) => string[];
5041
+ declare const gridColumnLookupSelector: (state: GridState) => GridColumnLookup;
5042
+ declare const allGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5043
+ declare const gridColumnVisibilityModelSelector: OutputSelector<GridColumnVisibilityModel>;
5044
+ declare const visibleGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5045
+ declare const gridVisibleColumnFieldsSelector: OutputSelector<string[]>;
5046
+ declare const gridColumnsMetaSelector: OutputSelector<{
5047
+ totalWidth: number;
5048
+ positions: number[];
5049
+ }>;
5050
+ declare const filterableGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5051
+ declare const filterableGridColumnsIdsSelector: OutputSelector<string[]>;
5052
+ declare const visibleGridColumnsLengthSelector: OutputSelector<number>;
5053
+ declare const gridColumnsTotalWidthSelector: OutputSelector<number>;
5054
+
5055
+ /**
5056
+ * @deprecated Should have been internal only, you can inline the logic.
5057
+ */
5058
+ declare const getGridColDef: (columnTypes: GridColumnTypesRecord, type: GridColType | undefined) => GridColTypeDef;
5059
+
5060
+ declare const gridDensitySelector: (state: GridState) => GridDensityState;
5061
+ declare const gridDensityValueSelector: OutputSelector<GridDensity>;
5062
+ declare const gridDensityRowHeightSelector: OutputSelector<number>;
5063
+ declare const gridDensityHeaderHeightSelector: OutputSelector<number>;
5064
+ declare const gridDensityFactorSelector: OutputSelector<number>;
5065
+
5066
+ declare const gridEditRowsStateSelector: (state: GridState) => GridEditRowsModel;
5067
+
5068
+ declare const gridFocusStateSelector: (state: GridState) => GridFocusState;
5069
+ declare const gridFocusCellSelector: OutputSelector<GridCellIdentifier | null>;
5070
+ declare const gridFocusColumnHeaderSelector: OutputSelector<GridColumnIdentifier | null>;
5071
+ declare const gridTabIndexStateSelector: (state: GridState) => GridTabIndexState;
5072
+ declare const gridTabIndexCellSelector: OutputSelector<GridCellIdentifier | null>;
5073
+ declare const gridTabIndexColumnHeaderSelector: OutputSelector<GridColumnIdentifier | null>;
5074
+
5075
+ declare const gridPreferencePanelStateSelector: (state: GridState) => GridPreferencePanelState;
5076
+
5077
+ declare const gridRowsMetaSelector: (state: GridState) => GridRowsMetaState;
5078
+
5079
+ declare const gridRowsStateSelector: (state: GridState) => GridRowsState;
5080
+ declare const gridRowCountSelector: OutputSelector<number>;
5081
+ declare const gridTopLevelRowCountSelector: OutputSelector<number>;
5082
+ declare const gridRowsLookupSelector: OutputSelector<GridRowsLookup>;
5083
+ declare const gridRowTreeSelector: OutputSelector<GridRowTreeConfig>;
5084
+ declare const gridRowGroupingNameSelector: OutputSelector<string>;
5085
+ declare const gridRowTreeDepthSelector: OutputSelector<number>;
5086
+ declare const gridRowIdsSelector: OutputSelector<GridRowId[]>;
5087
+
5088
+ declare const gridSelectionStateSelector: (state: GridState) => GridSelectionModel;
5089
+ declare const selectedGridRowsCountSelector: OutputSelector<number>;
5090
+ declare const selectedGridRowsSelector: OutputSelector<Map<GridRowId, {
5091
+ [key: string]: any;
5092
+ }>>;
5093
+ declare const selectedIdsLookupSelector: OutputSelector<{}>;
5094
+
5095
+ /**
5096
+ * @category Sorting
5097
+ * @ignore - do not document.
5098
+ */
5099
+ declare const gridSortingStateSelector: (state: GridState) => GridSortingState;
5100
+ /**
5101
+ * Get the id of the rows after the sorting process.
5102
+ * @category Sorting
5103
+ */
5104
+ declare const gridSortedRowIdsSelector: OutputSelector<GridRowId[]>;
5105
+ /**
5106
+ * Get the id and the model of the rows after the sorting process.
5107
+ * @category Sorting
5108
+ */
5109
+ declare const gridSortedRowEntriesSelector: OutputSelector<{
5110
+ id: GridRowId;
5111
+ model: {
5112
+ [key: string]: any;
5113
+ };
5114
+ }[]>;
5115
+ /**
5116
+ * Get the current sorting model.
5117
+ * @category Sorting
5118
+ */
5119
+ declare const gridSortModelSelector: OutputSelector<GridSortModel>;
5120
+ declare type GridSortColumnLookup = Record<string, {
5121
+ sortDirection: GridSortDirection;
5122
+ sortIndex?: number;
5123
+ }>;
5124
+ /**
5125
+ * @category Sorting
5126
+ * @ignore - do not document.
5127
+ */
5128
+ declare const gridSortColumnLookupSelector: OutputSelector<GridSortColumnLookup>;
5129
+
5130
+ declare const gridStringOrNumberComparator: GridComparatorFn;
5131
+ declare const gridNumberComparator: GridComparatorFn;
5132
+ declare const gridDateComparator: (value1: GridCellValue, value2: GridCellValue) => number;
5133
+
5134
+ declare const GRID_TREE_DATA_GROUPING_FIELD = "__tree_data_group__";
5135
+
6194
5136
  /**
6195
5137
  * @deprecated Use `apiRef.current` instead.
6196
5138
  */
@@ -6221,8 +5163,10 @@ declare function useGridApiOptionHandler<E extends GridEvents>(apiRef: GridApiRe
6221
5163
 
6222
5164
  declare function useGridApiMethod<T extends Partial<GridApi>>(apiRef: GridApiRef, apiMethods: T, apiName: string): void;
6223
5165
 
6224
- declare function useGridApiRef(): GridApiRef;
6225
- declare function useGridApiRef(apiRefProp: GridApiRef | undefined): GridApiRef;
5166
+ /**
5167
+ * Hook that instantiate a [[GridApiRef]].
5168
+ */
5169
+ declare const useGridApiRef: () => GridApiRef;
6226
5170
 
6227
5171
  declare function useGridLogger(apiRef: GridApiRef, name: string): Logger;
6228
5172
 
@@ -6230,7 +5174,7 @@ declare const useGridRootProps: <Props extends DataGridProcessedProps | DataGrid
6230
5174
 
6231
5175
  declare function useGridScrollFn(apiRef: GridApiRef, renderingZoneElementRef: React$1.RefObject<HTMLDivElement>, columnHeadersElementRef: React$1.RefObject<HTMLDivElement>): [GridScrollFn];
6232
5176
 
6233
- declare const useGridSelector: <T>(apiRef: GridApiRef, selector: (state: GridState) => T) => T;
5177
+ declare const useGridSelector: <T>(apiRef: GridApiRef, selector: OutputSelector<T> | ((state: GridState) => T)) => T;
6234
5178
 
6235
5179
  /**
6236
5180
  * @deprecated Use `apiRef.current.state`, `apiRef.current.setState` and `apiRef.current.forceUpdate` instead.
@@ -6299,8 +5243,8 @@ declare const DataGrid: React$1.MemoExoticComponent<React$1.ForwardRefExoticComp
6299
5243
  pagination?: true | undefined;
6300
5244
  } & React$1.RefAttributes<HTMLDivElement>>>;
6301
5245
 
6302
- declare const useDataGridComponent: (apiRef: GridApiRef, props: DataGridProcessedProps) => void;
5246
+ declare const useDataGridComponent: (props: DataGridProcessedProps) => GridApiRef;
6303
5247
 
6304
5248
  declare const MAX_PAGE_SIZE = 100;
6305
5249
 
6306
- export { AutoSizerProps, AutoSizerSize, CursorCoordinates, DEFAULT_GRID_COL_TYPE_KEY, DataGrid, DataGridProps, ElementSize, GRID_ACTIONS_COL_DEF, GRID_BOOLEAN_COL_DEF, GRID_CHECKBOX_SELECTION_COL_DEF, GRID_DATETIME_COL_DEF, GRID_DATE_COL_DEF, GRID_DEFAULT_LOCALE_TEXT, GRID_EXPERIMENTAL_ENABLED, GRID_NUMERIC_COL_DEF, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, GRID_SINGLE_SELECT_COL_DEF, GRID_STRING_COL_DEF, GRID_TREE_DATA_GROUPING_FIELD, GridActionsCell, GridActionsCellItem, GridActionsCellItemProps, GridActionsColDef, GridAddIcon, GridAlignment, GridApi, GridApiContext, GridApiRef, GridArrowDownwardIcon, GridArrowUpwardIcon, GridAutoSizer, GridBody, GridCallbackDetails, GridCell, GridCellCheckboxForwardRef, GridCellCheckboxRenderer, GridCellClassFn, GridCellClassNamePropType, GridCellEditCommitParams, GridCellEventLookup, GridCellIdentifier, GridCellIndexCoordinates, GridCellMode, GridCellModes, GridCellParams, GridCellProps, GridCellValue, GridCheckCircleIcon, GridCheckIcon, GridClassKey, GridClasses, GridClipboardApi, GridCloseIcon, GridColDef, GridColType, GridColTypeDef, GridColumnApi, GridColumnHeaderClassFn, GridColumnHeaderClassNamePropType, GridColumnHeaderEventLookup, GridColumnHeaderIndexCoordinates, GridColumnHeaderItem, GridColumnHeaderMenu, GridColumnHeaderMenuProps, GridColumnHeaderParams, GridColumnHeaderSeparator, GridColumnHeaderSeparatorProps, GridColumnHeaderSeparatorSides, GridColumnHeaderSortIcon, GridColumnHeaderSortIconProps, GridColumnHeaderTitle, GridColumnHeaderTitleProps, GridColumnIcon, GridColumnIdentifier, GridColumnLookup, GridColumnMenu, GridColumnMenuApi, GridColumnMenuContainer, GridColumnMenuProps, GridColumnMenuState, GridColumnOrderChangeParams, GridColumnPinningApi, GridColumnPinningMenuItems, GridColumnPinningState, GridColumnReorderState, GridColumnResizeParams, GridColumnResizeState, GridColumnTypesRecord, GridColumnVisibilityChangeParams, GridColumnVisibilityModel, GridColumns, GridColumnsInitialState, GridColumnsMenuItem, GridColumnsMeta, GridColumnsPanel, GridColumnsState, GridCommitCellChangeParams, GridComparatorFn, GridControlledStateEventLookup, GridCoreApi, GridCsvExportApi, GridCsvExportOptions, GridDensity, GridDensityApi, GridDensityOption, GridDensityState, GridDensityTypes, GridDimensions, GridDimensionsApi, GridDisableVirtualizationApi, GridDragIcon, GridEditCellProps, GridEditCellPropsParams, GridEditCellValueParams, GridEditInputCell, GridEditMode, GridEditModes, GridEditRowApi, GridEditRowProps, GridEditRowsModel, GridEditSingleSelectCell, GridEnrichedColDef, GridErrorHandler, GridEventListener, GridEventLookup, GridEventPublisher, GridEvents, GridEventsStr, GridExpandMoreIcon, GridExportFormat, GridExportOptions, GridFeatureMode, GridFeatureModeConstant, GridFilterActiveItemsLookup, GridFilterAltIcon, GridFilterApi, GridFilterForm, GridFilterFormProps, GridFilterInitialState, GridFilterInputDate, GridFilterInputDateProps, GridFilterInputMultipleSingleSelect, GridFilterInputMultipleSingleSelectProps, GridFilterInputMultipleValue, GridFilterInputMultipleValueProps, GridFilterInputSingleSelect, GridFilterInputSingleSelectProps, GridFilterInputValue, GridFilterInputValueProps, GridFilterItem, GridFilterItemProps, GridFilterListIcon, GridFilterMenuItem, GridFilterModel, GridFilterOperator, GridFilterPanel, GridFilterState, GridFocusApi, GridFocusState, GridFooter, GridFooterContainer, GridFooterContainerProps, GridFooterPlaceholder, GridGroupingColDefOverride, GridGroupingColDefOverrideParams, GridGroupingValueGetterParams, GridHeader, GridHeaderCheckbox, GridHeaderPlaceholder, GridHeaderSelectionCheckboxParams, GridIconSlotsComponent, GridInitialState, GridInputSelectionModel, GridKeyValue, GridKeyboardArrowRight, GridLinkOperator, GridLoadIcon, GridLoadingOverlay, GridLocaleText, GridLocaleTextApi, GridMenu, GridMenuIcon, GridMenuProps, GridMoreVertIcon, GridNativeColTypes, GridNoRowsOverlay, GridOverlay, GridOverlayProps, GridOverlays, GridPagination, GridPaginationApi, GridPaginationInitialState, GridPaginationState, GridPanel, GridPanelClasses, GridPanelContent, GridPanelFooter, GridPanelHeader, GridPanelProps, GridPanelWrapper, GridParamsApi, GridPinnedColumns, GridPinnedPosition, GridPreProcessEditCellProps, GridPreferencePanelInitialState, GridPreferencePanelState, GridPreferencePanelsValue, GridPreferencesPanel, GridPreferencesPanelApi, GridPrintExportApi, GridPrintExportOptions, GridRenderCellParams, GridRenderColumnsProps, GridRenderContext, GridRenderContextProps, GridRenderEditCellParams, GridRenderPaginationProps, GridRenderRowProps, GridRoot, GridRootContainerRef, GridRootProps, GridRow, GridRowApi, GridRowCount, GridRowData, GridRowEntry, GridRowEventLookup, GridRowGroupingApi, GridRowGroupingInitialState, GridRowGroupingModel, GridRowGroupingState, GridRowId, GridRowIdGetter, GridRowMode, GridRowModel, GridRowModelUpdate, GridRowModes, GridRowParams, GridRowProps, GridRowScrollEndParams, GridRowSelectionCheckboxParams, GridRowTreeConfig, GridRowTreeNodeConfig, GridRowsLookup, GridRowsProp, GridRowsState, GridSaveAltIcon, GridScrollApi, GridScrollArea, GridScrollFn, GridScrollParams, GridSearchIcon, GridSelectedRowCount, GridSelectionApi, GridSelectionModel, GridSeparatorIcon, GridSignature, GridSlotsComponent, GridSlotsComponentsProps, GridSortApi, GridSortCellParams, GridSortColumnLookup, GridSortDirection, GridSortItem, GridSortModel, GridSortModelParams, GridSortingInitialState, GridSortingState, GridState, GridStateApi, GridStateChangeParams, GridStateColDef, GridTabIndexState, GridTableRowsIcon, GridToolbar, GridToolbarColumnsButton, GridToolbarContainer, GridToolbarContainerProps, GridToolbarDensitySelector, GridToolbarExport, GridToolbarExportProps, GridToolbarFilterButton, GridToolbarFilterButtonProps, GridToolbarProps, GridTranslationKeys, GridTreeDataGroupingCell, GridTripleDotsVerticalIcon, GridTypeFilterInputValueProps, GridUpdateAction, GridValueFormatterParams, GridValueGetterFullParams, GridValueGetterParams, GridValueOptionsParams, GridValueSetterParams, GridViewHeadlineIcon, GridViewStreamIcon, HideGridColMenuItem, Logger, MAX_PAGE_SIZE, MuiBaseEvent, MuiEvent, SUBMIT_FILTER_DATE_STROKE_TIME, SUBMIT_FILTER_STROKE_TIME, SortGridMenuItems, allGridColumnsFieldsSelector, allGridColumnsSelector, arSD, bgBG, checkGridRowIdIsValid, createUseGridApiEventHandler, csCZ, deDE, elGR, enUS, esES, faIR, fiFI, filterableGridColumnsIdsSelector, filterableGridColumnsSelector, frFR, getDataGridUtilityClass, getDefaultGridFilterModel, getGridBooleanOperators, getGridColDef, getGridDateOperators, getGridDefaultColumnTypes, getGridNumericColumnOperators, getGridNumericOperators, getGridSingleSelectOperators, getGridStringOperators, getRowGroupingFieldFromGroupingCriteria, gridClasses, gridColumnLookupSelector, gridColumnMenuSelector, gridColumnReorderDragColSelector, gridColumnReorderSelector, gridColumnResizeSelector, gridColumnVisibilityModelSelector, gridColumnsMetaSelector, gridColumnsSelector, gridColumnsTotalWidthSelector, gridDateFormatter, gridDateTimeFormatter, gridDensityHeaderHeightSelector, gridDensityRowHeightSelector, gridDensitySelector, gridDensityValueSelector, gridEditRowsStateSelector, gridFilterActiveItemsLookupSelector, gridFilterActiveItemsSelector, gridFilterModelSelector, gridFilterStateSelector, gridFilteredDescendantCountLookupSelector, gridFocusCellSelector, gridFocusColumnHeaderSelector, gridFocusStateSelector, gridPageCountSelector, gridPageSelector, gridPageSizeSelector, gridPaginatedVisibleSortedGridRowEntriesSelector, gridPaginatedVisibleSortedGridRowIdsSelector, gridPaginationRowRangeSelector, gridPaginationSelector, gridPanelClasses, gridPinnedColumnsSelector, gridPreferencePanelStateSelector, gridResizingColumnFieldSelector, gridRowCountSelector, gridRowGroupingModelSelector, gridRowGroupingNameSelector, gridRowGroupingSanitizedModelSelector, gridRowGroupingStateSelector, gridRowIdsSelector, gridRowTreeDepthSelector, gridRowTreeSelector, gridRowsLookupSelector, gridRowsStateSelector, gridSelectionStateSelector, gridSortColumnLookupSelector, gridSortModelSelector, gridSortedRowEntriesSelector, gridSortedRowIdsSelector, gridTabIndexCellSelector, gridTabIndexColumnHeaderSelector, gridTabIndexStateSelector, gridTopLevelRowCountSelector, gridVisibleColumnFieldsSelector, gridVisibleRowCountSelector, gridVisibleRowsLookupSelector, gridVisibleRowsSelector, gridVisibleSortedRowEntriesSelector, gridVisibleSortedRowIdsSelector, gridVisibleSortedTopLevelRowEntriesSelector, gridVisibleTopLevelRowCountSelector, heIL, itIT, jaJP, koKR, nlNL, plPL, ptBR, renderActionsCell, renderEditInputCell, renderEditSingleSelectCell, ruRU, selectedGridRowsCountSelector, selectedGridRowsSelector, selectedIdsLookupSelector, skSK, trTR, ukUA, useDataGridComponent, useGridApi, useGridApiContext, useGridApiEventHandler, useGridApiMethod, useGridApiOptionHandler, useGridApiRef, useGridLogger, useGridNativeEventListener, useGridRootProps, useGridScrollFn, useGridSelector, useGridState, viVN, visibleGridColumnsLengthSelector, visibleGridColumnsSelector, zhCN };
5250
+ export { AutoSizerProps, AutoSizerSize, CursorCoordinates, DEFAULT_GRID_COL_TYPE_KEY, DataGrid, DataGridProps, ElementSize, GRID_ACTIONS_COL_DEF, GRID_BOOLEAN_COL_DEF, GRID_CHECKBOX_SELECTION_COL_DEF, GRID_DATETIME_COL_DEF, GRID_DATE_COL_DEF, GRID_DEFAULT_LOCALE_TEXT, GRID_EXPERIMENTAL_ENABLED, GRID_NUMERIC_COL_DEF, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, GRID_SINGLE_SELECT_COL_DEF, GRID_STRING_COL_DEF, GRID_TREE_DATA_GROUPING_FIELD, GridActionsCell, GridActionsCellItem, GridActionsCellItemProps, GridActionsColDef, GridAddIcon, GridAlignment, GridApi, GridApiContext, GridApiRef, GridArrowDownwardIcon, GridArrowUpwardIcon, GridAutoSizer, GridBody, GridCallbackDetails, GridCell, GridCellCheckboxForwardRef, GridCellCheckboxRenderer, GridCellClassFn, GridCellClassNamePropType, GridCellEditCommitParams, GridCellEventLookup, GridCellIdentifier, GridCellIndexCoordinates, GridCellMode, GridCellModes, GridCellParams, GridCellProps, GridCellValue, GridCheckCircleIcon, GridCheckIcon, GridClassKey, GridClasses, GridClipboardApi, GridCloseIcon, GridColDef, GridColType, GridColTypeDef, GridColumnApi, GridColumnHeaderClassFn, GridColumnHeaderClassNamePropType, GridColumnHeaderEventLookup, GridColumnHeaderIndexCoordinates, GridColumnHeaderItem, GridColumnHeaderMenu, GridColumnHeaderMenuProps, GridColumnHeaderParams, GridColumnHeaderSeparator, GridColumnHeaderSeparatorProps, GridColumnHeaderSeparatorSides, GridColumnHeaderSortIcon, GridColumnHeaderSortIconProps, GridColumnHeaderTitle, GridColumnHeaderTitleProps, GridColumnIcon, GridColumnIdentifier, GridColumnLookup, GridColumnMenu, GridColumnMenuApi, GridColumnMenuContainer, GridColumnMenuProps, GridColumnMenuState, GridColumnOrderChangeParams, GridColumnPinningApi, GridColumnPinningMenuItems, GridColumnPinningState, GridColumnReorderState, GridColumnResizeParams, GridColumnResizeState, GridColumnTypesRecord, GridColumnVisibilityChangeParams, GridColumnVisibilityModel, GridColumns, GridColumnsInitialState, GridColumnsMenuItem, GridColumnsMeta, GridColumnsPanel, GridColumnsState, GridCommitCellChangeParams, GridComparatorFn, GridControlledStateEventLookup, GridCoreApi, GridCsvExportApi, GridCsvExportOptions, GridCsvGetRowsToExportParams, GridDensity, GridDensityApi, GridDensityOption, GridDensityState, GridDensityTypes, GridDimensions, GridDimensionsApi, GridDisableVirtualizationApi, GridDragIcon, GridEditCellProps, GridEditCellPropsParams, GridEditCellValueParams, GridEditInputCell, GridEditMode, GridEditModes, GridEditRowApi, GridEditRowProps, GridEditRowsModel, GridEditSingleSelectCell, GridEnrichedColDef, GridErrorHandler, GridEventListener, GridEventLookup, GridEventPublisher, GridEvents, GridEventsStr, GridExpandMoreIcon, GridExportFormat, GridExportOptions, GridFeatureMode, GridFeatureModeConstant, GridFilterActiveItemsLookup, GridFilterAltIcon, GridFilterApi, GridFilterForm, GridFilterFormProps, GridFilterInitialState, GridFilterInputDate, GridFilterInputDateProps, GridFilterInputMultipleSingleSelect, GridFilterInputMultipleSingleSelectProps, GridFilterInputMultipleValue, GridFilterInputMultipleValueProps, GridFilterInputSingleSelect, GridFilterInputSingleSelectProps, GridFilterInputValue, GridFilterInputValueProps, GridFilterItem, GridFilterItemProps, GridFilterListIcon, GridFilterMenuItem, GridFilterModel, GridFilterOperator, GridFilterPanel, GridFilterState, GridFocusApi, GridFocusState, GridFooter, GridFooterContainer, GridFooterContainerProps, GridFooterPlaceholder, GridGroupingColDefOverride, GridGroupingColDefOverrideParams, GridGroupingValueGetterParams, GridHeader, GridHeaderCheckbox, GridHeaderPlaceholder, GridHeaderSelectionCheckboxParams, GridIconSlotsComponent, GridInitialState, GridInputSelectionModel, GridKeyValue, GridKeyboardArrowRight, GridLinkOperator, GridLoadIcon, GridLoadingOverlay, GridLocaleText, GridLocaleTextApi, GridMenu, GridMenuIcon, GridMenuProps, GridMoreVertIcon, GridNativeColTypes, GridNoRowsOverlay, GridOverlay, GridOverlayProps, GridOverlays, GridPagination, GridPaginationApi, GridPaginationInitialState, GridPaginationState, GridPanel, GridPanelClasses, GridPanelContent, GridPanelFooter, GridPanelHeader, GridPanelProps, GridPanelWrapper, GridParamsApi, GridPinnedColumns, GridPinnedPosition, GridPreProcessEditCellProps, GridPreferencePanelInitialState, GridPreferencePanelState, GridPreferencePanelsValue, GridPreferencesPanel, GridPreferencesPanelApi, GridPrintExportApi, GridPrintExportOptions, GridRenderCellParams, GridRenderColumnsProps, GridRenderContext, GridRenderContextProps, GridRenderEditCellParams, GridRenderPaginationProps, GridRenderRowProps, GridRoot, GridRootContainerRef, GridRootProps, GridRow, GridRowApi, GridRowCount, GridRowData, GridRowEntry, GridRowEventLookup, GridRowGroupingApi, GridRowGroupingInitialState, GridRowGroupingModel, GridRowGroupingState, GridRowHeightParams, GridRowHeightReturnValue, GridRowId, GridRowIdGetter, GridRowMode, GridRowModel, GridRowModelUpdate, GridRowModes, GridRowParams, GridRowProps, GridRowScrollEndParams, GridRowSelectionCheckboxParams, GridRowTreeConfig, GridRowTreeNodeConfig, GridRowsLookup, GridRowsMetaApi, GridRowsProp, GridRowsState, GridSaveAltIcon, GridScrollApi, GridScrollArea, GridScrollFn, GridScrollParams, GridSearchIcon, GridSelectedRowCount, GridSelectionApi, GridSelectionModel, GridSeparatorIcon, GridSignature, GridSlotsComponent, GridSlotsComponentsProps, GridSortApi, GridSortCellParams, GridSortColumnLookup, GridSortDirection, GridSortItem, GridSortModel, GridSortModelParams, GridSortingInitialState, GridSortingState, GridState, GridStateApi, GridStateChangeParams, GridStateColDef, GridTabIndexState, GridTableRowsIcon, GridToolbar, GridToolbarColumnsButton, GridToolbarContainer, GridToolbarContainerProps, GridToolbarDensitySelector, GridToolbarExport, GridToolbarExportProps, GridToolbarFilterButton, GridToolbarFilterButtonProps, GridToolbarProps, GridTranslationKeys, GridTreeDataGroupingCell, GridTripleDotsVerticalIcon, GridTypeFilterInputValueProps, GridUpdateAction, GridValueFormatterParams, GridValueGetterFullParams, GridValueGetterParams, GridValueOptionsParams, GridValueSetterParams, GridViewHeadlineIcon, GridViewStreamIcon, GridVirtualScrollerApi, HideGridColMenuItem, Logger, MAX_PAGE_SIZE, MuiBaseEvent, MuiEvent, SUBMIT_FILTER_DATE_STROKE_TIME, SUBMIT_FILTER_STROKE_TIME, SortGridMenuItems, allGridColumnsFieldsSelector, allGridColumnsSelector, arSD, bgBG, checkGridRowIdIsValid, createUseGridApiEventHandler, csCZ, deDE, elGR, enUS, esES, faIR, fiFI, filterableGridColumnsIdsSelector, filterableGridColumnsSelector, frFR, getDataGridUtilityClass, getDefaultGridFilterModel, getGridBooleanOperators, getGridColDef, getGridDateOperators, getGridDefaultColumnTypes, getGridNumericColumnOperators, getGridNumericOperators, getGridSingleSelectOperators, getGridStringOperators, getRowGroupingFieldFromGroupingCriteria, gridClasses, gridColumnLookupSelector, gridColumnMenuSelector, gridColumnReorderDragColSelector, gridColumnReorderSelector, gridColumnResizeSelector, gridColumnVisibilityModelSelector, gridColumnsMetaSelector, gridColumnsSelector, gridColumnsTotalWidthSelector, gridDateComparator, gridDateFormatter, gridDateTimeFormatter, gridDensityFactorSelector, gridDensityHeaderHeightSelector, gridDensityRowHeightSelector, gridDensitySelector, gridDensityValueSelector, gridEditRowsStateSelector, gridFilterActiveItemsLookupSelector, gridFilterActiveItemsSelector, gridFilterModelSelector, gridFilterStateSelector, gridFilteredDescendantCountLookupSelector, gridFilteredRowsLookupSelector, gridFilteredSortedRowEntriesSelector, gridFilteredSortedRowIdsSelector, gridFocusCellSelector, gridFocusColumnHeaderSelector, gridFocusStateSelector, gridNumberComparator, gridPageCountSelector, gridPageSelector, gridPageSizeSelector, gridPaginatedVisibleSortedGridRowEntriesSelector, gridPaginatedVisibleSortedGridRowIdsSelector, gridPaginationRowRangeSelector, gridPaginationSelector, gridPanelClasses, gridPinnedColumnsSelector, gridPreferencePanelStateSelector, gridResizingColumnFieldSelector, gridRowCountSelector, gridRowGroupingModelSelector, gridRowGroupingNameSelector, gridRowGroupingSanitizedModelSelector, gridRowGroupingStateSelector, gridRowIdsSelector, gridRowTreeDepthSelector, gridRowTreeSelector, gridRowsLookupSelector, gridRowsMetaSelector, gridRowsStateSelector, gridSelectionStateSelector, gridSortColumnLookupSelector, gridSortModelSelector, gridSortedRowEntriesSelector, gridSortedRowIdsSelector, gridSortingStateSelector, gridStringOrNumberComparator, gridTabIndexCellSelector, gridTabIndexColumnHeaderSelector, gridTabIndexStateSelector, gridTopLevelRowCountSelector, gridVisibleColumnFieldsSelector, gridVisibleRowCountSelector, gridVisibleRowsLookupSelector, gridVisibleRowsSelector, gridVisibleSortedRowEntriesSelector, gridVisibleSortedRowIdsSelector, gridVisibleSortedTopLevelRowEntriesSelector, gridVisibleTopLevelRowCountSelector, heIL, itIT, jaJP, koKR, nlNL, plPL, ptBR, renderActionsCell, renderEditInputCell, renderEditSingleSelectCell, ruRU, selectedGridRowsCountSelector, selectedGridRowsSelector, selectedIdsLookupSelector, skSK, trTR, ukUA, useDataGridComponent, useGridApi, useGridApiContext, useGridApiEventHandler, useGridApiMethod, useGridApiOptionHandler, useGridApiRef, useGridLogger, useGridNativeEventListener, useGridRootProps, useGridScrollFn, useGridSelector, useGridState, viVN, visibleGridColumnsLengthSelector, visibleGridColumnsSelector, zhCN };