diff --git a/src/DataGrid.tsx b/src/DataGrid.tsx
index f75c57e6c9..d91cc95627 100644
--- a/src/DataGrid.tsx
+++ b/src/DataGrid.tsx
@@ -103,78 +103,78 @@ export interface DataGridProps<R, SR = unknown, K extends React.Key = React.Key>
    * Rows to be pinned at the bottom of the rows view for summary, the vertical scroll bar will not scroll these rows.
    * Bottom horizontal scroll bar can move the row left / right. Or a customized row renderer can be used to disabled the scrolling support.
    */
-  summaryRows?: readonly SR[];
+  summaryRows?: readonly SR[] | null;
   /** The getter should return a unique key for each row */
-  rowKeyGetter?: (row: R) => K;
-  onRowsChange?: (rows: R[], data: RowsChangeData<R, SR>) => void;
+  rowKeyGetter?: ((row: R) => K) | null;
+  onRowsChange?: ((rows: R[], data: RowsChangeData<R, SR>) => void) | null;
 
   /**
    * Dimensions props
    */
   /** The height of each row in pixels */
-  rowHeight?: number | ((args: RowHeightArgs<R>) => number);
+  rowHeight?: number | ((args: RowHeightArgs<R>) => number) | null;
   /** The height of the header row in pixels */
-  headerRowHeight?: number;
+  headerRowHeight?: number | null;
   /** The height of the header filter row in pixels */
-  headerFiltersHeight?: number;
+  headerFiltersHeight?: number | null;
   /** The height of each summary row in pixels */
-  summaryRowHeight?: number;
+  summaryRowHeight?: number | null;
 
   /**
    * Feature props
    */
   /** Set of selected row keys */
-  selectedRows?: ReadonlySet<K>;
+  selectedRows?: ReadonlySet<K> | null;
   /** Function called whenever row selection is changed */
-  onSelectedRowsChange?: (selectedRows: Set<K>) => void;
+  onSelectedRowsChange?: ((selectedRows: Set<K>) => void) | null;
   /** The key of the column which is currently being sorted */
-  sortColumn?: string;
+  sortColumn?: string | null;
   /** The direction to sort the sortColumn*/
-  sortDirection?: SortDirection;
+  sortDirection?: SortDirection | null;
   /** Function called whenever grid is sorted*/
-  onSort?: (columnKey: string, direction: SortDirection) => void;
-  filters?: Readonly<Filters>;
-  onFiltersChange?: (filters: Filters) => void;
-  defaultColumnOptions?: DefaultColumnOptions<R, SR>;
-  groupBy?: readonly string[];
-  rowGrouper?: (rows: readonly R[], columnKey: string) => Record<string, readonly R[]>;
-  expandedGroupIds?: ReadonlySet<unknown>;
-  onExpandedGroupIdsChange?: (expandedGroupIds: Set<unknown>) => void;
-  onFill?: (event: FillEvent<R>) => R[];
-  onPaste?: (event: PasteEvent<R>) => R;
+  onSort?: ((columnKey: string, direction: SortDirection) => void) | null;
+  filters?: Readonly<Filters> | null;
+  onFiltersChange?: ((filters: Filters) => void) | null;
+  defaultColumnOptions?: DefaultColumnOptions<R, SR> | null;
+  groupBy?: readonly string[] | null;
+  rowGrouper?: ((rows: readonly R[], columnKey: string) => Record<string, readonly R[]>) | null;
+  expandedGroupIds?: ReadonlySet<unknown> | null;
+  onExpandedGroupIdsChange?: ((expandedGroupIds: Set<unknown>) => void) | null;
+  onFill?: ((event: FillEvent<R>) => R[]) | null;
+  onPaste?: ((event: PasteEvent<R>) => R) | null;
 
   /**
    * Custom renderers
    */
