@mui/x-data-grid-pro 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.
@@ -18,13 +18,11 @@ import { InternalStandardProps } from '@mui/material';
18
18
  import { TextFieldProps } from '@mui/material/TextField';
19
19
  import { ButtonProps } from '@mui/material/Button';
20
20
  import { TooltipProps } from '@mui/material/Tooltip';
21
- import * as reselect from 'reselect';
22
21
 
23
22
  interface GridBodyProps {
24
23
  children?: React$1.ReactNode;
25
24
  VirtualScrollerComponent: React$1.JSXElementConstructor<React$1.HTMLAttributes<HTMLDivElement> & {
26
25
  ref: React$1.Ref<HTMLDivElement>;
27
- selectionLookup: {};
28
26
  disableVirtualization: boolean;
29
27
  }>;
30
28
  ColumnHeadersComponent: React$1.JSXElementConstructor<React$1.HTMLAttributes<HTMLDivElement> & {
@@ -209,6 +207,7 @@ declare function checkGridRowIdIsValid(id: GridRowId, row: GridRowModel | Partia
209
207
 
210
208
  interface GridEditCellProps {
211
209
  value: GridCellValue;
210
+ isValidating?: boolean;
212
211
  [prop: string]: any;
213
212
  }
214
213
  declare type GridEditRowProps = {
@@ -292,7 +291,20 @@ interface GridRowParams<R extends GridRowModel = GridRowModel> {
292
291
  * @deprecated Use `params.row` to directly access the fields you want instead.
293
292
  */
294
293
  getValue: (id: GridRowId, field: string) => GridCellValue;
295
- }
294
+ }
295
+ /**
296
+ * Object passed as parameter in the row getRowHeight callback.
297
+ */
298
+ interface GridRowHeightParams extends GridRowEntry {
299
+ /**
300
+ * The grid current density factor.
301
+ */
302
+ densityFactor: number;
303
+ }
304
+ /**
305
+ * The getRowHeight return value.
306
+ */
307
+ declare type GridRowHeightReturnValue = number | null | undefined;
296
308
 
297
309
  interface GridParamsApi {
298
310
  /**
@@ -827,306 +839,24 @@ interface GridColumnMenuState {
827
839
  field?: string;
828
840
  }
829
841
 
830
- declare const gridColumnMenuSelector: (state: GridState) => GridColumnMenuState;
831
-
832
- interface GridColumnResizeState {
833
- resizingColumnField: string;
842
+ interface OutputSelector<Result> {
843
+ (stateOrApiRef: GridApiRef | GridState): Result;
844
+ cache: object;
834
845
  }
835
846
 
836
- declare const gridColumnResizeSelector: (state: GridState) => GridColumnResizeState;
837
- declare const gridResizingColumnFieldSelector: ((state: {
838
- rows: GridRowsState;
839
- editRows: GridEditRowsModel;
840
- pagination: GridPaginationState;
841
- columns: GridColumnsState;
842
- columnReorder: GridColumnReorderState;
843
- columnResize: GridColumnResizeState;
844
- columnMenu: GridColumnMenuState;
845
- sorting: GridSortingState;
846
- focus: GridFocusState;
847
- tabIndex: GridTabIndexState;
848
- selection: GridSelectionModel;
849
- filter: GridFilterState;
850
- preferencePanel: GridPreferencePanelState;
851
- density: GridDensityState;
852
- rowGrouping: GridRowGroupingState;
853
- error?: any;
854
- pinnedColumns: GridPinnedColumns;
855
- }) => string) & reselect.OutputSelectorFields<(args_0: GridColumnResizeState) => string & {
856
- clearCache: () => void;
857
- }> & {
858
- clearCache: () => void;
859
- };
860
-
861
- declare const gridPinnedColumnsSelector: (state: GridState) => GridPinnedColumns;
862
-
863
- interface GridPinnedColumns {
864
- left?: string[];
865
- right?: string[];
866
- }
867
- declare enum GridPinnedPosition {
868
- left = "left",
869
- right = "right"
847
+ interface GridColumnReorderState {
848
+ dragCol: string;
870
849
  }
871
- /**
872
- * The column pinning API interface that is available in the grid [[apiRef]].
873
- */
874
- interface GridColumnPinningApi {
875
- /**
876
- * Pins a column to the left or right side of the grid.
877
- * @param {string} field The column field to pin.
878
- * @param {GridPinnedPosition} side Which side to pin the column.
879
- */
880
- pinColumn: (field: string, side: GridPinnedPosition) => void;
881
- /**
882
- * Unpins a column.
883
- * @param {string} field The column field to unpin.
884
- */
885
- unpinColumn: (field: string) => void;
886
- /**
887
- * Returns which columns are pinned.
888
- * @returns {GridPinnedColumns} An object containing the pinned columns.
889
- */
890
- getPinnedColumns: () => GridPinnedColumns;
891
- /**
892
- * Changes the pinned columns.
893
- * @param {GridPinnedColumns} pinnedColumns An object containing the columns to pin.
894
- */
895
- setPinnedColumns: (pinnedColumns: GridPinnedColumns) => void;
896
- /**
897
- * Returns which side a column is pinned to.
898
- * @param {string} field The column field to check.
899
- * @returns {string | false} Which side the column is pinned or `false` if not pinned.
900
- */
901
- isColumnPinned: (field: string) => GridPinnedPosition | false;
850
+ interface GridCanBeReorderedPreProcessingContext {
851
+ targetIndex: number;
902
852
  }
903
853
 
904
- declare type GridColumnPinningState = GridPinnedColumns;
905
-
906
- declare const gridColumnsSelector: (state: GridState) => GridColumnsState;
907
- declare const allGridColumnsFieldsSelector: (state: GridState) => string[];
908
- declare const gridColumnLookupSelector: (state: GridState) => GridColumnLookup;
909
- declare const allGridColumnsSelector: ((state: {
910
- rows: GridRowsState;
911
- editRows: GridEditRowsModel;
912
- pagination: GridPaginationState;
913
- columns: GridColumnsState;
914
- columnReorder: GridColumnReorderState;
915
- columnResize: GridColumnResizeState;
916
- columnMenu: GridColumnMenuState;
917
- sorting: GridSortingState;
918
- focus: GridFocusState;
919
- tabIndex: GridTabIndexState;
920
- selection: GridSelectionModel;
921
- filter: GridFilterState;
922
- preferencePanel: GridPreferencePanelState;
923
- density: GridDensityState;
924
- rowGrouping: GridRowGroupingState;
925
- error?: any;
926
- pinnedColumns: GridPinnedColumns;
927
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: string[], args_1: GridColumnLookup) => GridStateColDef[] & {
928
- clearCache: () => void;
929
- }> & {
930
- clearCache: () => void;
931
- };
932
- declare const gridColumnVisibilityModelSelector: ((state: {
933
- rows: GridRowsState;
934
- editRows: GridEditRowsModel;
935
- pagination: GridPaginationState;
936
- columns: GridColumnsState;
937
- columnReorder: GridColumnReorderState;
938
- columnResize: GridColumnResizeState;
939
- columnMenu: GridColumnMenuState;
940
- sorting: GridSortingState;
941
- focus: GridFocusState;
942
- tabIndex: GridTabIndexState;
943
- selection: GridSelectionModel;
944
- filter: GridFilterState;
945
- preferencePanel: GridPreferencePanelState;
946
- density: GridDensityState;
947
- rowGrouping: GridRowGroupingState;
948
- error?: any;
949
- pinnedColumns: GridPinnedColumns;
950
- }) => GridColumnVisibilityModel) & reselect.OutputSelectorFields<(args_0: GridColumnsState) => GridColumnVisibilityModel & {
951
- clearCache: () => void;
952
- }> & {
953
- clearCache: () => void;
954
- };
955
- declare const visibleGridColumnsSelector: ((state: {
956
- rows: GridRowsState;
957
- editRows: GridEditRowsModel;
958
- pagination: GridPaginationState;
959
- columns: GridColumnsState;
960
- columnReorder: GridColumnReorderState;
961
- columnResize: GridColumnResizeState;
962
- columnMenu: GridColumnMenuState;
963
- sorting: GridSortingState;
964
- focus: GridFocusState;
965
- tabIndex: GridTabIndexState;
966
- selection: GridSelectionModel;
967
- filter: GridFilterState;
968
- preferencePanel: GridPreferencePanelState;
969
- density: GridDensityState;
970
- rowGrouping: GridRowGroupingState;
971
- error?: any;
972
- pinnedColumns: GridPinnedColumns;
973
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[], args_1: GridColumnVisibilityModel) => GridStateColDef[] & {
974
- clearCache: () => void;
975
- }> & {
976
- clearCache: () => void;
977
- };
978
- declare const gridVisibleColumnFieldsSelector: ((state: {
979
- rows: GridRowsState;
980
- editRows: GridEditRowsModel;
981
- pagination: GridPaginationState;
982
- columns: GridColumnsState;
983
- columnReorder: GridColumnReorderState;
984
- columnResize: GridColumnResizeState;
985
- columnMenu: GridColumnMenuState;
986
- sorting: GridSortingState;
987
- focus: GridFocusState;
988
- tabIndex: GridTabIndexState;
989
- selection: GridSelectionModel;
990
- filter: GridFilterState;
991
- preferencePanel: GridPreferencePanelState;
992
- density: GridDensityState;
993
- rowGrouping: GridRowGroupingState;
994
- error?: any;
995
- pinnedColumns: GridPinnedColumns;
996
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => string[] & {
997
- clearCache: () => void;
998
- }> & {
999
- clearCache: () => void;
1000
- };
1001
- declare const gridColumnsMetaSelector: ((state: {
1002
- rows: GridRowsState;
1003
- editRows: GridEditRowsModel;
1004
- pagination: GridPaginationState;
1005
- columns: GridColumnsState;
1006
- columnReorder: GridColumnReorderState;
1007
- columnResize: GridColumnResizeState;
1008
- columnMenu: GridColumnMenuState;
1009
- sorting: GridSortingState;
1010
- focus: GridFocusState;
1011
- tabIndex: GridTabIndexState;
1012
- selection: GridSelectionModel;
1013
- filter: GridFilterState;
1014
- preferencePanel: GridPreferencePanelState;
1015
- density: GridDensityState;
1016
- rowGrouping: GridRowGroupingState;
1017
- error?: any;
1018
- pinnedColumns: GridPinnedColumns;
1019
- }) => {
1020
- totalWidth: number;
1021
- positions: number[];
1022
- }) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => {
1023
- totalWidth: number;
1024
- positions: number[];
1025
- } & {
1026
- clearCache: () => void;
1027
- }> & {
1028
- clearCache: () => void;
1029
- };
1030
- declare const filterableGridColumnsSelector: ((state: {
1031
- rows: GridRowsState;
1032
- editRows: GridEditRowsModel;
1033
- pagination: GridPaginationState;
1034
- columns: GridColumnsState;
1035
- columnReorder: GridColumnReorderState;
1036
- columnResize: GridColumnResizeState;
1037
- columnMenu: GridColumnMenuState;
1038
- sorting: GridSortingState;
1039
- focus: GridFocusState;
1040
- tabIndex: GridTabIndexState;
1041
- selection: GridSelectionModel;
1042
- filter: GridFilterState;
1043
- preferencePanel: GridPreferencePanelState;
1044
- density: GridDensityState;
1045
- rowGrouping: GridRowGroupingState;
1046
- error?: any;
1047
- pinnedColumns: GridPinnedColumns;
1048
- }) => GridStateColDef[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => GridStateColDef[] & {
1049
- clearCache: () => void;
1050
- }> & {
1051
- clearCache: () => void;
1052
- };
1053
- declare const filterableGridColumnsIdsSelector: ((state: {
1054
- rows: GridRowsState;
1055
- editRows: GridEditRowsModel;
1056
- pagination: GridPaginationState;
1057
- columns: GridColumnsState;
1058
- columnReorder: GridColumnReorderState;
1059
- columnResize: GridColumnResizeState;
1060
- columnMenu: GridColumnMenuState;
1061
- sorting: GridSortingState;
1062
- focus: GridFocusState;
1063
- tabIndex: GridTabIndexState;
1064
- selection: GridSelectionModel;
1065
- filter: GridFilterState;
1066
- preferencePanel: GridPreferencePanelState;
1067
- density: GridDensityState;
1068
- rowGrouping: GridRowGroupingState;
1069
- error?: any;
1070
- pinnedColumns: GridPinnedColumns;
1071
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => string[] & {
1072
- clearCache: () => void;
1073
- }> & {
1074
- clearCache: () => void;
1075
- };
1076
- declare const visibleGridColumnsLengthSelector: ((state: {
1077
- rows: GridRowsState;
1078
- editRows: GridEditRowsModel;
1079
- pagination: GridPaginationState;
1080
- columns: GridColumnsState;
1081
- columnReorder: GridColumnReorderState;
1082
- columnResize: GridColumnResizeState;
1083
- columnMenu: GridColumnMenuState;
1084
- sorting: GridSortingState;
1085
- focus: GridFocusState;
1086
- tabIndex: GridTabIndexState;
1087
- selection: GridSelectionModel;
1088
- filter: GridFilterState;
1089
- preferencePanel: GridPreferencePanelState;
1090
- density: GridDensityState;
1091
- rowGrouping: GridRowGroupingState;
1092
- error?: any;
1093
- pinnedColumns: GridPinnedColumns;
1094
- }) => number) & reselect.OutputSelectorFields<(args_0: GridStateColDef[]) => number & {
1095
- clearCache: () => void;
1096
- }> & {
1097
- clearCache: () => void;
1098
- };
1099
- declare const gridColumnsTotalWidthSelector: ((state: {
1100
- rows: GridRowsState;
1101
- editRows: GridEditRowsModel;
1102
- pagination: GridPaginationState;
1103
- columns: GridColumnsState;
1104
- columnReorder: GridColumnReorderState;
1105
- columnResize: GridColumnResizeState;
1106
- columnMenu: GridColumnMenuState;
1107
- sorting: GridSortingState;
1108
- focus: GridFocusState;
1109
- tabIndex: GridTabIndexState;
1110
- selection: GridSelectionModel;
1111
- filter: GridFilterState;
1112
- preferencePanel: GridPreferencePanelState;
1113
- density: GridDensityState;
1114
- rowGrouping: GridRowGroupingState;
1115
- error?: any;
1116
- pinnedColumns: GridPinnedColumns;
1117
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1118
- totalWidth: number;
1119
- positions: number[];
1120
- }) => number & {
1121
- clearCache: () => void;
1122
- }> & {
1123
- clearCache: () => void;
1124
- };
854
+ declare const gridColumnReorderSelector: (state: GridState) => GridColumnReorderState;
855
+ declare const gridColumnReorderDragColSelector: OutputSelector<string>;
1125
856
 
1126
- /**
1127
- * @deprecated Should have been internal only, you can inline the logic.
1128
- */
1129
- declare const getGridColDef: (columnTypes: GridColumnTypesRecord, type: GridColType | undefined) => GridColTypeDef;
857
+ interface GridColumnResizeState {
858
+ resizingColumnField: string;
859
+ }
1130
860
 
1131
861
  /**
1132
862
  * Available densities.
@@ -1145,80 +875,182 @@ interface GridDensityState {
1145
875
  value: GridDensity;
1146
876
  rowHeight: number;
1147
877
  headerHeight: number;
878
+ factor: number;
1148
879
  }
1149
880
 
1150
- declare const gridDensitySelector: (state: GridState) => GridDensityState;
1151
- declare const gridDensityValueSelector: ((state: {
1152
- rows: GridRowsState;
1153
- editRows: GridEditRowsModel;
1154
- pagination: GridPaginationState;
1155
- columns: GridColumnsState;
1156
- columnReorder: GridColumnReorderState;
1157
- columnResize: GridColumnResizeState;
1158
- columnMenu: GridColumnMenuState;
1159
- sorting: GridSortingState;
1160
- focus: GridFocusState;
1161
- tabIndex: GridTabIndexState;
1162
- selection: GridSelectionModel;
1163
- filter: GridFilterState;
1164
- preferencePanel: GridPreferencePanelState;
1165
- density: GridDensityState;
1166
- rowGrouping: GridRowGroupingState;
1167
- error?: any;
1168
- pinnedColumns: GridPinnedColumns;
1169
- }) => GridDensity) & reselect.OutputSelectorFields<(args_0: GridDensityState) => GridDensity & {
1170
- clearCache: () => void;
1171
- }> & {
1172
- clearCache: () => void;
881
+ declare type GridCellIdentifier = {
882
+ id: GridRowId;
883
+ field: string;
1173
884
  };
1174
- declare const gridDensityRowHeightSelector: ((state: {
1175
- rows: GridRowsState;
1176
- editRows: GridEditRowsModel;
1177
- pagination: GridPaginationState;
1178
- columns: GridColumnsState;
1179
- columnReorder: GridColumnReorderState;
1180
- columnResize: GridColumnResizeState;
1181
- columnMenu: GridColumnMenuState;
1182
- sorting: GridSortingState;
1183
- focus: GridFocusState;
1184
- tabIndex: GridTabIndexState;
1185
- selection: GridSelectionModel;
1186
- filter: GridFilterState;
1187
- preferencePanel: GridPreferencePanelState;
1188
- density: GridDensityState;
1189
- rowGrouping: GridRowGroupingState;
1190
- error?: any;
1191
- pinnedColumns: GridPinnedColumns;
1192
- }) => number) & reselect.OutputSelectorFields<(args_0: GridDensityState) => number & {
1193
- clearCache: () => void;
1194
- }> & {
1195
- clearCache: () => void;
885
+ declare type GridColumnIdentifier = {
886
+ field: string;
1196
887
  };
1197
- declare const gridDensityHeaderHeightSelector: ((state: {
1198
- rows: GridRowsState;
1199
- editRows: GridEditRowsModel;
1200
- pagination: GridPaginationState;
1201
- columns: GridColumnsState;
1202
- columnReorder: GridColumnReorderState;
1203
- columnResize: GridColumnResizeState;
1204
- columnMenu: GridColumnMenuState;
1205
- sorting: GridSortingState;
1206
- focus: GridFocusState;
1207
- tabIndex: GridTabIndexState;
1208
- selection: GridSelectionModel;
1209
- filter: GridFilterState;
1210
- preferencePanel: GridPreferencePanelState;
1211
- density: GridDensityState;
1212
- rowGrouping: GridRowGroupingState;
1213
- error?: any;
1214
- pinnedColumns: GridPinnedColumns;
1215
- }) => number) & reselect.OutputSelectorFields<(args_0: GridDensityState) => number & {
1216
- clearCache: () => void;
1217
- }> & {
1218
- clearCache: () => void;
888
+ interface GridFocusState {
889
+ cell: GridCellIdentifier | null;
890
+ columnHeader: GridColumnIdentifier | null;
891
+ }
892
+ interface GridTabIndexState {
893
+ cell: GridCellIdentifier | null;
894
+ columnHeader: GridColumnIdentifier | null;
895
+ }
896
+
897
+ declare enum GridPreferencePanelsValue {
898
+ filters = "filters",
899
+ columns = "columns"
900
+ }
901
+
902
+ interface GridPreferencePanelState {
903
+ open: boolean;
904
+ openedPanelValue?: GridPreferencePanelsValue;
905
+ }
906
+ declare type GridPreferencePanelInitialState = GridPreferencePanelState;
907
+
908
+ interface GridRowGroupParams {
909
+ ids: GridRowId[];
910
+ idRowsLookup: GridRowsLookup;
911
+ previousTree: GridRowTreeConfig | null;
912
+ }
913
+ interface GridRowGroupingResult {
914
+ /**
915
+ * Name of the algorithm used to group the rows
916
+ * 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.
917
+ */
918
+ groupingName: string;
919
+ tree: GridRowTreeConfig;
920
+ treeDepth: number;
921
+ ids: GridRowId[];
922
+ idRowsLookup: GridRowsLookup;
923
+ }
924
+ declare type GridRowGroupingPreProcessing = (params: GridRowGroupParams) => GridRowGroupingResult | null;
925
+ interface GridRowGroupsPreProcessingApi {
926
+ /**
927
+ * Register a column pre-processing and emit an event to re-apply the row grouping pre-processing.
928
+ * @param {string} processingName Name of the pre-processing. Used to clean the previous version of the pre-processing.
929
+ * @param {GridRowGroupingPreProcessing} columnsPreProcessing Pre-processing to register.
930
+ * @ignore - do not document.
931
+ */
932
+ unstable_registerRowGroupsBuilder: (processingName: string, groupingFunction: GridRowGroupingPreProcessing | null) => void;
933
+ /**
934
+ * Apply the first row grouping pre-processing that does not return null.
935
+ * @param {GridRowsLookup} rowsLookup. Lookup of the rows to group.
936
+ * @param {GridRowId[]} List of the rows IDs.
937
+ * @returns {GridRowGroupingResult} The grouped rows.
938
+ * @ignore - do not document.
939
+ */
940
+ unstable_groupRows: (params: GridRowGroupParams) => GridRowGroupingResult;
941
+ }
942
+
943
+ interface GridRowsState extends GridRowGroupingResult {
944
+ /**
945
+ * Amount of rows before applying the filtering.
946
+ * It also count the expanded and collapsed children rows.
947
+ */
948
+ totalRowCount: number;
949
+ /**
950
+ * Amount of rows before applying the filtering.
951
+ * It does not count the expanded children rows.
952
+ */
953
+ totalTopLevelRowCount: number;
954
+ }
955
+
956
+ declare type GridInputSelectionModel = GridRowId[] | GridRowId;
957
+ declare type GridSelectionModel = GridRowId[];
958
+
959
+ interface GridSortingState {
960
+ sortedRows: GridRowId[];
961
+ sortModel: GridSortModel;
962
+ }
963
+ interface GridSortingInitialState {
964
+ sortModel?: GridSortModel;
965
+ }
966
+ declare type GridSortingModelApplier = (rowList: GridRowTreeNodeConfig[]) => GridRowId[];
967
+ interface GridSortingParams {
968
+ sortRowList: GridSortingModelApplier | null;
969
+ }
970
+ declare type GridSortingMethod = (params: GridSortingParams) => GridRowId[];
971
+ declare type GridSortingMethodCollection = {
972
+ [methodName: string]: GridSortingMethod;
1219
973
  };
1220
974
 
1221
- declare const gridEditRowsStateSelector: (state: GridState) => GridEditRowsModel;
975
+ interface GridPaginationState {
976
+ pageSize: number;
977
+ page: number;
978
+ pageCount: number;
979
+ rowCount: number;
980
+ }
981
+ interface GridPaginationInitialState {
982
+ pageSize?: number;
983
+ page?: number;
984
+ }
985
+ /**
986
+ * The apiRef methods handled by `useGridPageSize`
987
+ */
988
+ interface GridPageSizeApi {
989
+ /**
990
+ * Sets the number of displayed rows to the value given by `pageSize`.
991
+ * @param {number} pageSize The new number of displayed rows.
992
+ */
993
+ setPageSize: (pageSize: number) => void;
994
+ }
995
+ /**
996
+ * The apiRef methods handled by `useGridPage`
997
+ */
998
+ interface GridPageApi {
999
+ /**
1000
+ * Sets the displayed page to the value given by `page`.
1001
+ * @param {number} page The new page number.
1002
+ */
1003
+ setPage: (page: number) => void;
1004
+ }
1005
+ /**
1006
+ * The pagination API interface that is available in the grid [[apiRef]].
1007
+ */
1008
+ interface GridPaginationApi extends GridPageApi, GridPageSizeApi {
1009
+ }
1010
+
1011
+ /**
1012
+ * @category Pagination
1013
+ * @ignore - do not document.
1014
+ */
1015
+ declare const gridPaginationSelector: (state: GridState) => GridPaginationState;
1016
+ /**
1017
+ * Get the index of the page to render if the pagination is enabled
1018
+ * @category Pagination
1019
+ */
1020
+ declare const gridPageSelector: OutputSelector<number>;
1021
+ /**
1022
+ * Get the maximum amount of rows to display on a single page if the pagination is enabled
1023
+ * @category Pagination
1024
+ */
1025
+ declare const gridPageSizeSelector: OutputSelector<number>;
1026
+ /**
1027
+ * Get the amount of pages needed to display all the rows if the pagination is enabled
1028
+ * @category Pagination
1029
+ */
1030
+ declare const gridPageCountSelector: OutputSelector<number>;
1031
+ /**
1032
+ * Get the index of the first and the last row to include in the current page if the pagination is enabled.
1033
+ * @category Pagination
1034
+ */
1035
+ declare const gridPaginationRowRangeSelector: OutputSelector<{
1036
+ firstRowIndex: number;
1037
+ lastRowIndex: number;
1038
+ } | null>;
1039
+ /**
1040
+ * Get the id and the model of each row to include in the current page if the pagination is enabled.
1041
+ * @category Pagination
1042
+ */
1043
+ declare const gridPaginatedVisibleSortedGridRowEntriesSelector: OutputSelector<{
1044
+ id: GridRowId;
1045
+ model: {
1046
+ [key: string]: any;
1047
+ };
1048
+ }[]>;
1049
+ /**
1050
+ * Get the id of each row to include in the current page if the pagination is enabled.
1051
+ * @category Pagination
1052
+ */
1053
+ declare const gridPaginatedVisibleSortedGridRowIdsSelector: OutputSelector<GridRowId[]>;
1222
1054
 
1223
1055
  /**
1224
1056
  * Model describing the filters to apply to the grid.
@@ -1239,9 +1071,16 @@ interface GridFilterModel {
1239
1071
  declare const getDefaultGridFilterModel: () => GridFilterModel;
1240
1072
  interface GridFilterState {
1241
1073
  filterModel: GridFilterModel;
1074
+ /**
1075
+ * Filtering status for each row.
1076
+ * A row is filtered if it is passing the filters, whether its parents are expanded or not.
1077
+ * If a row is not registered in this lookup, it is filtered.
1078
+ * This is the equivalent of the `visibleRowsLookup` if all the groups were expanded.
1079
+ */
1080
+ filteredRowsLookup: Record<GridRowId, boolean>;
1242
1081
  /**
1243
1082
  * Visibility status for each row.
1244
- * A row is visible if it is passing the filters AND if its parent is expanded.
1083
+ * A row is visible if it is passing the filters AND if its parents are expanded.
1245
1084
  * If a row is not registered in this lookup, it is visible.
1246
1085
  */
1247
1086
  visibleRowsLookup: Record<GridRowId, boolean>;
@@ -1264,221 +1103,46 @@ declare type GridAggregatedFilterItemApplier = (rowId: GridRowId, shouldApplyIte
1264
1103
  interface GridFilteringParams {
1265
1104
  isRowMatchingFilters: GridAggregatedFilterItemApplier | null;
1266
1105
  }
1267
- declare type GridFilteringMethod = (params: GridFilteringParams) => Pick<GridFilterState, 'visibleRowsLookup' | 'filteredDescendantCountLookup'>;
1106
+ declare type GridFilteringMethod = (params: GridFilteringParams) => Omit<GridFilterState, 'filterModel'>;
1268
1107
  declare type GridFilteringMethodCollection = {
1269
1108
  [methodName: string]: GridFilteringMethod;
1270
1109
  };
1271
1110
 
1272
- interface GridRowGroupParams {
1273
- ids: GridRowId[];
1274
- idRowsLookup: GridRowsLookup;
1275
- previousTree: GridRowTreeConfig | null;
1111
+ declare type GridRowGroupingModel = string[];
1112
+ interface GridRowGroupingState {
1113
+ model: GridRowGroupingModel;
1276
1114
  }
1277
- interface GridRowGroupingResult {
1278
- /**
1279
- * Name of the algorithm used to group the rows
1280
- * 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.
1281
- */
1282
- groupingName: string;
1283
- tree: GridRowTreeConfig;
1284
- treeDepth: number;
1285
- ids: GridRowId[];
1286
- idRowsLookup: GridRowsLookup;
1115
+ interface GridRowGroupingInitialState {
1116
+ model?: GridRowGroupingModel;
1287
1117
  }
1288
- declare type GridRowGroupingPreProcessing = (params: GridRowGroupParams) => GridRowGroupingResult | null;
1289
- interface GridRowGroupsPreProcessingApi {
1118
+ interface GridRowGroupingApi {
1290
1119
  /**
1291
- * Register a column pre-processing and emit an event to re-apply the row grouping pre-processing.
1292
- * @param {string} processingName Name of the pre-processing. Used to clean the previous version of the pre-processing.
1293
- * @param {GridRowGroupingPreProcessing} columnsPreProcessing Pre-processing to register.
1294
- * @ignore - do not document.
1120
+ * Sets the columns to use as grouping criteria.
1121
+ * @param {GridRowGroupingModel} model The columns to use as grouping criteria.
1295
1122
  */
1296
- unstable_registerRowGroupsBuilder: (processingName: string, groupingFunction: GridRowGroupingPreProcessing | null) => void;
1123
+ setRowGroupingModel: (model: GridRowGroupingModel) => void;
1297
1124
  /**
1298
- * Apply the first row grouping pre-processing that does not return null.
1299
- * @param {GridRowsLookup} rowsLookup. Lookup of the rows to group.
1300
- * @param {GridRowId[]} List of the rows IDs.
1301
- * @returns {GridRowGroupingResult} The grouped rows.
1302
- * @ignore - do not document.
1125
+ * Adds the field to the row grouping model.
1126
+ * @param {string} groupingCriteriaField The field from which we want to group the rows.
1127
+ * @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.
1303
1128
  */
1304
- unstable_groupRows: (params: GridRowGroupParams) => GridRowGroupingResult;
1305
- }
1306
-
1307
- interface GridRowsState extends GridRowGroupingResult {
1129
+ addRowGroupingCriteria: (groupingCriteriaField: string, groupingIndex?: number) => void;
1308
1130
  /**
1309
- * Amount of rows before applying the filtering.
1310
- * It also count the expanded and collapsed children rows.
1131
+ * sRemove the field from the row grouping model.
1132
+ * @param {string} groupingCriteriaField The field from which we want to stop grouping the rows.
1311
1133
  */
1312
- totalRowCount: number;
1134
+ removeRowGroupingCriteria: (groupingCriteriaField: string) => void;
1313
1135
  /**
1314
- * Amount of rows before applying the filtering.
1315
- * It does not count the expanded children rows.
1136
+ * Sets the grouping index of a grouping criteria.
1137
+ * @param {string} groupingCriteriaField The field of the grouping criteria from which we want to change the grouping index.
1138
+ * @param {number} groupingIndex The new grouping index of this grouping criteria.
1316
1139
  */
1317
- totalTopLevelRowCount: number;
1140
+ setRowGroupingCriteriaIndex: (groupingCriteriaField: string, groupingIndex: number) => void;
1318
1141
  }
1319
1142
 
1320
- declare const gridRowsStateSelector: (state: GridState) => GridRowsState;
1321
- declare const gridRowCountSelector: ((state: {
1322
- rows: GridRowsState;
1323
- editRows: GridEditRowsModel;
1324
- pagination: GridPaginationState;
1325
- columns: GridColumnsState;
1326
- columnReorder: GridColumnReorderState;
1327
- columnResize: GridColumnResizeState;
1328
- columnMenu: GridColumnMenuState;
1329
- sorting: GridSortingState;
1330
- focus: GridFocusState;
1331
- tabIndex: GridTabIndexState;
1332
- selection: GridSelectionModel;
1333
- filter: GridFilterState;
1334
- preferencePanel: GridPreferencePanelState;
1335
- density: GridDensityState;
1336
- rowGrouping: GridRowGroupingState;
1337
- error?: any;
1338
- pinnedColumns: GridPinnedColumns;
1339
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1340
- clearCache: () => void;
1341
- }> & {
1342
- clearCache: () => void;
1343
- };
1344
- declare const gridTopLevelRowCountSelector: ((state: {
1345
- rows: GridRowsState;
1346
- editRows: GridEditRowsModel;
1347
- pagination: GridPaginationState;
1348
- columns: GridColumnsState;
1349
- columnReorder: GridColumnReorderState;
1350
- columnResize: GridColumnResizeState;
1351
- columnMenu: GridColumnMenuState;
1352
- sorting: GridSortingState;
1353
- focus: GridFocusState;
1354
- tabIndex: GridTabIndexState;
1355
- selection: GridSelectionModel;
1356
- filter: GridFilterState;
1357
- preferencePanel: GridPreferencePanelState;
1358
- density: GridDensityState;
1359
- rowGrouping: GridRowGroupingState;
1360
- error?: any;
1361
- pinnedColumns: GridPinnedColumns;
1362
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1363
- clearCache: () => void;
1364
- }> & {
1365
- clearCache: () => void;
1366
- };
1367
- declare const gridRowsLookupSelector: ((state: {
1368
- rows: GridRowsState;
1369
- editRows: GridEditRowsModel;
1370
- pagination: GridPaginationState;
1371
- columns: GridColumnsState;
1372
- columnReorder: GridColumnReorderState;
1373
- columnResize: GridColumnResizeState;
1374
- columnMenu: GridColumnMenuState;
1375
- sorting: GridSortingState;
1376
- focus: GridFocusState;
1377
- tabIndex: GridTabIndexState;
1378
- selection: GridSelectionModel;
1379
- filter: GridFilterState;
1380
- preferencePanel: GridPreferencePanelState;
1381
- density: GridDensityState;
1382
- rowGrouping: GridRowGroupingState;
1383
- error?: any;
1384
- pinnedColumns: GridPinnedColumns;
1385
- }) => GridRowsLookup) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowsLookup & {
1386
- clearCache: () => void;
1387
- }> & {
1388
- clearCache: () => void;
1389
- };
1390
- declare const gridRowTreeSelector: ((state: {
1391
- rows: GridRowsState;
1392
- editRows: GridEditRowsModel;
1393
- pagination: GridPaginationState;
1394
- columns: GridColumnsState;
1395
- columnReorder: GridColumnReorderState;
1396
- columnResize: GridColumnResizeState;
1397
- columnMenu: GridColumnMenuState;
1398
- sorting: GridSortingState;
1399
- focus: GridFocusState;
1400
- tabIndex: GridTabIndexState;
1401
- selection: GridSelectionModel;
1402
- filter: GridFilterState;
1403
- preferencePanel: GridPreferencePanelState;
1404
- density: GridDensityState;
1405
- rowGrouping: GridRowGroupingState;
1406
- error?: any;
1407
- pinnedColumns: GridPinnedColumns;
1408
- }) => GridRowTreeConfig) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowTreeConfig & {
1409
- clearCache: () => void;
1410
- }> & {
1411
- clearCache: () => void;
1412
- };
1413
- declare const gridRowGroupingNameSelector: ((state: {
1414
- rows: GridRowsState;
1415
- editRows: GridEditRowsModel;
1416
- pagination: GridPaginationState;
1417
- columns: GridColumnsState;
1418
- columnReorder: GridColumnReorderState;
1419
- columnResize: GridColumnResizeState;
1420
- columnMenu: GridColumnMenuState;
1421
- sorting: GridSortingState;
1422
- focus: GridFocusState;
1423
- tabIndex: GridTabIndexState;
1424
- selection: GridSelectionModel;
1425
- filter: GridFilterState;
1426
- preferencePanel: GridPreferencePanelState;
1427
- density: GridDensityState;
1428
- rowGrouping: GridRowGroupingState;
1429
- error?: any;
1430
- pinnedColumns: GridPinnedColumns;
1431
- }) => string) & reselect.OutputSelectorFields<(args_0: GridRowsState) => string & {
1432
- clearCache: () => void;
1433
- }> & {
1434
- clearCache: () => void;
1435
- };
1436
- declare const gridRowTreeDepthSelector: ((state: {
1437
- rows: GridRowsState;
1438
- editRows: GridEditRowsModel;
1439
- pagination: GridPaginationState;
1440
- columns: GridColumnsState;
1441
- columnReorder: GridColumnReorderState;
1442
- columnResize: GridColumnResizeState;
1443
- columnMenu: GridColumnMenuState;
1444
- sorting: GridSortingState;
1445
- focus: GridFocusState;
1446
- tabIndex: GridTabIndexState;
1447
- selection: GridSelectionModel;
1448
- filter: GridFilterState;
1449
- preferencePanel: GridPreferencePanelState;
1450
- density: GridDensityState;
1451
- rowGrouping: GridRowGroupingState;
1452
- error?: any;
1453
- pinnedColumns: GridPinnedColumns;
1454
- }) => number) & reselect.OutputSelectorFields<(args_0: GridRowsState) => number & {
1455
- clearCache: () => void;
1456
- }> & {
1457
- clearCache: () => void;
1458
- };
1459
- declare const gridRowIdsSelector: ((state: {
1460
- rows: GridRowsState;
1461
- editRows: GridEditRowsModel;
1462
- pagination: GridPaginationState;
1463
- columns: GridColumnsState;
1464
- columnReorder: GridColumnReorderState;
1465
- columnResize: GridColumnResizeState;
1466
- columnMenu: GridColumnMenuState;
1467
- sorting: GridSortingState;
1468
- focus: GridFocusState;
1469
- tabIndex: GridTabIndexState;
1470
- selection: GridSelectionModel;
1471
- filter: GridFilterState;
1472
- preferencePanel: GridPreferencePanelState;
1473
- density: GridDensityState;
1474
- rowGrouping: GridRowGroupingState;
1475
- error?: any;
1476
- pinnedColumns: GridPinnedColumns;
1477
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridRowsState) => GridRowId[] & {
1478
- clearCache: () => void;
1479
- }> & {
1480
- clearCache: () => void;
1481
- };
1143
+ declare const gridRowGroupingStateSelector: (state: GridState) => GridRowGroupingState;
1144
+ declare const gridRowGroupingModelSelector: OutputSelector<GridRowGroupingModel>;
1145
+ declare const gridRowGroupingSanitizedModelSelector: OutputSelector<string[]>;
1482
1146
 
1483
1147
  /**
1484
1148
  * @category Filtering
@@ -1489,1064 +1153,95 @@ declare const gridFilterStateSelector: (state: GridState) => GridFilterState;
1489
1153
  * Get the current filter model.
1490
1154
  * @category Filtering
1491
1155
  */
1492
- declare const gridFilterModelSelector: ((state: {
1493
- rows: GridRowsState;
1494
- editRows: GridEditRowsModel;
1495
- pagination: GridPaginationState;
1496
- columns: GridColumnsState;
1497
- columnReorder: GridColumnReorderState;
1498
- columnResize: GridColumnResizeState;
1499
- columnMenu: GridColumnMenuState;
1500
- sorting: GridSortingState;
1501
- focus: GridFocusState;
1502
- tabIndex: GridTabIndexState;
1503
- selection: GridSelectionModel;
1504
- filter: GridFilterState;
1505
- preferencePanel: GridPreferencePanelState;
1506
- density: GridDensityState;
1507
- rowGrouping: GridRowGroupingState;
1508
- error?: any;
1509
- pinnedColumns: GridPinnedColumns;
1510
- }) => GridFilterModel) & reselect.OutputSelectorFields<(args_0: GridFilterState) => GridFilterModel & {
1511
- clearCache: () => void;
1512
- }> & {
1513
- clearCache: () => void;
1514
- };
1156
+ declare const gridFilterModelSelector: OutputSelector<GridFilterModel>;
1515
1157
  /**
1516
1158
  * @category Filtering
1517
1159
  * @ignore - do not document.
1518
1160
  */
1519
- declare const gridVisibleRowsLookupSelector: ((state: {
1520
- rows: GridRowsState;
1521
- editRows: GridEditRowsModel;
1522
- pagination: GridPaginationState;
1523
- columns: GridColumnsState;
1524
- columnReorder: GridColumnReorderState;
1525
- columnResize: GridColumnResizeState;
1526
- columnMenu: GridColumnMenuState;
1527
- sorting: GridSortingState;
1528
- focus: GridFocusState;
1529
- tabIndex: GridTabIndexState;
1530
- selection: GridSelectionModel;
1531
- filter: GridFilterState;
1532
- preferencePanel: GridPreferencePanelState;
1533
- density: GridDensityState;
1534
- rowGrouping: GridRowGroupingState;
1535
- error?: any;
1536
- pinnedColumns: GridPinnedColumns;
1537
- }) => Record<GridRowId, boolean>) & reselect.OutputSelectorFields<(args_0: GridFilterState) => Record<GridRowId, boolean> & {
1538
- clearCache: () => void;
1539
- }> & {
1540
- clearCache: () => void;
1541
- };
1161
+ declare const gridVisibleRowsLookupSelector: OutputSelector<Record<GridRowId, boolean>>;
1542
1162
  /**
1543
1163
  * @category Filtering
1544
1164
  * @ignore - do not document.
1545
1165
  */
1546
- declare const gridFilteredDescendantCountLookupSelector: ((state: {
1547
- rows: GridRowsState;
1548
- editRows: GridEditRowsModel;
1549
- pagination: GridPaginationState;
1550
- columns: GridColumnsState;
1551
- columnReorder: GridColumnReorderState;
1552
- columnResize: GridColumnResizeState;
1553
- columnMenu: GridColumnMenuState;
1554
- sorting: GridSortingState;
1555
- focus: GridFocusState;
1556
- tabIndex: GridTabIndexState;
1557
- selection: GridSelectionModel;
1558
- filter: GridFilterState;
1559
- preferencePanel: GridPreferencePanelState;
1560
- density: GridDensityState;
1561
- rowGrouping: GridRowGroupingState;
1562
- error?: any;
1563
- pinnedColumns: GridPinnedColumns;
1564
- }) => Record<GridRowId, number>) & reselect.OutputSelectorFields<(args_0: GridFilterState) => Record<GridRowId, number> & {
1565
- clearCache: () => void;
1566
- }> & {
1567
- clearCache: () => void;
1568
- };
1166
+ declare const gridFilteredRowsLookupSelector: OutputSelector<Record<GridRowId, boolean>>;
1167
+ /**
1168
+ * @category Filtering
1169
+ * @ignore - do not document.
1170
+ */
1171
+ declare const gridFilteredDescendantCountLookupSelector: OutputSelector<Record<GridRowId, number>>;
1569
1172
  /**
1570
1173
  * Get the id and the model of the rows accessible after the filtering process.
1174
+ * Does not contain the collapsed children.
1571
1175
  * @category Filtering
1572
1176
  */
1573
- declare const gridVisibleSortedRowEntriesSelector: ((state: {
1574
- rows: GridRowsState;
1575
- editRows: GridEditRowsModel;
1576
- pagination: GridPaginationState;
1577
- columns: GridColumnsState;
1578
- columnReorder: GridColumnReorderState;
1579
- columnResize: GridColumnResizeState;
1580
- columnMenu: GridColumnMenuState;
1581
- sorting: GridSortingState;
1582
- focus: GridFocusState;
1583
- tabIndex: GridTabIndexState;
1584
- selection: GridSelectionModel;
1585
- filter: GridFilterState;
1586
- preferencePanel: GridPreferencePanelState;
1587
- density: GridDensityState;
1588
- rowGrouping: GridRowGroupingState;
1589
- error?: any;
1590
- pinnedColumns: GridPinnedColumns;
1591
- }) => {
1592
- id: GridRowId;
1593
- model: {
1594
- [key: string]: any;
1595
- };
1596
- }[]) & reselect.OutputSelectorFields<(args_0: Record<GridRowId, boolean>, args_1: {
1597
- id: GridRowId;
1598
- model: {
1599
- [key: string]: any;
1600
- };
1601
- }[]) => {
1177
+ declare const gridVisibleSortedRowEntriesSelector: OutputSelector<{
1602
1178
  id: GridRowId;
1603
1179
  model: {
1604
1180
  [key: string]: any;
1605
1181
  };
1606
- }[] & {
1607
- clearCache: () => void;
1608
- }> & {
1609
- clearCache: () => void;
1610
- };
1182
+ }[]>;
1611
1183
  /**
1612
1184
  * Get the id of the rows accessible after the filtering process.
1185
+ * Does not contain the collapsed children.
1613
1186
  * @category Filtering
1614
1187
  */
1615
- declare const gridVisibleSortedRowIdsSelector: ((state: {
1616
- rows: GridRowsState;
1617
- editRows: GridEditRowsModel;
1618
- pagination: GridPaginationState;
1619
- columns: GridColumnsState;
1620
- columnReorder: GridColumnReorderState;
1621
- columnResize: GridColumnResizeState;
1622
- columnMenu: GridColumnMenuState;
1623
- sorting: GridSortingState;
1624
- focus: GridFocusState;
1625
- tabIndex: GridTabIndexState;
1626
- selection: GridSelectionModel;
1627
- filter: GridFilterState;
1628
- preferencePanel: GridPreferencePanelState;
1629
- density: GridDensityState;
1630
- rowGrouping: GridRowGroupingState;
1631
- error?: any;
1632
- pinnedColumns: GridPinnedColumns;
1633
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: {
1188
+ declare const gridVisibleSortedRowIdsSelector: OutputSelector<GridRowId[]>;
1189
+ /**
1190
+ * Get the id and the model of the rows accessible after the filtering process.
1191
+ * Contains the collapsed children.
1192
+ * @category Filtering
1193
+ */
1194
+ declare const gridFilteredSortedRowEntriesSelector: OutputSelector<{
1634
1195
  id: GridRowId;
1635
1196
  model: {
1636
1197
  [key: string]: any;
1637
1198
  };
1638
- }[]) => GridRowId[] & {
1639
- clearCache: () => void;
1640
- }> & {
1641
- clearCache: () => void;
1642
- };
1199
+ }[]>;
1200
+ /**
1201
+ * Get the id of the rows accessible after the filtering process.
1202
+ * Contains the collapsed children.
1203
+ * @category Filtering
1204
+ */
1205
+ declare const gridFilteredSortedRowIdsSelector: OutputSelector<GridRowId[]>;
1643
1206
  /**
1644
1207
  * @category Filtering
1645
1208
  * @deprecated Use `gridVisibleSortedRowIdsSelector` instead
1646
1209
  * @ignore - do not document.
1647
1210
  */
1648
- declare const gridVisibleRowsSelector: ((state: {
1649
- rows: GridRowsState;
1650
- editRows: GridEditRowsModel;
1651
- pagination: GridPaginationState;
1652
- columns: GridColumnsState;
1653
- columnReorder: GridColumnReorderState;
1654
- columnResize: GridColumnResizeState;
1655
- columnMenu: GridColumnMenuState;
1656
- sorting: GridSortingState;
1657
- focus: GridFocusState;
1658
- tabIndex: GridTabIndexState;
1659
- selection: GridSelectionModel;
1660
- filter: GridFilterState;
1661
- preferencePanel: GridPreferencePanelState;
1662
- density: GridDensityState;
1663
- rowGrouping: GridRowGroupingState;
1664
- error?: any;
1665
- pinnedColumns: GridPinnedColumns;
1666
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: {
1211
+ declare const gridVisibleRowsSelector: OutputSelector<GridRowId[]>;
1212
+ /**
1213
+ * Get the id and the model of the top level rows accessible after the filtering process.
1214
+ * @category Filtering
1215
+ */
1216
+ declare const gridVisibleSortedTopLevelRowEntriesSelector: OutputSelector<{
1667
1217
  id: GridRowId;
1668
1218
  model: {
1669
1219
  [key: string]: any;
1670
1220
  };
1671
- }[]) => GridRowId[] & {
1672
- clearCache: () => void;
1673
- }> & {
1674
- clearCache: () => void;
1675
- };
1221
+ }[]>;
1676
1222
  /**
1677
- * Get the id and the model of the top level rows accessible after the filtering process.
1223
+ * Get the amount of rows accessible after the filtering process.
1678
1224
  * @category Filtering
1679
1225
  */
1680
- declare const gridVisibleSortedTopLevelRowEntriesSelector: ((state: {
1681
- rows: GridRowsState;
1682
- editRows: GridEditRowsModel;
1683
- pagination: GridPaginationState;
1684
- columns: GridColumnsState;
1685
- columnReorder: GridColumnReorderState;
1686
- columnResize: GridColumnResizeState;
1687
- columnMenu: GridColumnMenuState;
1688
- sorting: GridSortingState;
1689
- focus: GridFocusState;
1690
- tabIndex: GridTabIndexState;
1691
- selection: GridSelectionModel;
1692
- filter: GridFilterState;
1693
- preferencePanel: GridPreferencePanelState;
1694
- density: GridDensityState;
1695
- rowGrouping: GridRowGroupingState;
1696
- error?: any;
1697
- pinnedColumns: GridPinnedColumns;
1698
- }) => {
1699
- id: GridRowId;
1700
- model: {
1701
- [key: string]: any;
1702
- };
1703
- }[]) & reselect.OutputSelectorFields<(args_0: {
1704
- id: GridRowId;
1705
- model: {
1706
- [key: string]: any;
1707
- };
1708
- }[], args_1: GridRowTreeConfig, args_2: number) => {
1709
- id: GridRowId;
1710
- model: {
1711
- [key: string]: any;
1712
- };
1713
- }[] & {
1714
- clearCache: () => void;
1715
- }> & {
1716
- clearCache: () => void;
1717
- };
1718
- /**
1719
- * Get the amount of rows accessible after the filtering process.
1720
- * @category Filtering
1721
- */
1722
- declare const gridVisibleRowCountSelector: ((state: {
1723
- rows: GridRowsState;
1724
- editRows: GridEditRowsModel;
1725
- pagination: GridPaginationState;
1726
- columns: GridColumnsState;
1727
- columnReorder: GridColumnReorderState;
1728
- columnResize: GridColumnResizeState;
1729
- columnMenu: GridColumnMenuState;
1730
- sorting: GridSortingState;
1731
- focus: GridFocusState;
1732
- tabIndex: GridTabIndexState;
1733
- selection: GridSelectionModel;
1734
- filter: GridFilterState;
1735
- preferencePanel: GridPreferencePanelState;
1736
- density: GridDensityState;
1737
- rowGrouping: GridRowGroupingState;
1738
- error?: any;
1739
- pinnedColumns: GridPinnedColumns;
1740
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1741
- id: GridRowId;
1742
- model: {
1743
- [key: string]: any;
1744
- };
1745
- }[]) => number & {
1746
- clearCache: () => void;
1747
- }> & {
1748
- clearCache: () => void;
1749
- };
1226
+ declare const gridVisibleRowCountSelector: OutputSelector<number>;
1750
1227
  /**
1751
1228
  * Get the amount of top level rows accessible after the filtering process.
1752
1229
  * @category Filtering
1753
1230
  */
1754
- declare const gridVisibleTopLevelRowCountSelector: ((state: {
1755
- rows: GridRowsState;
1756
- editRows: GridEditRowsModel;
1757
- pagination: GridPaginationState;
1758
- columns: GridColumnsState;
1759
- columnReorder: GridColumnReorderState;
1760
- columnResize: GridColumnResizeState;
1761
- columnMenu: GridColumnMenuState;
1762
- sorting: GridSortingState;
1763
- focus: GridFocusState;
1764
- tabIndex: GridTabIndexState;
1765
- selection: GridSelectionModel;
1766
- filter: GridFilterState;
1767
- preferencePanel: GridPreferencePanelState;
1768
- density: GridDensityState;
1769
- rowGrouping: GridRowGroupingState;
1770
- error?: any;
1771
- pinnedColumns: GridPinnedColumns;
1772
- }) => number) & reselect.OutputSelectorFields<(args_0: {
1773
- id: GridRowId;
1774
- model: {
1775
- [key: string]: any;
1776
- };
1777
- }[]) => number & {
1778
- clearCache: () => void;
1779
- }> & {
1780
- clearCache: () => void;
1781
- };
1782
- /**
1783
- * @category Filtering
1784
- * @ignore - do not document.
1785
- */
1786
- declare const gridFilterActiveItemsSelector: ((state: {
1787
- rows: GridRowsState;
1788
- editRows: GridEditRowsModel;
1789
- pagination: GridPaginationState;
1790
- columns: GridColumnsState;
1791
- columnReorder: GridColumnReorderState;
1792
- columnResize: GridColumnResizeState;
1793
- columnMenu: GridColumnMenuState;
1794
- sorting: GridSortingState;
1795
- focus: GridFocusState;
1796
- tabIndex: GridTabIndexState;
1797
- selection: GridSelectionModel;
1798
- filter: GridFilterState;
1799
- preferencePanel: GridPreferencePanelState;
1800
- density: GridDensityState;
1801
- rowGrouping: GridRowGroupingState;
1802
- error?: any;
1803
- pinnedColumns: GridPinnedColumns;
1804
- }) => GridFilterItem[]) & reselect.OutputSelectorFields<(args_0: GridFilterModel, args_1: GridColumnLookup) => GridFilterItem[] & {
1805
- clearCache: () => void;
1806
- }> & {
1807
- clearCache: () => void;
1808
- };
1809
- declare type GridFilterActiveItemsLookup = {
1810
- [columnField: string]: GridFilterItem[];
1811
- };
1231
+ declare const gridVisibleTopLevelRowCountSelector: OutputSelector<number>;
1812
1232
  /**
1813
1233
  * @category Filtering
1814
1234
  * @ignore - do not document.
1815
1235
  */
1816
- declare const gridFilterActiveItemsLookupSelector: ((state: {
1817
- rows: GridRowsState;
1818
- editRows: GridEditRowsModel;
1819
- pagination: GridPaginationState;
1820
- columns: GridColumnsState;
1821
- columnReorder: GridColumnReorderState;
1822
- columnResize: GridColumnResizeState;
1823
- columnMenu: GridColumnMenuState;
1824
- sorting: GridSortingState;
1825
- focus: GridFocusState;
1826
- tabIndex: GridTabIndexState;
1827
- selection: GridSelectionModel;
1828
- filter: GridFilterState;
1829
- preferencePanel: GridPreferencePanelState;
1830
- density: GridDensityState;
1831
- rowGrouping: GridRowGroupingState;
1832
- error?: any;
1833
- pinnedColumns: GridPinnedColumns;
1834
- }) => GridFilterActiveItemsLookup) & reselect.OutputSelectorFields<(args_0: GridFilterItem[]) => GridFilterActiveItemsLookup & {
1835
- clearCache: () => void;
1836
- }> & {
1837
- clearCache: () => void;
1838
- };
1839
-
1840
- declare type GridCellIdentifier = {
1841
- id: GridRowId;
1842
- field: string;
1843
- };
1844
- declare type GridColumnIdentifier = {
1845
- field: string;
1846
- };
1847
- interface GridFocusState {
1848
- cell: GridCellIdentifier | null;
1849
- columnHeader: GridColumnIdentifier | null;
1850
- }
1851
- interface GridTabIndexState {
1852
- cell: GridCellIdentifier | null;
1853
- columnHeader: GridColumnIdentifier | null;
1854
- }
1855
-
1856
- declare const gridFocusStateSelector: (state: GridState) => GridFocusState;
1857
- declare const gridFocusCellSelector: ((state: {
1858
- rows: GridRowsState;
1859
- editRows: GridEditRowsModel;
1860
- pagination: GridPaginationState;
1861
- columns: GridColumnsState;
1862
- columnReorder: GridColumnReorderState;
1863
- columnResize: GridColumnResizeState;
1864
- columnMenu: GridColumnMenuState;
1865
- sorting: GridSortingState;
1866
- focus: GridFocusState;
1867
- tabIndex: GridTabIndexState;
1868
- selection: GridSelectionModel;
1869
- filter: GridFilterState;
1870
- preferencePanel: GridPreferencePanelState;
1871
- density: GridDensityState;
1872
- rowGrouping: GridRowGroupingState;
1873
- error?: any;
1874
- pinnedColumns: GridPinnedColumns;
1875
- }) => GridCellIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridFocusState) => GridCellIdentifier & {
1876
- clearCache: () => void;
1877
- }> & {
1878
- clearCache: () => void;
1879
- };
1880
- declare const gridFocusColumnHeaderSelector: ((state: {
1881
- rows: GridRowsState;
1882
- editRows: GridEditRowsModel;
1883
- pagination: GridPaginationState;
1884
- columns: GridColumnsState;
1885
- columnReorder: GridColumnReorderState;
1886
- columnResize: GridColumnResizeState;
1887
- columnMenu: GridColumnMenuState;
1888
- sorting: GridSortingState;
1889
- focus: GridFocusState;
1890
- tabIndex: GridTabIndexState;
1891
- selection: GridSelectionModel;
1892
- filter: GridFilterState;
1893
- preferencePanel: GridPreferencePanelState;
1894
- density: GridDensityState;
1895
- rowGrouping: GridRowGroupingState;
1896
- error?: any;
1897
- pinnedColumns: GridPinnedColumns;
1898
- }) => GridColumnIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridFocusState) => GridColumnIdentifier & {
1899
- clearCache: () => void;
1900
- }> & {
1901
- clearCache: () => void;
1902
- };
1903
- declare const gridTabIndexStateSelector: (state: GridState) => GridTabIndexState;
1904
- declare const gridTabIndexCellSelector: ((state: {
1905
- rows: GridRowsState;
1906
- editRows: GridEditRowsModel;
1907
- pagination: GridPaginationState;
1908
- columns: GridColumnsState;
1909
- columnReorder: GridColumnReorderState;
1910
- columnResize: GridColumnResizeState;
1911
- columnMenu: GridColumnMenuState;
1912
- sorting: GridSortingState;
1913
- focus: GridFocusState;
1914
- tabIndex: GridTabIndexState;
1915
- selection: GridSelectionModel;
1916
- filter: GridFilterState;
1917
- preferencePanel: GridPreferencePanelState;
1918
- density: GridDensityState;
1919
- rowGrouping: GridRowGroupingState;
1920
- error?: any;
1921
- pinnedColumns: GridPinnedColumns;
1922
- }) => GridCellIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridTabIndexState) => GridCellIdentifier & {
1923
- clearCache: () => void;
1924
- }> & {
1925
- clearCache: () => void;
1926
- };
1927
- declare const gridTabIndexColumnHeaderSelector: ((state: {
1928
- rows: GridRowsState;
1929
- editRows: GridEditRowsModel;
1930
- pagination: GridPaginationState;
1931
- columns: GridColumnsState;
1932
- columnReorder: GridColumnReorderState;
1933
- columnResize: GridColumnResizeState;
1934
- columnMenu: GridColumnMenuState;
1935
- sorting: GridSortingState;
1936
- focus: GridFocusState;
1937
- tabIndex: GridTabIndexState;
1938
- selection: GridSelectionModel;
1939
- filter: GridFilterState;
1940
- preferencePanel: GridPreferencePanelState;
1941
- density: GridDensityState;
1942
- rowGrouping: GridRowGroupingState;
1943
- error?: any;
1944
- pinnedColumns: GridPinnedColumns;
1945
- }) => GridColumnIdentifier | null) & reselect.OutputSelectorFields<(args_0: GridTabIndexState) => GridColumnIdentifier & {
1946
- clearCache: () => void;
1947
- }> & {
1948
- clearCache: () => void;
1949
- };
1950
-
1951
- interface GridPaginationState {
1952
- pageSize: number;
1953
- page: number;
1954
- pageCount: number;
1955
- rowCount: number;
1956
- }
1957
- interface GridPaginationInitialState {
1958
- pageSize?: number;
1959
- page?: number;
1960
- }
1961
- /**
1962
- * The apiRef methods handled by `useGridPageSize`
1963
- */
1964
- interface GridPageSizeApi {
1965
- /**
1966
- * Sets the number of displayed rows to the value given by `pageSize`.
1967
- * @param {number} pageSize The new number of displayed rows.
1968
- */
1969
- setPageSize: (pageSize: number) => void;
1970
- }
1971
- /**
1972
- * The apiRef methods handled by `useGridPage`
1973
- */
1974
- interface GridPageApi {
1975
- /**
1976
- * Sets the displayed page to the value given by `page`.
1977
- * @param {number} page The new page number.
1978
- */
1979
- setPage: (page: number) => void;
1980
- }
1981
- /**
1982
- * The pagination API interface that is available in the grid [[apiRef]].
1983
- */
1984
- interface GridPaginationApi extends GridPageApi, GridPageSizeApi {
1985
- }
1986
-
1987
- /**
1988
- * @category Pagination
1989
- * @ignore - do not document.
1990
- */
1991
- declare const gridPaginationSelector: (state: GridState) => GridPaginationState;
1992
- /**
1993
- * Get the index of the page to render if the pagination is enabled
1994
- * @category Pagination
1995
- */
1996
- declare const gridPageSelector: ((state: {
1997
- rows: GridRowsState;
1998
- editRows: GridEditRowsModel;
1999
- pagination: GridPaginationState;
2000
- columns: GridColumnsState;
2001
- columnReorder: GridColumnReorderState;
2002
- columnResize: GridColumnResizeState;
2003
- columnMenu: GridColumnMenuState;
2004
- sorting: GridSortingState;
2005
- focus: GridFocusState;
2006
- tabIndex: GridTabIndexState;
2007
- selection: GridSelectionModel;
2008
- filter: GridFilterState;
2009
- preferencePanel: GridPreferencePanelState;
2010
- density: GridDensityState;
2011
- rowGrouping: GridRowGroupingState;
2012
- error?: any;
2013
- pinnedColumns: GridPinnedColumns;
2014
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2015
- clearCache: () => void;
2016
- }> & {
2017
- clearCache: () => void;
2018
- };
2019
- /**
2020
- * Get the maximum amount of rows to display on a single page if the pagination is enabled
2021
- * @category Pagination
2022
- */
2023
- declare const gridPageSizeSelector: ((state: {
2024
- rows: GridRowsState;
2025
- editRows: GridEditRowsModel;
2026
- pagination: GridPaginationState;
2027
- columns: GridColumnsState;
2028
- columnReorder: GridColumnReorderState;
2029
- columnResize: GridColumnResizeState;
2030
- columnMenu: GridColumnMenuState;
2031
- sorting: GridSortingState;
2032
- focus: GridFocusState;
2033
- tabIndex: GridTabIndexState;
2034
- selection: GridSelectionModel;
2035
- filter: GridFilterState;
2036
- preferencePanel: GridPreferencePanelState;
2037
- density: GridDensityState;
2038
- rowGrouping: GridRowGroupingState;
2039
- error?: any;
2040
- pinnedColumns: GridPinnedColumns;
2041
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2042
- clearCache: () => void;
2043
- }> & {
2044
- clearCache: () => void;
2045
- };
2046
- /**
2047
- * Get the amount of pages needed to display all the rows if the pagination is enabled
2048
- * @category Pagination
2049
- */
2050
- declare const gridPageCountSelector: ((state: {
2051
- rows: GridRowsState;
2052
- editRows: GridEditRowsModel;
2053
- pagination: GridPaginationState;
2054
- columns: GridColumnsState;
2055
- columnReorder: GridColumnReorderState;
2056
- columnResize: GridColumnResizeState;
2057
- columnMenu: GridColumnMenuState;
2058
- sorting: GridSortingState;
2059
- focus: GridFocusState;
2060
- tabIndex: GridTabIndexState;
2061
- selection: GridSelectionModel;
2062
- filter: GridFilterState;
2063
- preferencePanel: GridPreferencePanelState;
2064
- density: GridDensityState;
2065
- rowGrouping: GridRowGroupingState;
2066
- error?: any;
2067
- pinnedColumns: GridPinnedColumns;
2068
- }) => number) & reselect.OutputSelectorFields<(args_0: GridPaginationState) => number & {
2069
- clearCache: () => void;
2070
- }> & {
2071
- clearCache: () => void;
2072
- };
2073
- /**
2074
- * Get the index of the first and the last row to include in the current page if the pagination is enabled.
2075
- * @category Pagination
2076
- */
2077
- declare const gridPaginationRowRangeSelector: ((state: {
2078
- rows: GridRowsState;
2079
- editRows: GridEditRowsModel;
2080
- pagination: GridPaginationState;
2081
- columns: GridColumnsState;
2082
- columnReorder: GridColumnReorderState;
2083
- columnResize: GridColumnResizeState;
2084
- columnMenu: GridColumnMenuState;
2085
- sorting: GridSortingState;
2086
- focus: GridFocusState;
2087
- tabIndex: GridTabIndexState;
2088
- selection: GridSelectionModel;
2089
- filter: GridFilterState;
2090
- preferencePanel: GridPreferencePanelState;
2091
- density: GridDensityState;
2092
- rowGrouping: GridRowGroupingState;
2093
- error?: any;
2094
- pinnedColumns: GridPinnedColumns;
2095
- }) => {
2096
- firstRowIndex: number;
2097
- lastRowIndex: number;
2098
- } | null) & reselect.OutputSelectorFields<(args_0: GridPaginationState, args_1: GridRowTreeConfig, args_2: number, args_3: {
2099
- id: GridRowId;
2100
- model: {
2101
- [key: string]: any;
2102
- };
2103
- }[], args_4: {
2104
- id: GridRowId;
2105
- model: {
2106
- [key: string]: any;
2107
- };
2108
- }[]) => {
2109
- firstRowIndex: number;
2110
- lastRowIndex: number;
2111
- } & {
2112
- clearCache: () => void;
2113
- }> & {
2114
- clearCache: () => void;
2115
- };
2116
- /**
2117
- * Get the id and the model of each row to include in the current page if the pagination is enabled.
2118
- * @category Pagination
2119
- */
2120
- declare const gridPaginatedVisibleSortedGridRowEntriesSelector: ((state: {
2121
- rows: GridRowsState;
2122
- editRows: GridEditRowsModel;
2123
- pagination: GridPaginationState;
2124
- columns: GridColumnsState;
2125
- columnReorder: GridColumnReorderState;
2126
- columnResize: GridColumnResizeState;
2127
- columnMenu: GridColumnMenuState;
2128
- sorting: GridSortingState;
2129
- focus: GridFocusState;
2130
- tabIndex: GridTabIndexState;
2131
- selection: GridSelectionModel;
2132
- filter: GridFilterState;
2133
- preferencePanel: GridPreferencePanelState;
2134
- density: GridDensityState;
2135
- rowGrouping: GridRowGroupingState;
2136
- error?: any;
2137
- pinnedColumns: GridPinnedColumns;
2138
- }) => {
2139
- id: GridRowId;
2140
- model: {
2141
- [key: string]: any;
2142
- };
2143
- }[]) & reselect.OutputSelectorFields<(args_0: {
2144
- id: GridRowId;
2145
- model: {
2146
- [key: string]: any;
2147
- };
2148
- }[], args_1: {
2149
- firstRowIndex: number;
2150
- lastRowIndex: number;
2151
- } | null) => {
2152
- id: GridRowId;
2153
- model: {
2154
- [key: string]: any;
2155
- };
2156
- }[] & {
2157
- clearCache: () => void;
2158
- }> & {
2159
- clearCache: () => void;
2160
- };
2161
- /**
2162
- * Get the id of each row to include in the current page if the pagination is enabled.
2163
- * @category Pagination
2164
- */
2165
- declare const gridPaginatedVisibleSortedGridRowIdsSelector: ((state: {
2166
- rows: GridRowsState;
2167
- editRows: GridEditRowsModel;
2168
- pagination: GridPaginationState;
2169
- columns: GridColumnsState;
2170
- columnReorder: GridColumnReorderState;
2171
- columnResize: GridColumnResizeState;
2172
- columnMenu: GridColumnMenuState;
2173
- sorting: GridSortingState;
2174
- focus: GridFocusState;
2175
- tabIndex: GridTabIndexState;
2176
- selection: GridSelectionModel;
2177
- filter: GridFilterState;
2178
- preferencePanel: GridPreferencePanelState;
2179
- density: GridDensityState;
2180
- rowGrouping: GridRowGroupingState;
2181
- error?: any;
2182
- pinnedColumns: GridPinnedColumns;
2183
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridRowId[], args_1: {
2184
- firstRowIndex: number;
2185
- lastRowIndex: number;
2186
- } | null) => GridRowId[] & {
2187
- clearCache: () => void;
2188
- }> & {
2189
- clearCache: () => void;
2190
- };
2191
-
2192
- declare enum GridPreferencePanelsValue {
2193
- filters = "filters",
2194
- columns = "columns"
2195
- }
2196
-
2197
- interface GridPreferencePanelState {
2198
- open: boolean;
2199
- openedPanelValue?: GridPreferencePanelsValue;
2200
- }
2201
- declare type GridPreferencePanelInitialState = GridPreferencePanelState;
2202
-
2203
- declare const gridPreferencePanelStateSelector: (state: GridState) => GridPreferencePanelState;
2204
-
2205
- declare const gridSelectionStateSelector: (state: GridState) => GridSelectionModel;
2206
- declare const selectedGridRowsCountSelector: ((state: {
2207
- rows: GridRowsState;
2208
- editRows: GridEditRowsModel;
2209
- pagination: GridPaginationState;
2210
- columns: GridColumnsState;
2211
- columnReorder: GridColumnReorderState;
2212
- columnResize: GridColumnResizeState;
2213
- columnMenu: GridColumnMenuState;
2214
- sorting: GridSortingState;
2215
- focus: GridFocusState;
2216
- tabIndex: GridTabIndexState;
2217
- selection: GridSelectionModel;
2218
- filter: GridFilterState;
2219
- preferencePanel: GridPreferencePanelState;
2220
- density: GridDensityState;
2221
- rowGrouping: GridRowGroupingState;
2222
- error?: any;
2223
- pinnedColumns: GridPinnedColumns;
2224
- }) => number) & reselect.OutputSelectorFields<(args_0: GridSelectionModel) => number & {
2225
- clearCache: () => void;
2226
- }> & {
2227
- clearCache: () => void;
2228
- };
2229
- declare const selectedGridRowsSelector: ((state: {
2230
- rows: GridRowsState;
2231
- editRows: GridEditRowsModel;
2232
- pagination: GridPaginationState;
2233
- columns: GridColumnsState;
2234
- columnReorder: GridColumnReorderState;
2235
- columnResize: GridColumnResizeState;
2236
- columnMenu: GridColumnMenuState;
2237
- sorting: GridSortingState;
2238
- focus: GridFocusState;
2239
- tabIndex: GridTabIndexState;
2240
- selection: GridSelectionModel;
2241
- filter: GridFilterState;
2242
- preferencePanel: GridPreferencePanelState;
2243
- density: GridDensityState;
2244
- rowGrouping: GridRowGroupingState;
2245
- error?: any;
2246
- pinnedColumns: GridPinnedColumns;
2247
- }) => Map<GridRowId, {
2248
- [key: string]: any;
2249
- }>) & reselect.OutputSelectorFields<(args_0: GridSelectionModel, args_1: GridRowsLookup) => Map<GridRowId, {
2250
- [key: string]: any;
2251
- }> & {
2252
- clearCache: () => void;
2253
- }> & {
2254
- clearCache: () => void;
2255
- };
2256
- declare const selectedIdsLookupSelector: ((state: {
2257
- rows: GridRowsState;
2258
- editRows: GridEditRowsModel;
2259
- pagination: GridPaginationState;
2260
- columns: GridColumnsState;
2261
- columnReorder: GridColumnReorderState;
2262
- columnResize: GridColumnResizeState;
2263
- columnMenu: GridColumnMenuState;
2264
- sorting: GridSortingState;
2265
- focus: GridFocusState;
2266
- tabIndex: GridTabIndexState;
2267
- selection: GridSelectionModel;
2268
- filter: GridFilterState;
2269
- preferencePanel: GridPreferencePanelState;
2270
- density: GridDensityState;
2271
- rowGrouping: GridRowGroupingState;
2272
- error?: any;
2273
- pinnedColumns: GridPinnedColumns;
2274
- }) => {}) & reselect.OutputSelectorFields<(args_0: GridSelectionModel) => {
2275
- clearCache: () => void;
2276
- }> & {
2277
- clearCache: () => void;
2278
- };
2279
-
2280
- interface GridSortingState {
2281
- sortedRows: GridRowId[];
2282
- sortModel: GridSortModel;
2283
- }
2284
- interface GridSortingInitialState {
2285
- sortModel?: GridSortModel;
2286
- }
2287
- declare type GridSortingModelApplier = (rowList: GridRowTreeNodeConfig[]) => GridRowId[];
2288
- interface GridSortingParams {
2289
- sortRowList: GridSortingModelApplier | null;
2290
- }
2291
- declare type GridSortingMethod = (params: GridSortingParams) => GridRowId[];
2292
- declare type GridSortingMethodCollection = {
2293
- [methodName: string]: GridSortingMethod;
2294
- };
2295
-
2296
- /**
2297
- * Get the id of the rows after the sorting process.
2298
- * @category Sorting
2299
- */
2300
- declare const gridSortedRowIdsSelector: ((state: {
2301
- rows: GridRowsState;
2302
- editRows: GridEditRowsModel;
2303
- pagination: GridPaginationState;
2304
- columns: GridColumnsState;
2305
- columnReorder: GridColumnReorderState;
2306
- columnResize: GridColumnResizeState;
2307
- columnMenu: GridColumnMenuState;
2308
- sorting: GridSortingState;
2309
- focus: GridFocusState;
2310
- tabIndex: GridTabIndexState;
2311
- selection: GridSelectionModel;
2312
- filter: GridFilterState;
2313
- preferencePanel: GridPreferencePanelState;
2314
- density: GridDensityState;
2315
- rowGrouping: GridRowGroupingState;
2316
- error?: any;
2317
- pinnedColumns: GridPinnedColumns;
2318
- }) => GridRowId[]) & reselect.OutputSelectorFields<(args_0: GridSortingState) => GridRowId[] & {
2319
- clearCache: () => void;
2320
- }> & {
2321
- clearCache: () => void;
2322
- };
2323
- /**
2324
- * Get the id and the model of the rows after the sorting process.
2325
- * @category Sorting
2326
- */
2327
- declare const gridSortedRowEntriesSelector: ((state: {
2328
- rows: GridRowsState;
2329
- editRows: GridEditRowsModel;
2330
- pagination: GridPaginationState;
2331
- columns: GridColumnsState;
2332
- columnReorder: GridColumnReorderState;
2333
- columnResize: GridColumnResizeState;
2334
- columnMenu: GridColumnMenuState;
2335
- sorting: GridSortingState;
2336
- focus: GridFocusState;
2337
- tabIndex: GridTabIndexState;
2338
- selection: GridSelectionModel;
2339
- filter: GridFilterState;
2340
- preferencePanel: GridPreferencePanelState;
2341
- density: GridDensityState;
2342
- rowGrouping: GridRowGroupingState;
2343
- error?: any;
2344
- pinnedColumns: GridPinnedColumns;
2345
- }) => {
2346
- id: GridRowId;
2347
- model: {
2348
- [key: string]: any;
2349
- };
2350
- }[]) & reselect.OutputSelectorFields<(args_0: GridRowId[], args_1: GridRowsLookup) => {
2351
- id: GridRowId;
2352
- model: {
2353
- [key: string]: any;
2354
- };
2355
- }[] & {
2356
- clearCache: () => void;
2357
- }> & {
2358
- clearCache: () => void;
2359
- };
2360
- /**
2361
- * Get the current sorting model.
2362
- * @category Sorting
2363
- */
2364
- declare const gridSortModelSelector: ((state: {
2365
- rows: GridRowsState;
2366
- editRows: GridEditRowsModel;
2367
- pagination: GridPaginationState;
2368
- columns: GridColumnsState;
2369
- columnReorder: GridColumnReorderState;
2370
- columnResize: GridColumnResizeState;
2371
- columnMenu: GridColumnMenuState;
2372
- sorting: GridSortingState;
2373
- focus: GridFocusState;
2374
- tabIndex: GridTabIndexState;
2375
- selection: GridSelectionModel;
2376
- filter: GridFilterState;
2377
- preferencePanel: GridPreferencePanelState;
2378
- density: GridDensityState;
2379
- rowGrouping: GridRowGroupingState;
2380
- error?: any;
2381
- pinnedColumns: GridPinnedColumns;
2382
- }) => GridSortModel) & reselect.OutputSelectorFields<(args_0: GridSortingState) => GridSortModel & {
2383
- clearCache: () => void;
2384
- }> & {
2385
- clearCache: () => void;
2386
- };
2387
- declare type GridSortColumnLookup = Record<string, {
2388
- sortDirection: GridSortDirection;
2389
- sortIndex?: number;
2390
- }>;
2391
- /**
2392
- * @category Sorting
2393
- * @ignore - do not document.
2394
- */
2395
- declare const gridSortColumnLookupSelector: ((state: {
2396
- rows: GridRowsState;
2397
- editRows: GridEditRowsModel;
2398
- pagination: GridPaginationState;
2399
- columns: GridColumnsState;
2400
- columnReorder: GridColumnReorderState;
2401
- columnResize: GridColumnResizeState;
2402
- columnMenu: GridColumnMenuState;
2403
- sorting: GridSortingState;
2404
- focus: GridFocusState;
2405
- tabIndex: GridTabIndexState;
2406
- selection: GridSelectionModel;
2407
- filter: GridFilterState;
2408
- preferencePanel: GridPreferencePanelState;
2409
- density: GridDensityState;
2410
- rowGrouping: GridRowGroupingState;
2411
- error?: any;
2412
- pinnedColumns: GridPinnedColumns;
2413
- }) => GridSortColumnLookup) & reselect.OutputSelectorFields<(args_0: GridSortModel) => GridSortColumnLookup & {
2414
- clearCache: () => void;
2415
- }> & {
2416
- clearCache: () => void;
2417
- };
2418
-
2419
- /**
2420
- * The size of a container.
2421
- */
2422
- interface ElementSize {
2423
- /**
2424
- * The height of a container or HTMLElement.
2425
- */
2426
- height: number;
2427
- /**
2428
- * The width of a container or HTMLElement.
2429
- */
2430
- width: number;
2431
- }
2432
-
2433
- interface GridDimensions {
2434
- /**
2435
- * The viewport size including scrollbars.
2436
- */
2437
- viewportOuterSize: ElementSize;
2438
- /**
2439
- * The viewport size not including scrollbars.
2440
- */
2441
- viewportInnerSize: ElementSize;
2442
- /**
2443
- * Indicates if a scroll is currently needed to go from the beginning of the first column to the end of the last column.
2444
- */
2445
- hasScrollX: boolean;
2446
- /**
2447
- * Indicates if a scroll is currently needed to go from the beginning of the first row to the end of the last row.
2448
- */
2449
- hasScrollY: boolean;
2450
- }
2451
- interface GridDimensionsApi {
2452
- /**
2453
- * Triggers a resize of the component and recalculation of width and height.
2454
- */
2455
- resize: () => void;
2456
- /**
2457
- * Returns the dimensions of the grid
2458
- * @returns {GridDimensions | null} The dimension information of the grid. If `null`, the grid is not ready yet.
2459
- */
2460
- getRootDimensions: () => GridDimensions | null;
2461
- /**
2462
- * Returns the amount of rows that are currently visible in the viewport
2463
- * @returns {number} The amount of rows visible in the viewport
2464
- * @ignore - do not document.
2465
- */
2466
- unstable_getViewportPageSize: () => number;
2467
- }
2468
-
2469
- declare const GRID_TREE_DATA_GROUPING_FIELD = "__tree_data_group__";
2470
-
2471
- declare type GridRowGroupingModel = string[];
2472
- interface GridRowGroupingState {
2473
- model: GridRowGroupingModel;
2474
- }
2475
- interface GridRowGroupingInitialState {
2476
- model?: GridRowGroupingModel;
2477
- }
2478
- interface GridRowGroupingApi {
2479
- /**
2480
- * Sets the columns to use as grouping criteria.
2481
- * @param {GridRowGroupingModel} model The columns to use as grouping criteria.
2482
- */
2483
- setRowGroupingModel: (model: GridRowGroupingModel) => void;
2484
- /**
2485
- * Adds the field to the row grouping model.
2486
- * @param {string} groupingCriteriaField The field from which we want to group the rows.
2487
- * @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.
2488
- */
2489
- addRowGroupingCriteria: (groupingCriteriaField: string, groupingIndex?: number) => void;
2490
- /**
2491
- * sRemove the field from the row grouping model.
2492
- * @param {string} groupingCriteriaField The field from which we want to stop grouping the rows.
2493
- */
2494
- removeRowGroupingCriteria: (groupingCriteriaField: string) => void;
2495
- /**
2496
- * Sets the grouping index of a grouping criteria.
2497
- * @param {string} groupingCriteriaField The field of the grouping criteria from which we want to change the grouping index.
2498
- * @param {number} groupingIndex The new grouping index of this grouping criteria.
2499
- */
2500
- setRowGroupingCriteriaIndex: (groupingCriteriaField: string, groupingIndex: number) => void;
2501
- }
2502
-
2503
- declare const gridRowGroupingStateSelector: (state: GridState) => GridRowGroupingState;
2504
- declare const gridRowGroupingModelSelector: ((state: {
2505
- rows: GridRowsState;
2506
- editRows: GridEditRowsModel;
2507
- pagination: GridPaginationState;
2508
- columns: GridColumnsState;
2509
- columnReorder: GridColumnReorderState;
2510
- columnResize: GridColumnResizeState;
2511
- columnMenu: GridColumnMenuState;
2512
- sorting: GridSortingState;
2513
- focus: GridFocusState;
2514
- tabIndex: GridTabIndexState;
2515
- selection: GridSelectionModel;
2516
- filter: GridFilterState;
2517
- preferencePanel: GridPreferencePanelState;
2518
- density: GridDensityState;
2519
- rowGrouping: GridRowGroupingState;
2520
- error?: any;
2521
- pinnedColumns: GridPinnedColumns;
2522
- }) => GridRowGroupingModel) & reselect.OutputSelectorFields<(args_0: GridRowGroupingState) => GridRowGroupingModel & {
2523
- clearCache: () => void;
2524
- }> & {
2525
- clearCache: () => void;
1236
+ declare const gridFilterActiveItemsSelector: OutputSelector<GridFilterItem[]>;
1237
+ declare type GridFilterActiveItemsLookup = {
1238
+ [columnField: string]: GridFilterItem[];
2526
1239
  };
2527
- declare const gridRowGroupingSanitizedModelSelector: ((state: {
2528
- rows: GridRowsState;
2529
- editRows: GridEditRowsModel;
2530
- pagination: GridPaginationState;
2531
- columns: GridColumnsState;
2532
- columnReorder: GridColumnReorderState;
2533
- columnResize: GridColumnResizeState;
2534
- columnMenu: GridColumnMenuState;
2535
- sorting: GridSortingState;
2536
- focus: GridFocusState;
2537
- tabIndex: GridTabIndexState;
2538
- selection: GridSelectionModel;
2539
- filter: GridFilterState;
2540
- preferencePanel: GridPreferencePanelState;
2541
- density: GridDensityState;
2542
- rowGrouping: GridRowGroupingState;
2543
- error?: any;
2544
- pinnedColumns: GridPinnedColumns;
2545
- }) => string[]) & reselect.OutputSelectorFields<(args_0: GridRowGroupingModel, args_1: GridColumnLookup) => string[] & {
2546
- clearCache: () => void;
2547
- }> & {
2548
- clearCache: () => void;
2549
- };
1240
+ /**
1241
+ * @category Filtering
1242
+ * @ignore - do not document.
1243
+ */
1244
+ declare const gridFilterActiveItemsLookupSelector: OutputSelector<GridFilterActiveItemsLookup>;
2550
1245
 
2551
1246
  declare const GridFeatureModeConstant: {
2552
1247
  client: "client";
@@ -3030,6 +1725,18 @@ interface GridClasses {
3030
1725
  * Styles applied to the right pinned columns.
3031
1726
  */
3032
1727
  'pinnedColumns--right': string;
1728
+ /**
1729
+ * Styles applied to the pinned column headers.
1730
+ */
1731
+ pinnedColumnHeaders: string;
1732
+ /**
1733
+ * Styles applied to the left pinned column headers.
1734
+ */
1735
+ 'pinnedColumnHeaders--left': string;
1736
+ /**
1737
+ * Styles applied to the right pinned column headers.
1738
+ */
1739
+ 'pinnedColumnHeaders--right': string;
3033
1740
  /**
3034
1741
  * Styles applied to the root element.
3035
1742
  */
@@ -3094,10 +1801,7 @@ interface GridClasses {
3094
1801
  }
3095
1802
  declare type GridClassKey = keyof GridClasses;
3096
1803
  declare function getDataGridUtilityClass(slot: string): string;
3097
- 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>;
3098
-
3099
- declare type GridInputSelectionModel = GridRowId[] | GridRowId;
3100
- declare type GridSelectionModel = GridRowId[];
1804
+ 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>;
3101
1805
 
3102
1806
  /**
3103
1807
  * Overrideable components props dynamically passed to the component at rendering.
@@ -3128,6 +1832,12 @@ interface GridSlotsComponentsProps {
3128
1832
  toolbar?: any;
3129
1833
  }
3130
1834
 
1835
+ interface GridExperimentalFeatures {
1836
+ /**
1837
+ * Will be part of the premium-plan when fully ready.
1838
+ */
1839
+ preventCommitWhileValidating: boolean;
1840
+ }
3131
1841
  /**
3132
1842
  * The props of the `DataGrid` component after the pre-processing phase.
3133
1843
  */
@@ -3408,6 +2118,12 @@ interface DataGridPropsWithoutDefaultValue extends CommonProps {
3408
2118
  * @returns {string} The CSS class to apply to the row.
3409
2119
  */
3410
2120
  getRowClassName?: (params: GridRowParams) => string;
2121
+ /**
2122
+ * Function that sets the row height per row.
2123
+ * @param {GridRowHeightParams} params With all properties from [[GridRowHeightParams]].
2124
+ * @returns {GridRowHeightReturnValue} The row height value. If `null` or `undefined` then the default row height is applied.
2125
+ */
2126
+ getRowHeight?: (params: GridRowHeightParams) => GridRowHeightReturnValue;
3411
2127
  /**
3412
2128
  * Callback fired when a cell is rendered, returns true if the cell is editable.
3413
2129
  * @param {GridCellParams} params With all properties from [[GridCellParams]].
@@ -3707,13 +2423,19 @@ interface DataGridPropsWithoutDefaultValue extends CommonProps {
3707
2423
  * The system prop that allows defining system overrides as well as additional CSS styles.
3708
2424
  */
3709
2425
  sx?: SxProps<Theme>;
2426
+ /**
2427
+ * Features under development.
2428
+ * 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.
2429
+ */
2430
+ experimentalFeatures?: Partial<GridExperimentalFeatures>;
3710
2431
  }
3711
2432
 
3712
- declare type GridExperimentalProFeatures =
3713
- /**
3714
- * Will be part of the premium-plan when fully ready.
3715
- */
3716
- 'rowGrouping';
2433
+ interface GridExperimentalProFeatures extends GridExperimentalFeatures {
2434
+ /**
2435
+ * Will be part of the premium-plan when fully ready.
2436
+ */
2437
+ rowGrouping: boolean;
2438
+ }
3717
2439
  /**
3718
2440
  * The props users can give to the `DataGridProProps` component.
3719
2441
  */
@@ -3722,9 +2444,7 @@ interface DataGridProProps extends Omit<Partial<DataGridProPropsWithDefaultValue
3722
2444
  * Features under development.
3723
2445
  * 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.
3724
2446
  */
3725
- experimentalFeatures?: {
3726
- [key in GridExperimentalProFeatures]?: boolean;
3727
- };
2447
+ experimentalFeatures?: Partial<GridExperimentalProFeatures>;
3728
2448
  }
3729
2449
  /**
3730
2450
  * The props of the `DataGridPro` component after the pre-processing phase.
@@ -3847,43 +2567,69 @@ interface DataGridProPropsWithoutDefaultValue extends DataGridPropsWithoutDefaul
3847
2567
  declare const GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = "__row_group_by_columns_group__";
3848
2568
  declare const getRowGroupingFieldFromGroupingCriteria: (groupingCriteria: string | null) => string;
3849
2569
 
3850
- interface GridColumnReorderState {
3851
- dragCol: string;
2570
+ interface GridPinnedColumns {
2571
+ left?: string[];
2572
+ right?: string[];
3852
2573
  }
3853
- interface GridCanBeReorderedPreProcessingContext {
3854
- targetIndex: number;
2574
+ declare enum GridPinnedPosition {
2575
+ left = "left",
2576
+ right = "right"
2577
+ }
2578
+ /**
2579
+ * The column pinning API interface that is available in the grid [[apiRef]].
2580
+ */
2581
+ interface GridColumnPinningApi {
2582
+ /**
2583
+ * Pins a column to the left or right side of the grid.
2584
+ * @param {string} field The column field to pin.
2585
+ * @param {GridPinnedPosition} side Which side to pin the column.
2586
+ */
2587
+ pinColumn: (field: string, side: GridPinnedPosition) => void;
2588
+ /**
2589
+ * Unpins a column.
2590
+ * @param {string} field The column field to unpin.
2591
+ */
2592
+ unpinColumn: (field: string) => void;
2593
+ /**
2594
+ * Returns which columns are pinned.
2595
+ * @returns {GridPinnedColumns} An object containing the pinned columns.
2596
+ */
2597
+ getPinnedColumns: () => GridPinnedColumns;
2598
+ /**
2599
+ * Changes the pinned columns.
2600
+ * @param {GridPinnedColumns} pinnedColumns An object containing the columns to pin.
2601
+ */
2602
+ setPinnedColumns: (pinnedColumns: GridPinnedColumns) => void;
2603
+ /**
2604
+ * Returns which side a column is pinned to.
2605
+ * @param {string} field The column field to check.
2606
+ * @returns {string | false} Which side the column is pinned or `false` if not pinned.
2607
+ */
2608
+ isColumnPinned: (field: string) => GridPinnedPosition | false;
3855
2609
  }
3856
2610
 
3857
- declare const gridColumnReorderSelector: (state: GridState) => GridColumnReorderState;
3858
- declare const gridColumnReorderDragColSelector: ((state: {
3859
- rows: GridRowsState;
3860
- editRows: GridEditRowsModel;
3861
- pagination: GridPaginationState;
3862
- columns: GridColumnsState;
3863
- columnReorder: GridColumnReorderState;
3864
- columnResize: GridColumnResizeState;
3865
- columnMenu: GridColumnMenuState;
3866
- sorting: GridSortingState;
3867
- focus: GridFocusState;
3868
- tabIndex: GridTabIndexState;
3869
- selection: GridSelectionModel;
3870
- filter: GridFilterState;
3871
- preferencePanel: GridPreferencePanelState;
3872
- density: GridDensityState;
3873
- rowGrouping: GridRowGroupingState;
3874
- error?: any;
3875
- pinnedColumns: GridPinnedColumns;
3876
- }) => string) & reselect.OutputSelectorFields<(args_0: GridColumnReorderState) => string & {
3877
- clearCache: () => void;
3878
- }> & {
3879
- clearCache: () => void;
3880
- };
2611
+ declare type GridColumnPinningState = GridPinnedColumns;
2612
+
2613
+ /**
2614
+ * The grid rows total height and row possitions.
2615
+ */
2616
+ interface GridRowsMetaState {
2617
+ /**
2618
+ * The sum of of all visible grid rows in the current rows.
2619
+ */
2620
+ currentPageTotalHeight: number;
2621
+ /**
2622
+ * The grid rows possitions.
2623
+ */
2624
+ positions: number[];
2625
+ }
3881
2626
 
3882
2627
  /**
3883
2628
  * TODO: Distinguish pro and community states
3884
2629
  */
3885
2630
  interface GridState {
3886
2631
  rows: GridRowsState;
2632
+ rowsMeta: GridRowsMetaState;
3887
2633
  editRows: GridEditRowsModel;
3888
2634
  pagination: GridPaginationState;
3889
2635
  columns: GridColumnsState;
@@ -3943,6 +2689,20 @@ interface GridValueOptionsParams {
3943
2689
  row?: GridRowModel;
3944
2690
  }
3945
2691
 
2692
+ /**
2693
+ * The size of a container.
2694
+ */
2695
+ interface ElementSize {
2696
+ /**
2697
+ * The height of a container or HTMLElement.
2698
+ */
2699
+ height: number;
2700
+ /**
2701
+ * The width of a container or HTMLElement.
2702
+ */
2703
+ width: number;
2704
+ }
2705
+
3946
2706
  declare type PreProcessorCallback = (value: any, params?: any) => any;
3947
2707
  declare enum GridPreProcessingGroup {
3948
2708
  hydrateColumns = "hydrateColumns",
@@ -4381,6 +3141,11 @@ interface GridCoreApi {
4381
3141
  * @param {any} props Props to be passed to the `ErrorOverlay` component.
4382
3142
  */
4383
3143
  showError: (props: any) => void;
3144
+ /**
3145
+ * Unique identifier for each component instance in a page.
3146
+ * @ignore - do not document.
3147
+ */
3148
+ instanceId: number;
4384
3149
  }
4385
3150
 
4386
3151
  interface GridDensityOption {
@@ -4452,8 +3217,9 @@ interface GridEditRowApi {
4452
3217
  * Commonly used inside the edit cell component.
4453
3218
  * @param {GridEditCellValueParams} params Contains the id, field and value to set.
4454
3219
  * @param {React.SyntheticEvent} event The event to pass forward.
3220
+ * @returns {Promise<boolean> | void} A promise with the validation status if `preventCommitWhileValidating` is `true`. Otherwise, void.
4455
3221
  */
4456
- setEditCellValue: (params: GridEditCellValueParams, event?: MuiBaseEvent) => void;
3222
+ setEditCellValue: (params: GridEditCellValueParams, event?: MuiBaseEvent) => Promise<boolean> | void;
4457
3223
  /**
4458
3224
  * Updates the field at the given id with the value stored in the edit row model.
4459
3225
  * @param {GridCommitCellChangeParams} params The id and field to commit to.
@@ -4519,6 +3285,19 @@ interface GridRowApi {
4519
3285
  setRowChildrenExpansion: (id: GridRowId, isExpanded: boolean) => void;
4520
3286
  }
4521
3287
 
3288
+ /**
3289
+ * The Row Meta API interface that is available in the grid `apiRef`.
3290
+ */
3291
+ interface GridRowsMetaApi {
3292
+ /**
3293
+ * Gets target row height.
3294
+ * @param {GridRowId} id The id of the row.
3295
+ * @returns {number} The target row height.
3296
+ * @ignore - do not document.
3297
+ */
3298
+ unstable_getRowHeight: (id: GridRowId) => number;
3299
+ }
3300
+
4522
3301
  /**
4523
3302
  * The selection API interface that is available in the grid [[apiRef]].
4524
3303
  */
@@ -4698,6 +3477,7 @@ interface GridLocaleText {
4698
3477
  filterOperatorOnOrBefore: string;
4699
3478
  filterOperatorIsEmpty: string;
4700
3479
  filterOperatorIsNotEmpty: string;
3480
+ filterOperatorIsAnyOf: string;
4701
3481
  filterValueAny: string;
4702
3482
  filterValueTrue: string;
4703
3483
  filterValueFalse: string;
@@ -4743,7 +3523,7 @@ interface GridLocaleTextApi {
4743
3523
  }
4744
3524
 
4745
3525
  /**
4746
- * The options to apply an export.
3526
+ * The options applicable to any export format.
4747
3527
  */
4748
3528
  interface GridExportOptions {
4749
3529
  /**
@@ -4757,6 +3537,12 @@ interface GridExportOptions {
4757
3537
  */
4758
3538
  allColumns?: boolean;
4759
3539
  }
3540
+ interface GridCsvGetRowsToExportParams {
3541
+ /**
3542
+ * The API of the grid.
3543
+ */
3544
+ apiRef: GridApiRef;
3545
+ }
4760
3546
  /**
4761
3547
  * The options to apply on the CSV export.
4762
3548
  */
@@ -4782,6 +3568,12 @@ interface GridCsvExportOptions extends GridExportOptions {
4782
3568
  * @default true
4783
3569
  */
4784
3570
  includeHeaders?: boolean;
3571
+ /**
3572
+ * Function that returns the id of the rows to export on the order they should be exported.
3573
+ * @param {GridCsvGetRowsToExportParams} params With all properties from [[GridCsvGetRowsToExportParams]].
3574
+ * @returns {GridRowId[]} The id of the rows to export.
3575
+ */
3576
+ getRowsToExport?: (params: GridCsvGetRowsToExportParams) => GridRowId[];
4785
3577
  }
4786
3578
  /**
4787
3579
  * The options to apply on the Print export.
@@ -4998,6 +3790,15 @@ interface GridScrollApi {
4998
3790
  scrollToIndexes: (params: Partial<GridCellIndexCoordinates>) => boolean;
4999
3791
  }
5000
3792
 
3793
+ interface GridVirtualScrollerApi {
3794
+ /**
3795
+ * Get the current grid rendering context.
3796
+ * @returns {GridRenderContext} The `GridRenderContext`.
3797
+ * @ignore - do not document.
3798
+ */
3799
+ unstable_getRenderContext: () => GridRenderContext;
3800
+ }
3801
+
5001
3802
  declare type GridSortDirection = 'asc' | 'desc' | null | undefined;
5002
3803
  interface GridSortCellParams {
5003
3804
  id: GridRowId;
@@ -5394,10 +4195,46 @@ interface GridLoggerApi {
5394
4195
  getLogger: (name: string) => Logger;
5395
4196
  }
5396
4197
 
4198
+ interface GridDimensions {
4199
+ /**
4200
+ * The viewport size including scrollbars.
4201
+ */
4202
+ viewportOuterSize: ElementSize;
4203
+ /**
4204
+ * The viewport size not including scrollbars.
4205
+ */
4206
+ viewportInnerSize: ElementSize;
4207
+ /**
4208
+ * Indicates if a scroll is currently needed to go from the beginning of the first column to the end of the last column.
4209
+ */
4210
+ hasScrollX: boolean;
4211
+ /**
4212
+ * Indicates if a scroll is currently needed to go from the beginning of the first row to the end of the last row.
4213
+ */
4214
+ hasScrollY: boolean;
4215
+ }
4216
+ interface GridDimensionsApi {
4217
+ /**
4218
+ * Triggers a resize of the component and recalculation of width and height.
4219
+ */
4220
+ resize: () => void;
4221
+ /**
4222
+ * Returns the dimensions of the grid
4223
+ * @returns {GridDimensions | null} The dimension information of the grid. If `null`, the grid is not ready yet.
4224
+ */
4225
+ getRootDimensions: () => GridDimensions | null;
4226
+ /**
4227
+ * Returns the amount of rows that are currently visible in the viewport
4228
+ * @returns {number} The amount of rows visible in the viewport
4229
+ * @ignore - do not document.
4230
+ */
4231
+ unstable_getViewportPageSize: () => number;
4232
+ }
4233
+
5397
4234
  /**
5398
4235
  * The full grid API.
5399
4236
  */
5400
- 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 {
4237
+ 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 {
5401
4238
  }
5402
4239
 
5403
4240
  /**
@@ -5545,7 +4382,7 @@ interface GridValueFormatterParams {
5545
4382
  */
5546
4383
  field: string;
5547
4384
  /**
5548
- * The cell value, but if the column has valueGetter, use getValue.
4385
+ * The cell value, if the column has valueGetter it is the value returned by it.
5549
4386
  */
5550
4387
  value: GridCellValue;
5551
4388
  /**
@@ -6199,6 +5036,110 @@ declare const GRID_EXPERIMENTAL_ENABLED: boolean;
6199
5036
 
6200
5037
  declare const GRID_DEFAULT_LOCALE_TEXT: GridLocaleText;
6201
5038
 
5039
+ declare const gridColumnMenuSelector: (state: GridState) => GridColumnMenuState;
5040
+
5041
+ declare const gridColumnResizeSelector: (state: GridState) => GridColumnResizeState;
5042
+ declare const gridResizingColumnFieldSelector: OutputSelector<string>;
5043
+
5044
+ declare const gridPinnedColumnsSelector: (state: GridState) => GridPinnedColumns;
5045
+
5046
+ declare const gridColumnsSelector: (state: GridState) => GridColumnsState;
5047
+ declare const allGridColumnsFieldsSelector: (state: GridState) => string[];
5048
+ declare const gridColumnLookupSelector: (state: GridState) => GridColumnLookup;
5049
+ declare const allGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5050
+ declare const gridColumnVisibilityModelSelector: OutputSelector<GridColumnVisibilityModel>;
5051
+ declare const visibleGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5052
+ declare const gridVisibleColumnFieldsSelector: OutputSelector<string[]>;
5053
+ declare const gridColumnsMetaSelector: OutputSelector<{
5054
+ totalWidth: number;
5055
+ positions: number[];
5056
+ }>;
5057
+ declare const filterableGridColumnsSelector: OutputSelector<GridStateColDef[]>;
5058
+ declare const filterableGridColumnsIdsSelector: OutputSelector<string[]>;
5059
+ declare const visibleGridColumnsLengthSelector: OutputSelector<number>;
5060
+ declare const gridColumnsTotalWidthSelector: OutputSelector<number>;
5061
+
5062
+ /**
5063
+ * @deprecated Should have been internal only, you can inline the logic.
5064
+ */
5065
+ declare const getGridColDef: (columnTypes: GridColumnTypesRecord, type: GridColType | undefined) => GridColTypeDef;
5066
+
5067
+ declare const gridDensitySelector: (state: GridState) => GridDensityState;
5068
+ declare const gridDensityValueSelector: OutputSelector<GridDensity>;
5069
+ declare const gridDensityRowHeightSelector: OutputSelector<number>;
5070
+ declare const gridDensityHeaderHeightSelector: OutputSelector<number>;
5071
+ declare const gridDensityFactorSelector: OutputSelector<number>;
5072
+
5073
+ declare const gridEditRowsStateSelector: (state: GridState) => GridEditRowsModel;
5074
+
5075
+ declare const gridFocusStateSelector: (state: GridState) => GridFocusState;
5076
+ declare const gridFocusCellSelector: OutputSelector<GridCellIdentifier | null>;
5077
+ declare const gridFocusColumnHeaderSelector: OutputSelector<GridColumnIdentifier | null>;
5078
+ declare const gridTabIndexStateSelector: (state: GridState) => GridTabIndexState;
5079
+ declare const gridTabIndexCellSelector: OutputSelector<GridCellIdentifier | null>;
5080
+ declare const gridTabIndexColumnHeaderSelector: OutputSelector<GridColumnIdentifier | null>;
5081
+
5082
+ declare const gridPreferencePanelStateSelector: (state: GridState) => GridPreferencePanelState;
5083
+
5084
+ declare const gridRowsMetaSelector: (state: GridState) => GridRowsMetaState;
5085
+
5086
+ declare const gridRowsStateSelector: (state: GridState) => GridRowsState;
5087
+ declare const gridRowCountSelector: OutputSelector<number>;
5088
+ declare const gridTopLevelRowCountSelector: OutputSelector<number>;
5089
+ declare const gridRowsLookupSelector: OutputSelector<GridRowsLookup>;
5090
+ declare const gridRowTreeSelector: OutputSelector<GridRowTreeConfig>;
5091
+ declare const gridRowGroupingNameSelector: OutputSelector<string>;
5092
+ declare const gridRowTreeDepthSelector: OutputSelector<number>;
5093
+ declare const gridRowIdsSelector: OutputSelector<GridRowId[]>;
5094
+
5095
+ declare const gridSelectionStateSelector: (state: GridState) => GridSelectionModel;
5096
+ declare const selectedGridRowsCountSelector: OutputSelector<number>;
5097
+ declare const selectedGridRowsSelector: OutputSelector<Map<GridRowId, {
5098
+ [key: string]: any;
5099
+ }>>;
5100
+ declare const selectedIdsLookupSelector: OutputSelector<{}>;
5101
+
5102
+ /**
5103
+ * @category Sorting
5104
+ * @ignore - do not document.
5105
+ */
5106
+ declare const gridSortingStateSelector: (state: GridState) => GridSortingState;
5107
+ /**
5108
+ * Get the id of the rows after the sorting process.
5109
+ * @category Sorting
5110
+ */
5111
+ declare const gridSortedRowIdsSelector: OutputSelector<GridRowId[]>;
5112
+ /**
5113
+ * Get the id and the model of the rows after the sorting process.
5114
+ * @category Sorting
5115
+ */
5116
+ declare const gridSortedRowEntriesSelector: OutputSelector<{
5117
+ id: GridRowId;
5118
+ model: {
5119
+ [key: string]: any;
5120
+ };
5121
+ }[]>;
5122
+ /**
5123
+ * Get the current sorting model.
5124
+ * @category Sorting
5125
+ */
5126
+ declare const gridSortModelSelector: OutputSelector<GridSortModel>;
5127
+ declare type GridSortColumnLookup = Record<string, {
5128
+ sortDirection: GridSortDirection;
5129
+ sortIndex?: number;
5130
+ }>;
5131
+ /**
5132
+ * @category Sorting
5133
+ * @ignore - do not document.
5134
+ */
5135
+ declare const gridSortColumnLookupSelector: OutputSelector<GridSortColumnLookup>;
5136
+
5137
+ declare const gridStringOrNumberComparator: GridComparatorFn;
5138
+ declare const gridNumberComparator: GridComparatorFn;
5139
+ declare const gridDateComparator: (value1: GridCellValue, value2: GridCellValue) => number;
5140
+
5141
+ declare const GRID_TREE_DATA_GROUPING_FIELD = "__tree_data_group__";
5142
+
6202
5143
  /**
6203
5144
  * @deprecated Use `apiRef.current` instead.
6204
5145
  */
@@ -6229,8 +5170,10 @@ declare function useGridApiOptionHandler<E extends GridEvents>(apiRef: GridApiRe
6229
5170
 
6230
5171
  declare function useGridApiMethod<T extends Partial<GridApi>>(apiRef: GridApiRef, apiMethods: T, apiName: string): void;
6231
5172
 
6232
- declare function useGridApiRef(): GridApiRef;
6233
- declare function useGridApiRef(apiRefProp: GridApiRef | undefined): GridApiRef;
5173
+ /**
5174
+ * Hook that instantiate a [[GridApiRef]].
5175
+ */
5176
+ declare const useGridApiRef: () => GridApiRef;
6234
5177
 
6235
5178
  declare function useGridLogger(apiRef: GridApiRef, name: string): Logger;
6236
5179
 
@@ -6238,7 +5181,7 @@ declare const useGridRootProps: <Props extends DataGridProcessedProps | DataGrid
6238
5181
 
6239
5182
  declare function useGridScrollFn(apiRef: GridApiRef, renderingZoneElementRef: React$1.RefObject<HTMLDivElement>, columnHeadersElementRef: React$1.RefObject<HTMLDivElement>): [GridScrollFn];
6240
5183
 
6241
- declare const useGridSelector: <T>(apiRef: GridApiRef, selector: (state: GridState) => T) => T;
5184
+ declare const useGridSelector: <T>(apiRef: GridApiRef, selector: OutputSelector<T> | ((state: GridState) => T)) => T;
6242
5185
 
6243
5186
  /**
6244
5187
  * @deprecated Use `apiRef.current.state`, `apiRef.current.setState` and `apiRef.current.forceUpdate` instead.
@@ -6305,4 +5248,4 @@ declare const zhCN: Localization;
6305
5248
 
6306
5249
  declare const DataGridPro: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<DataGridProProps & React$1.RefAttributes<HTMLDivElement>>>;
6307
5250
 
6308
- export { AutoSizerProps, AutoSizerSize, CursorCoordinates, DEFAULT_GRID_COL_TYPE_KEY, DataGridPro, DataGridProProps, 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, 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, useGridApi, useGridApiContext, useGridApiEventHandler, useGridApiMethod, useGridApiOptionHandler, useGridApiRef, useGridLogger, useGridNativeEventListener, useGridRootProps, useGridScrollFn, useGridSelector, useGridState, viVN, visibleGridColumnsLengthSelector, visibleGridColumnsSelector, zhCN };
5251
+ export { AutoSizerProps, AutoSizerSize, CursorCoordinates, DEFAULT_GRID_COL_TYPE_KEY, DataGridPro, DataGridProProps, 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, 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, useGridApi, useGridApiContext, useGridApiEventHandler, useGridApiMethod, useGridApiOptionHandler, useGridApiRef, useGridLogger, useGridNativeEventListener, useGridRootProps, useGridScrollFn, useGridSelector, useGridState, viVN, visibleGridColumnsLengthSelector, visibleGridColumnsSelector, zhCN };