@carbon/react 1.82.1 → 1.83.0

package/es/tools/wrapComponent.js

@@ -7,7 +7,7 @@
 
 import cx from 'classnames';
 import PropTypes from 'prop-types';
-import React__default from 'react';
+import React from 'react';
 import { usePrefix } from '../internal/usePrefix.js';
 
 /**
@@ -32,7 +32,7 @@ const wrapComponent = _ref => {
     } = _ref2;
     const prefix = usePrefix();
     const componentClass = cx(typeof getClassName === 'function' ? getClassName(prefix) : getClassName, baseClassName);
-    return /*#__PURE__*/React__default.createElement(type, {
+    return /*#__PURE__*/React.createElement(type, {
       ...other,
       // Prevent Weird quirk where `cx` will evaluate to an empty string, '',
       // and so we have empty `class` attributes in the resulting markup

package/es/types/common.d.ts

@@ -4,8 +4,6 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import * as React from 'react';
-export type ReactAttr<T = HTMLElement> = React.HTMLAttributes<T>;
 /**
  * For "as" props.  Creates an "as" property that supports native html tags such as 'span', 'a', 'button' as well as custom functional components
  * All native props for the supplied html tag/component are inferred as part of the base component props, allowing us to use props like `href` on an 'a' element etc

package/lib/components/AccordionItem/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright IBM Corp. 2016, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { AccordionItem } from '../Accordion';
+export default AccordionItem;
+export { AccordionItem };

package/lib/components/CodeSnippet/CodeSnippet.js

@@ -13,7 +13,7 @@ var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelper
 var PropTypes = require('prop-types');
 var React = require('react');
 var cx = require('classnames');
-var useResizeObserver = require('use-resize-observer');
+var useResizeObserver = require('../../internal/useResizeObserver.js');
 var iconsReact = require('@carbon/icons-react');
 var Copy = require('../Copy/Copy.js');
 var Button = require('../Button/Button.js');
@@ -31,7 +31,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var cx__default = /*#__PURE__*/_interopDefaultLegacy(cx);
-var useResizeObserver__default = /*#__PURE__*/_interopDefaultLegacy(useResizeObserver);
 var copy__default = /*#__PURE__*/_interopDefaultLegacy(copy);
 
 const rowHeightInPixels = 16;
@@ -112,7 +111,7 @@ function CodeSnippet(_ref) {
     setHasLeftOverflow(horizontalOverflow && !!codeScrollLeft);
     setHasRightOverflow(horizontalOverflow && codeScrollLeft + codeClientWidth !== codeScrollWidth);
   }, [type, getCodeRefDimensions]);
-  useResizeObserver__default["default"]({
+  useResizeObserver.useResizeObserver({
     // Cast the ref until the hook supports React 19
     // https://github.com/ZeeCoder/use-resize-observer/issues/108
     ref: getCodeRef(),

package/lib/components/ContentSwitcher/ContentSwitcher.d.ts

@@ -28,6 +28,10 @@ export interface ContentSwitcherProps extends Omit<HTMLAttributes<HTMLElement>,
      *     been deprecated in favor of the new `Layer` component. It will be removed in the next major release.
      */
     light?: boolean;
+    /**
+     * `true` to use the low contrast version.
+     */
+    lowContrast?: boolean;
     /**
      * Specify an `onChange` handler that is called whenever the ContentSwitcher
      * changes which item is selected
@@ -72,6 +76,10 @@ export default class ContentSwitcher extends React.Component<ContentSwitcherProp
          * `true` to use the light variant.
          */
         light: (props: any, propName: any, componentName: any, ...rest: any[]) => any;
+        /**
+         * `true` to use the low contrast version.
+         */
+        lowContrast: PropTypes.Requireable<boolean>;
         /**
          * Specify an `onChange` handler that is called whenever the ContentSwitcher
          * changes which item is selected

package/lib/components/ContentSwitcher/ContentSwitcher.js

@@ -111,6 +111,7 @@ class ContentSwitcher extends React__default["default"].Component {
       children,
       className,
       light,
+      lowContrast,
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       selectedIndex = 0,
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -128,7 +129,8 @@ class ContentSwitcher extends React__default["default"].Component {
       [`${prefix}--content-switcher--${size}`]: size,
       // TODO: V12 - Remove this class
       [`${prefix}--layout--size-${size}`]: size,
-      [`${prefix}--content-switcher--icon-only`]: isIconOnly
+      [`${prefix}--content-switcher--icon-only`]: isIconOnly,
+      [`${prefix}--content-switcher--low-contrast`]: lowContrast
     });
     return /*#__PURE__*/React__default["default"].createElement(index.LayoutConstraint, _rollupPluginBabelHelpers["extends"]({
       size: {
@@ -163,6 +165,10 @@ _rollupPluginBabelHelpers.defineProperty(ContentSwitcher, "propTypes", {
    * `true` to use the light variant.
    */
   light: deprecate["default"](PropTypes__default["default"].bool, 'The `light` prop for `ContentSwitcher` is no longer needed and has ' + 'been deprecated. It will be removed in the next major release.'),
+  /**
+   * `true` to use the low contrast version.
+   */
+  lowContrast: PropTypes__default["default"].bool,
   /**
    * Specify an `onChange` handler that is called whenever the ContentSwitcher
    * changes which item is selected

package/lib/components/DataTable/DataTable.d.ts

@@ -4,8 +4,7 @@
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import PropTypes from 'prop-types';
-import React, { type MouseEvent } from 'react';
+import React, { Component, type ChangeEvent, type MouseEvent, type ReactElement, type ReactNode } from 'react';
 import type { DataTableSortState } from './state/sortStates';
 import Table from './Table';
 import TableActionList from './TableActionList';
@@ -51,10 +50,12 @@ export interface DataTableCell<T> {
     isEditable: boolean;
     isEditing: boolean;
     isValid: boolean;
-    errors: null | Array<Error>;
+    errors: null | Error[];
     info: {
         header: string;
     };
+    hasAILabelHeader?: boolean;
+    hasDecoratorHeader?: boolean;
 }
 type DataTableCells<T extends any[]> = {
     [K in keyof T]: DataTableCell<T[K]>;
@@ -68,18 +69,18 @@ export interface DataTableRow<ColTypes extends any[]> {
 }
 export interface DataTableHeader {
     key: string;
-    header: React.ReactNode;
-    slug?: React.ReactElement<any>;
-    decorator?: React.ReactElement<any>;
+    header: ReactNode;
+    slug?: ReactElement;
+    decorator?: ReactElement;
 }
 export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
-    headers: Array<DataTableHeader>;
-    rows: Array<DataTableRow<ColTypes> & RowType>;
-    selectedRows: Array<DataTableRow<ColTypes> & RowType>;
-    getHeaderProps: (getHeaderPropsArgs: {
+    headers: DataTableHeader[];
+    rows: (DataTableRow<ColTypes> & RowType)[];
+    selectedRows: (DataTableRow<ColTypes> & RowType)[];
+    getHeaderProps: (options: {
         header: DataTableHeader;
         isSortable?: boolean;
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>, sortState: {
+        onClick?: (event: MouseEvent<HTMLButtonElement>, sortState: {
             sortHeaderKey: string;
             sortDirection: DataTableSortState;
         }) => void;
@@ -88,24 +89,24 @@ export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
         isSortable: boolean | undefined;
         isSortHeader: boolean;
         key: string;
-        onClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
+        onClick: (event: MouseEvent<HTMLButtonElement>) => void;
         sortDirection: DataTableSortState;
         [key: string]: unknown;
     };
-    getExpandHeaderProps: (getExpandHeaderPropsArgs?: {
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>, expandState: {
+    getExpandHeaderProps: (options?: {
+        onClick?: (event: MouseEvent<HTMLButtonElement>, expandState: {
             isExpanded?: boolean;
         }) => void;
-        onExpand?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+        onExpand?: (event: MouseEvent<HTMLButtonElement>) => void;
         [key: string]: unknown;
     }) => {
         ['aria-label']: string;
         isExpanded: boolean;
-        onExpand: (e: React.MouseEvent<HTMLButtonElement>) => void;
+        onExpand: (event: MouseEvent<HTMLButtonElement>) => void;
         [key: string]: unknown;
     };
-    getRowProps: (getRowPropsArgs: {
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    getRowProps: (options: {
+        onClick?: (event: MouseEvent<HTMLButtonElement>) => void;
         row: DataTableRow<ColTypes>;
         [key: string]: unknown;
     }) => {
@@ -114,19 +115,19 @@ export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
         isExpanded?: boolean;
         isSelected?: boolean;
         key: string;
-        onExpand: (e: React.MouseEvent<HTMLButtonElement>) => void;
+        onExpand: (event: MouseEvent<HTMLButtonElement>) => void;
         [key: string]: unknown;
     };
-    getExpandedRowProps: (getExpandedRowPropsArgs: {
+    getExpandedRowProps: (options: {
         row: DataTableRow<ColTypes>;
         [key: string]: unknown;
     }) => {
         ['id']: string;
         [key: string]: unknown;
     };
-    getSelectionProps: (getSelectionPropsArgs?: {
-        onClick?: (e: MouseEvent<HTMLInputElement, globalThis.MouseEvent>) => void;
-        row: DataTableRow<ColTypes>;
+    getSelectionProps: (options?: {
+        onClick?: (event: MouseEvent<HTMLInputElement, globalThis.MouseEvent>) => void;
+        row?: DataTableRow<ColTypes>;
         [key: string]: unknown;
     }) => {
         'aria-label': string;
@@ -135,17 +136,17 @@ export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
         id: string;
         indeterminate?: boolean;
         name: string;
-        onSelect: (e: React.MouseEvent<HTMLInputElement>) => void;
+        onSelect: (event: MouseEvent<HTMLInputElement>) => void;
         radio?: boolean | undefined;
         [key: string]: unknown;
     };
-    getToolbarProps: (getToolbarPropsArgs?: {
+    getToolbarProps: (options?: {
         [key: string]: unknown;
     }) => {
         size: 'sm' | undefined;
         [key: string]: unknown;
     };
-    getBatchActionProps: (getBatchActionPropsArgs?: {
+    getBatchActionProps: (options?: {
         [key: string]: unknown;
     }) => {
         onCancel: () => void;
@@ -168,14 +169,14 @@ export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
         stickyHeader?: boolean;
         useStaticWidth?: boolean;
     };
-    getCellProps: (getCellPropsArgs: {
+    getCellProps: (options: {
         cell: DataTableCell<ColTypes>;
     }) => {
         [key: string]: unknown;
         hasAILabelHeader?: boolean;
         hasDecoratorHeader?: boolean;
     };
-    onInputChange: (e: React.ChangeEvent<HTMLInputElement>, defaultValue?: string) => void;
+    onInputChange: (event: ChangeEvent<HTMLInputElement>, defaultValue?: string) => void;
     sortBy: (headerKey: string) => void;
     selectAll: () => void;
     selectRow: (rowId: string) => void;
@@ -184,24 +185,24 @@ export interface DataTableRenderProps<RowType, ColTypes extends any[]> {
     radio: boolean | undefined;
 }
 export interface DataTableProps<RowType, ColTypes extends any[]> extends TranslateWithId<TranslationKey> {
-    children?: (renderProps: DataTableRenderProps<RowType, ColTypes>) => React.ReactElement<any>;
+    children?: (renderProps: DataTableRenderProps<RowType, ColTypes>) => ReactElement;
     experimentalAutoAlign?: boolean;
-    filterRows?: (filterRowsArgs: {
+    filterRows?: (options: {
         cellsById: Record<string, DataTableCell<ColTypes>>;
         getCellId: (rowId: string, header: string) => string;
-        headers: Array<DataTableHeader>;
+        headers: DataTableHeader[];
         inputValue: string;
-        rowIds: Array<string>;
-    }) => Array<string>;
-    headers: Array<DataTableHeader>;
+        rowIds: string[];
+    }) => string[];
+    headers: DataTableHeader[];
     isSortable?: boolean;
     locale?: string;
     overflowMenuOnHover?: boolean;
     radio?: boolean;
-    render?: (renderProps: DataTableRenderProps<RowType, ColTypes>) => React.ReactElement<any>;
-    rows: Array<Omit<DataTableRow<ColTypes>, 'cells'>>;
+    render?: (renderProps: DataTableRenderProps<RowType, ColTypes>) => ReactElement;
+    rows: Omit<DataTableRow<ColTypes>, 'cells'>[];
     size?: DataTableSize;
-    sortRow?: (cellA: any, cellB: any, sortRowOptions: {
+    sortRow?: (cellA: any, cellB: any, options: {
         sortDirection: DataTableSortState;
         sortStates: Record<DataTableSortState, DataTableSortState>;
         locale: string;
@@ -215,9 +216,9 @@ export interface DataTableProps<RowType, ColTypes extends any[]> extends Transla
 interface DataTableState<ColTypes extends any[]> {
     cellsById: Record<string, DataTableCell<ColTypes>>;
     filterInputValue: string | null;
-    initialRowOrder: Array<string>;
+    initialRowOrder: string[];
     isExpandedAll: boolean;
-    rowIds: Array<string>;
+    rowIds: string[];
     rowsById: Record<string, DataTableRow<ColTypes>>;
     shouldShowBatchActions: boolean;
     sortDirection: DataTableSortState;
@@ -233,84 +234,8 @@ interface DataTableState<ColTypes extends any[]> {
  * and updating the state of the single entity will cascade updates to the
  * consumer.
  */
-declare class DataTable<RowType, ColTypes extends any[]> extends React.Component<DataTableProps<RowType, ColTypes>, DataTableState<ColTypes>> {
+declare class DataTable<RowType, ColTypes extends any[]> extends Component<DataTableProps<RowType, ColTypes>, DataTableState<ColTypes>> {
     instanceId: number;
-    static propTypes: {
-        /**
-         * Experimental property. Allows table to align cell contents to the top if there is text wrapping in the content. Might have performance issues, intended for smaller tables
-         */
-        experimentalAutoAlign: PropTypes.Requireable<boolean>;
-        /**
-         * Optional hook to manually control filtering of the rows from the
-         * TableToolbarSearch component
-         */
-        filterRows: PropTypes.Requireable<(...args: any[]) => any>;
-        /**
-         * The `headers` prop represents the order in which the headers should
-         * appear in the table. We expect an array of objects to be passed in, where
-         * `key` is the name of the key in a row object, and `header` is the name of
-         * the header.
-         */
-        headers: PropTypes.Validator<(PropTypes.InferProps<{
-            key: PropTypes.Validator<string>;
-            header: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
-        }> | null | undefined)[]>;
-        /**
-         * Specify whether the table should be able to be sorted by its headers
-         */
-        isSortable: PropTypes.Requireable<boolean>;
-        /**
-         * Provide a string for the current locale
-         */
-        locale: PropTypes.Requireable<string>;
-        /**
-         * Specify whether the overflow menu (if it exists) should be shown always, or only on hover
-         */
-        overflowMenuOnHover: PropTypes.Requireable<boolean>;
-        /**
-         * Specify whether the control should be a radio button or inline checkbox
-         */
-        radio: PropTypes.Requireable<boolean>;
-        /**
-         * The `rows` prop is where you provide us with a list of all the rows that
-         * you want to render in the table. The only hard requirement is that this
-         * is an array of objects, and that each object has a unique `id` field
-         * available on it.
-         */
-        rows: PropTypes.Validator<(PropTypes.InferProps<{
-            id: PropTypes.Validator<string>;
-            disabled: PropTypes.Requireable<boolean>;
-            isSelected: PropTypes.Requireable<boolean>;
-            isExpanded: PropTypes.Requireable<boolean>;
-        }> | null | undefined)[]>;
-        /**
-         *  Change the row height of table. Currently supports `xs`, `sm`, `md`, `lg`, and `xl`.
-         */
-        size: PropTypes.Requireable<string>;
-        /**
-         * Optional hook to manually control sorting of the rows.
-         */
-        sortRow: PropTypes.Requireable<(...args: any[]) => any>;
-        /**
-         * Specify whether the header should be sticky.
-         * Still experimental: may not work with every combination of table props
-         */
-        stickyHeader: PropTypes.Requireable<boolean>;
-        /**
-         * Optional method that takes in a message id and returns an
-         * internationalized string. See `DataTable.translationKeys` for all
-         * available message ids.
-         */
-        translateWithId: PropTypes.Requireable<(...args: any[]) => any>;
-        /**
-         * `false` If true, will use a width of 'auto' instead of 100%
-         */
-        useStaticWidth: PropTypes.Requireable<boolean>;
-        /**
-         * `true` to add useZebraStyles striping.
-         */
-        useZebraStyles: PropTypes.Requireable<boolean>;
-    };
     static translationKeys: ("carbon.table.row.expand" | "carbon.table.row.collapse" | "carbon.table.all.expand" | "carbon.table.all.collapse" | "carbon.table.all.select" | "carbon.table.all.unselect" | "carbon.table.row.select" | "carbon.table.row.unselect")[];
     static Table: typeof Table;
     static TableActionList: typeof TableActionList;
@@ -334,200 +259,82 @@ declare class DataTable<RowType, ColTypes extends any[]> extends React.Component
     static TableToolbarContent: typeof TableToolbarContent;
     static TableToolbarSearch: typeof TableToolbarSearch;
     static TableToolbarMenu: typeof TableToolbarMenu;
-    constructor(props: any);
-    shouldComponentUpdate(nextProps: any): boolean;
+    private readonly rp;
+    constructor(props: DataTableProps<RowType, ColTypes>);
+    shouldComponentUpdate(nextProps: DataTableProps<RowType, ColTypes>): boolean;
     /**
      * Get the props associated with the given header. Mostly used for adding in
      * sorting behavior.
-     *
-     * @param {object} config
-     * @param {string} config.header the header we want the props for
-     * @param {Function} config.onClick a custom click handler for the header
-     * @param {boolean} config.isSortable
-     * @returns {object}
      */
-    getHeaderProps: ({ header, onClick, isSortable, ...rest }: {
-        header: DataTableHeader;
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>, sortState: {
-            sortHeaderKey: string;
-            sortDirection: DataTableSortState;
-        }) => void;
-        isSortable?: boolean;
-        [key: string]: unknown;
-    }) => {
-        key: string;
-        sortDirection: DataTableSortState;
-        isSortable: boolean | undefined;
-        isSortHeader: boolean;
-        slug: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
-        decorator: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
-        onClick: (event: any) => void;
-    };
+    getHeaderProps: (typeof this.rp)['getHeaderProps'];
     /**
      * Get the props associated with the given expand header.
-     *
-     * @param {object} config
-     * @param {Function} config.onClick a custom click handler for the expand header
-     * @param {Function} config.onExpand a custom click handler called when header is expanded
-     * @returns {object}
      */
-    getExpandHeaderProps: ({ onClick, onExpand, ...rest }?: {
-        [key: string]: unknown;
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>, expandState: {
-            isExpanded: boolean;
-        }) => void;
-        onExpand?: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    }) => {
-        'aria-label': any;
-        'aria-controls': string;
-        isExpanded: boolean;
-        onExpand: (event: React.MouseEvent<HTMLButtonElement, globalThis.MouseEvent>, ...args: any[]) => void;
-    };
+    getExpandHeaderProps: (typeof this.rp)['getExpandHeaderProps'];
     /**
      * Decorate consumer's `onClick` event handler with sort parameters
-     *
-     * @param {Function} onClick
-     * @param {object} sortParams
-     * @returns {Function}
      */
-    handleOnHeaderClick: (onClick: any, sortParams: any) => (e: any) => any;
+    handleOnHeaderClick: (onClick: (event: MouseEvent<HTMLButtonElement>, sortParams: {
+        sortHeaderKey: string;
+        sortDirection: DataTableSortState;
+    }) => void, sortParams: {
+        sortHeaderKey: string;
+        sortDirection: DataTableSortState;
+    }) => (event: MouseEvent<HTMLButtonElement>) => void;
     /**
-     * Decorate consumer's `onClick` event handler with sort parameters
-     *
-     * @param {Function} onClick
-     * @param {object} expandParams
-     * @returns {Function}
+     * Decorate consumer's `onClick` event handler with expand parameters
      */
-    handleOnExpandHeaderClick: (onClick: any, expandParams: any) => (e: any) => any;
+    handleOnExpandHeaderClick: (onClick: (event: MouseEvent<HTMLButtonElement>, expandParams: {
+        isExpanded: boolean;
+    }) => void, expandParams: {
+        isExpanded: boolean;
+    }) => (event: MouseEvent<HTMLButtonElement>) => void;
     /**
      * Get the props associated with the given row. Mostly used for expansion.
-     *
-     * @param {object} config
-     * @param {object} config.row the row we want the props for
-     * @param {Function} config.onClick a custom click handler for the header
-     * @returns {object}
      */
-    getRowProps: ({ row, onClick, ...rest }: {
-        onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
-        row: DataTableRow<ColTypes>;
-        [key: string]: unknown;
-    }) => {
-        key: string;
-        onExpand: (event: React.MouseEvent<HTMLButtonElement, globalThis.MouseEvent>, ...args: any[]) => void;
-        isExpanded: boolean | undefined;
-        'aria-label': any;
-        'aria-controls': string;
-        isSelected: boolean | undefined;
-        disabled: boolean | undefined;
-    };
+    getRowProps: (typeof this.rp)['getRowProps'];
     /**
      * Get the props associated with an expanded row
-     *
-     * @param {object} config
-     * @param {object} config.row the parent row we want the props for
-     * @returns {object}
      */
-    getExpandedRowProps: ({ row, ...rest }: {
-        row: DataTableRow<ColTypes>;
-        [key: string]: unknown;
-    }) => {
-        id: string;
-    };
+    getExpandedRowProps: (typeof this.rp)['getExpandedRowProps'];
     /**
      * Gets the props associated with selection for a header or a row, where
      * applicable. Most often used to indicate selection status of the table or
      * for a specific row.
      */
-    getSelectionProps: ({ onClick, row, ...rest }?: {
-        [key: string]: unknown;
-        onClick?: (e: MouseEvent<HTMLInputElement, globalThis.MouseEvent>) => void;
-        row: DataTableRow<ColTypes>;
-    }) => {
-        checked: boolean | undefined;
-        onSelect: (event: React.MouseEvent<HTMLInputElement, globalThis.MouseEvent>, ...args: any[]) => void;
-        id: string;
-        name: string;
-        'aria-label': any;
-        disabled: boolean | undefined;
-        radio: boolean | undefined;
-    } | {
-        'aria-label': any;
-        checked: boolean;
-        id: string;
-        indeterminate: boolean;
-        name: string;
-        onSelect: (event: React.MouseEvent<HTMLInputElement, globalThis.MouseEvent>, ...args: any[]) => void;
-    };
-    getToolbarProps: (props?: {}) => {
-        size: "sm" | undefined;
-        [key: string]: unknown;
-    };
-    getBatchActionProps: (props?: {}) => {
-        shouldShowBatchActions: boolean;
-        totalSelected: number;
-        onCancel: () => void;
-        onSelectAll: undefined;
-        totalCount: number;
-    };
-    /**
-     * Helper utility to get the Table Props.
-     */
-    getTableProps: () => {
-        useZebraStyles: boolean | undefined;
-        size: DataTableSize;
-        isSortable: boolean | undefined;
-        useStaticWidth: boolean | undefined;
-        stickyHeader: boolean | undefined;
-        overflowMenuOnHover: boolean;
-        experimentalAutoAlign: boolean | undefined;
-    };
-    /**
-     * Helper utility to get the TableContainer Props.
-     */
-    getTableContainerProps: () => {
-        stickyHeader: boolean | undefined;
-        useStaticWidth: boolean | undefined;
-    };
+    getSelectionProps: (typeof this.rp)['getSelectionProps'];
+    getToolbarProps: (typeof this.rp)['getToolbarProps'];
+    getBatchActionProps: (typeof this.rp)['getBatchActionProps'];
+    getTableProps: (typeof this.rp)['getTableProps'];
+    getTableContainerProps: (typeof this.rp)['getTableContainerProps'];
     /**
      * Get the props associated with the given table cell.
-     *
-     * @param {object} config
-     * @param {object} config.cell the cell we want the props for
-     * @returns {object}
      */
-    getCellProps: ({ cell, ...rest }: {
-        [x: string]: any;
-        cell: any;
-    }) => {
-        hasAILabelHeader: any;
-        hasDecoratorHeader: any;
-    };
+    getCellProps: (typeof this.rp)['getCellProps'];
     /**
      * Helper utility to get all the currently selected rows
-     * @returns {Array<string>} the array of rowIds that are currently selected
+     *
+     * @returns the array of rowIds that are currently selected
      */
     getSelectedRows: () => string[];
     /**
      * Helper utility to get all of the available rows after applying the filter
-     * @returns {Array<string>} the array of rowIds that are currently included through the filter
-     *  */
+     *
+     * @returns the array of rowIds that are currently included through the filter
+     */
     getFilteredRowIds: () => string[];
     /**
      * Helper for getting the table prefix for elements that require an
      * `id` attribute that is unique.
-     *
-     * @returns {string}
      */
     getTablePrefix: () => string;
     /**
      * Helper for toggling all selected items in a state. Does not call
      * setState, so use it when setting state.
-     * @param {object} initialState
-     * @returns {object} object to put into this.setState (use spread operator)
+     *
+     * @returns object to put into this.setState (use spread operator)
      */
-    setAllSelectedState: (initialState: any, isSelected: any, filteredRowIds: any) => {
-        rowsById: any;
-    };
+    setAllSelectedState: (initialState: DataTableState<ColTypes>, isSelected: boolean, filteredRowIds: string[]) => Pick<DataTableState<ColTypes>, "rowsById">;
     /**
      * Handler for the `onCancel` event to hide the batch action bar and
      * deselect all selected rows
@@ -539,18 +346,12 @@ declare class DataTable<RowType, ColTypes extends any[]> extends React.Component
     handleSelectAll: () => void;
     /**
      * Handler for toggling the selection state of a given row.
-     *
-     * @param {string} rowId
-     * @returns {Function}
      */
-    handleOnSelectRow: (rowId: any) => () => void;
+    handleOnSelectRow: (rowId: string) => () => void;
     /**
      * Handler for toggling the expansion state of a given row.
-     *
-     * @param {string} rowId
-     * @returns {Function}
      */
-    handleOnExpandRow: (rowId: any) => () => void;
+    handleOnExpandRow: (rowId: string) => () => void;
     /**
      * Handler for changing the expansion state of all rows.
      */
@@ -558,17 +359,14 @@ declare class DataTable<RowType, ColTypes extends any[]> extends React.Component
     /**
      * Handler for transitioning to the next sort state of the table
      *
-     * @param {string} headerKey the field for the header that we are sorting by
-     * @returns {Function}
+     * @param headerKey - The field for the header that we are sorting by.
      */
-    handleSortBy: (headerKey: any) => () => void;
+    handleSortBy: (headerKey: string) => () => void;
     /**
      * Event handler for transitioning input value state changes for the table
      * filter component.
-     *
-     * @param {Event} event
      */
-    handleOnInputValueChange: (event: any, defaultValue: any) => void;
-    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+    handleOnInputValueChange: (event: ChangeEvent<HTMLInputElement>, defaultValue?: string) => void;
+    render(): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
 }
 export default DataTable;