-  rowRenderer?: React.ComponentType<RowRendererProps<R, SR>>;
-  emptyRowsRenderer?: React.ComponentType;
+  rowRenderer?: React.ComponentType<RowRendererProps<R, SR>> | null;
+  emptyRowsRenderer?: React.ComponentType | null;
 
   /**
    * Event props
    */
   /** Function called whenever a row is clicked */
-  onRowClick?: (rowIdx: number, row: R, column: CalculatedColumn<R, SR>) => void;
+  onRowClick?: ((rowIdx: number, row: R, column: CalculatedColumn<R, SR>) => void) | null;
   /** Called when the grid is scrolled */
-  onScroll?: (event: React.UIEvent<HTMLDivElement>) => void;
+  onScroll?: ((event: React.UIEvent<HTMLDivElement>) => void) | null;
   /** Called when a column is resized */
-  onColumnResize?: (idx: number, width: number) => void;
+  onColumnResize?: ((idx: number, width: number) => void) | null;
   /** Function called whenever selected cell is changed */
-  onSelectedCellChange?: (position: Position) => void;
+  onSelectedCellChange?: ((position: Position) => void) | null;
 
   /**
    * Toggles and modes
    */
   /** Toggles whether filters row is displayed or not */
-  enableFilterRow?: boolean;
-  cellNavigationMode?: CellNavigationMode;
-  enableVirtualization?: boolean;
+  enableFilterRow?: boolean | null;
+  cellNavigationMode?: CellNavigationMode | null;
+  enableVirtualization?: boolean | null;
 
   /**
    * Miscellaneous
    */
   /** The node where the editor portal should mount. */
-  editorPortalTarget?: Element;
-  rowClass?: (row: R) => string | undefined;
+  editorPortalTarget?: Element | null;
+  rowClass?: ((row: R) => string | undefined | null) | null;
 }
 
 /**
@@ -184,7 +184,7 @@ export interface DataGridProps<R, SR = unknown, K extends React.Key = React.Key>
  *
  * <DataGrid columns={columns} rows={rows} />
  */
-function DataGrid<R, SR>(
+function DataGrid<R, SR, K extends React.Key>(
   {
     // Grid and data Props
     columns: rawColumns,
@@ -193,10 +193,10 @@ function DataGrid<R, SR>(
     rowKeyGetter,
     onRowsChange,
     // Dimensions props
-    rowHeight = 35,
-    headerRowHeight = typeof rowHeight === 'number' ? rowHeight : 35,
-    headerFiltersHeight = 45,
-    summaryRowHeight = typeof rowHeight === 'number' ? rowHeight : 35,
+    rowHeight,
+    headerRowHeight,
+    headerFiltersHeight,
+    summaryRowHeight: rawSummaryRowHeight,
     // Feature props
     selectedRows,
     onSelectedRowsChange,
@@ -211,7 +211,7 @@ function DataGrid<R, SR>(
     expandedGroupIds,
     onExpandedGroupIdsChange,
     // Custom renderers
-    rowRenderer: RowRenderer = Row,
+    rowRenderer,
     emptyRowsRenderer: EmptyRowsRenderer,
     // Event props
     onRowClick,
@@ -221,11 +221,11 @@ function DataGrid<R, SR>(
     onFill,
     onPaste,
     // Toggles and modes
-    enableFilterRow = false,
-    cellNavigationMode = 'NONE',
-    enableVirtualization = true,
+    enableFilterRow,
+    cellNavigationMode: rawCellNavigationMode,
+    enableVirtualization,
     // Miscellaneous
-    editorPortalTarget = body,
+    editorPortalTarget: rawEditorPortalTarget,
     className,
     style,
     rowClass,
@@ -233,9 +233,22 @@ function DataGrid<R, SR>(
     'aria-label': ariaLabel,
     'aria-labelledby': ariaLabelledBy,
     'aria-describedby': ariaDescribedBy
-  }: DataGridProps<R, SR>,
+  }: DataGridProps<R, SR, K>,
   ref: React.Ref<DataGridHandle>
 ) {
+  /**
+   * defaults
+   */
+  rowHeight ??= 35;
+  headerRowHeight ??= typeof rowHeight === 'number' ? rowHeight : 35;
+  headerFiltersHeight ??= 45;
+  const summaryRowHeight = rawSummaryRowHeight ?? (typeof rowHeight === 'number' ? rowHeight : 35);
+  const RowRenderer = rowRenderer ?? Row;
+  enableFilterRow ??= false;
+  const cellNavigationMode = rawCellNavigationMode ?? 'NONE';
+  enableVirtualization ??= true;
+  const editorPortalTarget = rawEditorPortalTarget ?? body;
+
   /**
    * states
    */
@@ -273,7 +286,7 @@ function DataGrid<R, SR>(
   const summaryRowsCount = summaryRows?.length ?? 0;
   const totalHeaderHeight = headerRowHeight + (enableFilterRow ? headerFiltersHeight : 0);
   const clientHeight = gridHeight - totalHeaderHeight - summaryRowsCount * summaryRowHeight;
-  const isSelectable = selectedRows !== undefined && onSelectedRowsChange !== undefined;
+  const isSelectable = selectedRows != null && onSelectedRowsChange != null;
 
   const {
     columns,
@@ -335,7 +348,7 @@ function DataGrid<R, SR>(
   const minColIdx = hasGroups ? -1 : 0;
 
   // Cell drag is not supported on a treegrid
-  const enableCellDragAndDrop = hasGroups ? false : onFill !== undefined;
+  const enableCellDragAndDrop = hasGroups ? false : onFill != null;
 
   /**
    * effects
@@ -401,7 +414,7 @@ function DataGrid<R, SR>(
   function selectRow({ rowIdx, checked, isShiftClick }: SelectRowEvent) {
     if (!onSelectedRowsChange) return;
 
-    assertIsValidKeyGetter(rowKeyGetter);
+    assertIsValidKeyGetter<R, K>(rowKeyGetter);
     const newSelectedRows = new Set(selectedRows);
     const row = rows[rowIdx];
     if (isGroupRow(row)) {
@@ -973,11 +986,13 @@ function DataGrid<R, SR>(
       }
 
       startRowIndex++;
-      let key: React.Key = hasGroups ? startRowIndex : rowIdx;
+      let key;
       let isRowSelected = false;
       if (typeof rowKeyGetter === 'function') {
         key = rowKeyGetter(row);
         isRowSelected = selectedRows?.has(key) ?? false;
+      } else {
+        key = hasGroups ? startRowIndex : rowIdx;
       }
 
       rowElements.push(
@@ -1048,7 +1063,7 @@ function DataGrid<R, SR>(
       ref={gridRef}
       onScroll={handleScroll}
     >
-      <HeaderRow<R, SR>
+      <HeaderRow<R, SR, K>
         rowKeyGetter={rowKeyGetter}
         rows={rawRows}
         columns={viewportColumns}
@@ -1117,6 +1132,6 @@ function DataGrid<R, SR>(
   );
 }
 
-export default forwardRef(DataGrid) as <R, SR = unknown, Key extends React.Key = React.Key>(
-  props: DataGridProps<R, SR, Key> & RefAttributes<DataGridHandle>
+export default forwardRef(DataGrid) as <R, SR = unknown, K extends React.Key = React.Key>(
+  props: DataGridProps<R, SR, K> & RefAttributes<DataGridHandle>
 ) => JSX.Element;
diff --git a/src/HeaderCell.tsx b/src/HeaderCell.tsx
index 61f7d38472..c18036b9aa 100644
--- a/src/HeaderCell.tsx
+++ b/src/HeaderCell.tsx
@@ -19,7 +19,7 @@ const cellResizable = css`
 
 const cellResizableClassname = `rdg-cell-resizable ${cellResizable}`;
 
-function getAriaSort(sortDirection: SortDirection | undefined) {
+function getAriaSort(sortDirection: SortDirection | undefined | null) {
   switch (sortDirection) {
     case 'ASC':
       return 'ascending';
@@ -31,7 +31,7 @@ function getAriaSort(sortDirection: SortDirection | undefined) {
 }
 
 type SharedHeaderRowProps<R, SR> = Pick<
-  HeaderRowProps<R, SR>,
+  HeaderRowProps<R, SR, React.Key>,
   'sortColumn' | 'sortDirection' | 'onSort' | 'allRowsSelected'
 >;
 
diff --git a/src/HeaderRow.tsx b/src/HeaderRow.tsx
index 90cde6bd1d..bd8b88d2ba 100644
--- a/src/HeaderRow.tsx
+++ b/src/HeaderRow.tsx
@@ -6,19 +6,19 @@ import { assertIsValidKeyGetter, getColSpan } from './utils';
 import type { DataGridProps } from './DataGrid';
 import { headerRowClassname } from './style';
 
-type SharedDataGridProps<R, SR> = Pick<
-  DataGridProps<R, SR>,
+type SharedDataGridProps<R, SR, K extends React.Key> = Pick<
+  DataGridProps<R, SR, K>,
   'rows' | 'onSelectedRowsChange' | 'sortColumn' | 'sortDirection' | 'onSort' | 'rowKeyGetter'
 >;
 
-export interface HeaderRowProps<R, SR> extends SharedDataGridProps<R, SR> {
+export interface HeaderRowProps<R, SR, K extends React.Key> extends SharedDataGridProps<R, SR, K> {
   columns: readonly CalculatedColumn<R, SR>[];
   allRowsSelected: boolean;
   onColumnResize: (column: CalculatedColumn<R, SR>, width: number) => void;
   lastFrozenColumnIndex: number;
 }
 
-function HeaderRow<R, SR>({
+function HeaderRow<R, SR, K extends React.Key>({
   columns,
   rows,
   rowKeyGetter,
@@ -29,14 +29,14 @@ function HeaderRow<R, SR>({
   sortDirection,
   onSort,
   lastFrozenColumnIndex
-}: HeaderRowProps<R, SR>) {
+}: HeaderRowProps<R, SR, K>) {
   const handleAllRowsSelectionChange = useCallback(
     (checked: boolean) => {
       if (!onSelectedRowsChange) return;
 
-      assertIsValidKeyGetter(rowKeyGetter);
+      assertIsValidKeyGetter<R, K>(rowKeyGetter);
 
-      const newSelectedRows = new Set<React.Key>(checked ? rows.map(rowKeyGetter) : undefined);
+      const newSelectedRows = new Set<K>(checked ? rows.map(rowKeyGetter) : undefined);
       onSelectedRowsChange(newSelectedRows);
     },
     [onSelectedRowsChange, rows, rowKeyGetter]
@@ -76,4 +76,6 @@ function HeaderRow<R, SR>({
   );
 }
 
-export default memo(HeaderRow) as <R, SR>(props: HeaderRowProps<R, SR>) => JSX.Element;
+export default memo(HeaderRow) as <R, SR, K extends React.Key>(
+  props: HeaderRowProps<R, SR, K>
+) => JSX.Element;
diff --git a/src/hooks/useCalculatedColumns.ts b/src/hooks/useCalculatedColumns.ts
index ab4a9cbef3..7d8a911542 100644
--- a/src/hooks/useCalculatedColumns.ts
+++ b/src/hooks/useCalculatedColumns.ts
@@ -8,7 +8,7 @@ import { floor, max, min } from '../utils';
 
 interface CalculatedColumnsArgs<R, SR> extends Pick<DataGridProps<R, SR>, 'defaultColumnOptions'> {
   rawColumns: readonly Column<R, SR>[];
-  rawGroupBy: readonly string[] | undefined;
+  rawGroupBy: readonly string[] | undefined | null;
   viewportWidth: number;
   scrollLeft: number;
   columnWidths: ReadonlyMap<string, number>;
diff --git a/src/hooks/useViewportColumns.ts b/src/hooks/useViewportColumns.ts
index d1aa47871a..51da6316a9 100644
--- a/src/hooks/useViewportColumns.ts
+++ b/src/hooks/useViewportColumns.ts
@@ -7,7 +7,7 @@ interface ViewportColumnsArgs<R, SR> {
   columns: readonly CalculatedColumn<R, SR>[];
   colSpanColumns: readonly CalculatedColumn<R, SR>[];
   rows: readonly (R | GroupRow<R>)[];
-  summaryRows: readonly SR[] | undefined;
+  summaryRows: readonly SR[] | undefined | null;
   colOverscanStartIdx: number;
   colOverscanEndIdx: number;
   lastFrozenColumnIndex: number;
@@ -72,7 +72,7 @@ export function useViewportColumns<R, SR>({
       }
 
       // check summary rows
-      if (summaryRows !== undefined) {
+      if (summaryRows != null) {
         for (const row of summaryRows) {
           if (
             updateStartIdx(
diff --git a/src/hooks/useViewportRows.ts b/src/hooks/useViewportRows.ts
index f9bccd9070..76a9ca8fab 100644
--- a/src/hooks/useViewportRows.ts
+++ b/src/hooks/useViewportRows.ts
@@ -10,8 +10,11 @@ interface ViewportRowsArgs<R> {
   clientHeight: number;
   scrollTop: number;
   groupBy: readonly string[];
-  rowGrouper: ((rows: readonly R[], columnKey: string) => Record<string, readonly R[]>) | undefined;
-  expandedGroupIds: ReadonlySet<unknown> | undefined;
+  rowGrouper:
+    | ((rows: readonly R[], columnKey: string) => Record<string, readonly R[]>)
+    | undefined
+    | null;
+  expandedGroupIds: ReadonlySet<unknown> | undefined | null;
   enableVirtualization: boolean;
 }
 
@@ -31,7 +34,7 @@ export function useViewportRows<R>({
   enableVirtualization
 }: ViewportRowsArgs<R>) {
   const [groupedRows, rowsCount] = useMemo(() => {
-    if (groupBy.length === 0 || !rowGrouper) return [undefined, rawRows.length];
+    if (groupBy.length === 0 || rowGrouper == null) return [undefined, rawRows.length];
 
     const groupRows = (
       rows: readonly R[],
diff --git a/src/types.ts b/src/types.ts
index 05c31f10cf..37e9875a43 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -116,9 +116,9 @@ export interface EditorProps<TRow, TSummaryRow = unknown> extends SharedEditorPr
 
 export interface HeaderRendererProps<TRow, TSummaryRow = unknown> {
   column: CalculatedColumn<TRow, TSummaryRow>;
-  sortColumn: string | undefined;
-  sortDirection: SortDirection | undefined;
-  onSort: ((columnKey: string, direction: SortDirection) => void) | undefined;
+  sortColumn: string | undefined | null;
+  sortDirection: SortDirection | undefined | null;
+  onSort: ((columnKey: string, direction: SortDirection) => void) | undefined | null;
   allRowsSelected: boolean;
   onAllRowsSelectionChange: (checked: boolean) => void;
 }
@@ -156,7 +156,8 @@ export interface CellRendererProps<TRow, TSummaryRow = unknown>
   onRowChange: (rowIdx: number, newRow: TRow) => void;
   onRowClick:
     | ((rowIdx: number, row: TRow, column: CalculatedColumn<TRow, TSummaryRow>) => void)
-    | undefined;
+    | undefined
+    | null;
   selectCell: (position: Position, enableEditor?: boolean) => void;
 }
 
@@ -176,8 +177,9 @@ export interface RowRendererProps<TRow, TSummaryRow = unknown>
   onRowChange: (rowIdx: number, row: TRow) => void;
   onRowClick:
     | ((rowIdx: number, row: TRow, column: CalculatedColumn<TRow, TSummaryRow>) => void)
-    | undefined;
-  rowClass: ((row: TRow) => string | undefined) | undefined;
+    | undefined
+    | null;
+  rowClass: ((row: TRow) => string | undefined | null) | undefined | null;
   setDraggedOverRowIdx: ((overRowIdx: number) => void) | undefined;
   selectCell: (position: Position, enableEditor?: boolean) => void;
 }
diff --git a/src/utils/index.ts b/src/utils/index.ts
index 761d53d38e..ac1cf16af9 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -10,9 +10,9 @@ export * from './selectedCellUtils';
 
 export const { min, max, floor, ceil, sign } = Math;
 
-export function assertIsValidKeyGetter<R>(
+export function assertIsValidKeyGetter<R, K extends React.Key>(
   keyGetter: unknown
-): asserts keyGetter is (row: R) => React.Key {
+): asserts keyGetter is (row: R) => K {
   if (typeof keyGetter !== 'function') {
     throw new Error('Please specify the rowKeyGetter prop to use selection');
   }
diff --git a/stories/demos/AllFeatures.tsx b/stories/demos/AllFeatures.tsx
index 62e7ffda74..3494cdbc16 100644
--- a/stories/demos/AllFeatures.tsx
+++ b/stories/demos/AllFeatures.tsx
@@ -203,7 +203,7 @@ function loadMoreRows(newRowsCount: number, length: number): Promise<Row[]> {
 
 export function AllFeatures() {
   const [rows, setRows] = useState(() => createRows(2000));
-  const [selectedRows, setSelectedRows] = useState(() => new Set<React.Key>());
+  const [selectedRows, setSelectedRows] = useState<ReadonlySet<string>>(() => new Set());
   const [isLoading, setIsLoading] = useState(false);
 
   function handleFill({ columnKey, sourceRow, targetRows }: FillEvent<Row>): Row[] {
diff --git a/stories/demos/CommonFeatures.tsx b/stories/demos/CommonFeatures.tsx
index 6fce3fde93..042bb14994 100644
--- a/stories/demos/CommonFeatures.tsx
+++ b/stories/demos/CommonFeatures.tsx
@@ -221,7 +221,7 @@ function createRows(): readonly Row[] {
 export function CommonFeatures() {
   const [rows, setRows] = useState(createRows);
   const [[sortColumn, sortDirection], setSort] = useState<[string, SortDirection]>(['id', 'NONE']);
-  const [selectedRows, setSelectedRows] = useState(() => new Set<React.Key>());
+  const [selectedRows, setSelectedRows] = useState<ReadonlySet<number>>(() => new Set());
 
   const countries = useMemo(() => {
     return [...new Set(rows.map((r) => r.country))].sort(new Intl.Collator().compare);
diff --git a/stories/demos/Grouping.tsx b/stories/demos/Grouping.tsx
index 0ddfe81368..c3abee9d8f 100644
--- a/stories/demos/Grouping.tsx
+++ b/stories/demos/Grouping.tsx
@@ -162,7 +162,7 @@ const options: OptionsType<Option> = [
 
 export function Grouping() {
   const [rows] = useState(createRows);
-  const [selectedRows, setSelectedRows] = useState(() => new Set<React.Key>());
+  const [selectedRows, setSelectedRows] = useState<ReadonlySet<number>>(() => new Set());
   const [selectedOptions, setSelectedOptions] = useState<ValueType<Option, true>>([
     options[0],
     options[1]
diff --git a/test/utils.tsx b/test/utils.tsx
index 2435c8a9b8..52ab3db216 100644
--- a/test/utils.tsx
+++ b/test/utils.tsx
@@ -3,7 +3,7 @@ import { render, screen, within } from '@testing-library/react';
 import DataGrid from '../src/';
 import type { DataGridProps } from '../src/';
 
-export function setup<R, SR>(props: DataGridProps<R, SR>) {
+export function setup<R, SR, K extends React.Key>(props: DataGridProps<R, SR, K>) {
   return render(
     <StrictMode>
       <DataGrid {...props} />