@elastic/eui 93.6.0 → 94.1.0

package/eui.d.ts

@@ -3854,13 +3854,81 @@ declare module '@elastic/eui/src/components/focus_trap' {
 	export type { EuiFocusTrapProps, FocusTarget } from '@elastic/eui/src/components/focus_trap/focus_trap';
 	export { EuiFocusTrap } from '@elastic/eui/src/components/focus_trap/focus_trap';
 
+}
+declare module '@elastic/eui/src/components/table/mobile/responsive_context' {
+	
+	import { type EuiBreakpointSize } from '@elastic/eui/src/services';
+	export const DEFAULT_TABLE_BREAKPOINT: EuiBreakpointSize;
+	/**
+	 * Used by parent/top-level table components to determine isResponsive state
+	 * based on the passed breakpoint
+	 */
+	export const useIsEuiTableResponsive: (componentProp?: string | boolean | undefined) => boolean;
+	/**
+	 * Context set by parent table components
+	 * Hook used by cells to fetch parent isResponsive state
+	 */
+	export const EuiTableIsResponsiveContext: import("react").Context<boolean>;
+	export const useEuiTableIsResponsive: () => boolean;
+
+}
+declare module '@elastic/eui/src/components/table/table.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableVariables: ({ euiTheme }: UseEuiTheme) => {
+	    cellContentPadding: string;
+	    compressedCellContentPadding: string;
+	    mobileSizes: {
+	        actions: {
+	            width: string;
+	            offset: string;
+	        };
+	        checkbox: {
+	            width: string;
+	            offset: string;
+	        };
+	    };
+	    checkboxSize: string;
+	};
+	export const euiTableStyles: (euiThemeContext: UseEuiTheme) => {
+	    euiTable: import("@emotion/utils").SerializedStyles;
+	    layout: {
+	        fixed: import("@emotion/utils").SerializedStyles;
+	        auto: import("@emotion/utils").SerializedStyles;
+	    };
+	    /**
+	     * 1. The padding on the `.euiTableCellContent` div allows the ellipsis to show if the
+	     * content is truncated. If the padding was on the cell, the ellipsis would be cropped.
+	     * 2. The `:where()` selector sets the specificity to 0, allowing consumers to more easily
+	     * override our CSS if needed
+	     */
+	    uncompressed: import("@emotion/utils").SerializedStyles;
+	    compressed: import("@emotion/utils").SerializedStyles;
+	    /**
+	     * Responsive/mobile vs desktop styles
+	     * Individual row/cells handle their own desktop vs mobile styles
+	     */
+	    desktop: import("@emotion/utils").SerializedStyles;
+	    mobile: import("@emotion/utils").SerializedStyles;
+	};
+	export const euiTableCaptionStyles: import("@emotion/utils").SerializedStyles;
+
 }
 declare module '@elastic/eui/src/components/table/table' {
 	import { FunctionComponent, TableHTMLAttributes } from 'react';
+	import { type EuiBreakpointSize } from '@elastic/eui/src/services';
 	import { CommonProps } from '@elastic/eui/src/components/common';
 	export interface EuiTableProps extends CommonProps, TableHTMLAttributes<HTMLTableElement> {
 	    compressed?: boolean;
-	    responsive?: boolean;
+	    /**
+	     * Named breakpoint. Below this size, the table will collapse
+	     * into responsive cards.
+	     *
+	     * Pass `false` to never collapse to a mobile view, or inversely,
+	     * `true` to always render mobile-friendly cards.
+	     *
+	     * @default m
+	     */
+	    responsiveBreakpoint?: EuiBreakpointSize | boolean;
 	    /**
 	     * Sets the table-layout CSS property
 	     */
@@ -3890,102 +3958,441 @@ declare module '@elastic/eui/src/components/table/utils' {
 	export const resolveWidthAsStyle: (style?: CSSProperties, width?: string | number | undefined) => CSSProperties;
 
 }
-declare module '@elastic/eui/src/components/table/table_footer_cell' {
-	import { FunctionComponent, TdHTMLAttributes } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	import { HorizontalAlignment } from '@elastic/eui/src/services';
-	export type EuiTableFooterCellProps = CommonProps & TdHTMLAttributes<HTMLTableCellElement> & {
-	    align?: HorizontalAlignment;
-	    width?: string | number;
-	};
-	export const EuiTableFooterCell: FunctionComponent<EuiTableFooterCellProps>;
+declare module '@elastic/eui/src/services/canvas/canvas_text_utils' {
+	import type { ExclusiveUnion } from '@elastic/eui/src/components/common';
+	export type CanvasTextParams = ExclusiveUnion<{
+	    container: HTMLElement;
+	}, {
+	    font: CanvasTextDrawingStyles['font'];
+	}>;
+	/**
+	 * Creates a temporary Canvas element for manipulating text & determining text width.
+	 *
+	 * To accurately measure text, canvas rendering requires either a container to
+	 * compute/derive font styles from, or a static font string (useful for usage
+	 * outside the DOM). Particular care should be applied when fallback fonts are
+	 * used, as more fallback fonts can lead to less precision.
+	 *
+	 * Please note that while canvas is more significantly more performant than DOM
+	 * measurement, there are subpixel to single digit pixel differences between
+	 * DOM and canvas measurement due to the different rendering engines used.
+	 */
+	export class CanvasTextUtils {
+	    context: CanvasRenderingContext2D;
+	    currentText: string;
+	    constructor({ font, container }: CanvasTextParams);
+	    computeFontFromElement: (element: HTMLElement) => string;
+	    get textWidth(): number;
+	    setTextToCheck: (text: string) => void;
+	}
 
 }
-declare module '@elastic/eui/src/components/table/table_header' {
-	import { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export type EuiTableHeaderProps = CommonProps & HTMLAttributes<HTMLElement> & {
+declare module '@elastic/eui/src/services/canvas' {
+	export { CanvasTextUtils } from '@elastic/eui/src/services/canvas/canvas_text_utils';
+	export type { CanvasTextParams } from '@elastic/eui/src/services/canvas/canvas_text_utils';
+
+}
+declare module '@elastic/eui/src/components/text_truncate/utils' {
+	import { CanvasTextParams, CanvasTextUtils } from '@elastic/eui/src/services/canvas'; type TruncationParams = CanvasTextParams & {
+	    fullText: string;
+	    ellipsis: string;
+	    availableWidth: number;
+	};
+	/**
+	 * Utilities for truncating types at various positions, as well as
+	 * determining whether truncation is possible or even necessary.
+	 */
+	export class TruncationUtils extends CanvasTextUtils {
+	    protected fullText: TruncationParams['fullText'];
+	    protected ellipsis: TruncationParams['ellipsis'];
+	    protected availableWidth: TruncationParams['availableWidth'];
+	    constructor({ fullText, ellipsis, availableWidth, ...rest }: TruncationParams);
 	    /**
-	     * Children must be valid DOM structure residing within `<thead>`.
-	     * Use `<td> | <th>` by default, or `<tr><th/></tr>` when `wrapWithTableRow=false`
+	     * Performance utilities
 	     */
-	    children?: ReactNode;
+	    debugPerformance: boolean;
+	    debugCounter: number;
+	    get textWidth(): number;
 	    /**
-	     * Automatically adds a wrapping `<tr>` element around the children
+	     * Internal utils for calculating a ratio based on the passed available width
+	     * vs the full text width.
+	     * This ratio is used to get an initial _approximate_ text string that should
+	     * be slightly over the available width, which we can then remove from
+	     * character-by-character until the text just fits within the available width.
 	     */
-	    wrapWithTableRow?: boolean;
-	};
-	export const EuiTableHeader: FunctionComponent<EuiTableHeaderProps>;
-
-}
-declare module '@elastic/eui/src/components/inner_text/inner_text' {
-	import { FunctionComponent, ReactElement } from 'react'; type RefT = HTMLElement | Element | undefined | null;
-	export function useInnerText(innerTextFallback?: string): [(node: RefT) => void, string | undefined];
-	export interface EuiInnerTextProps {
+	    widthRatio: number;
+	    setTextWidthRatio: (text?: string, textToOffset?: string) => void;
+	    getTextFromRatio: (text: string, type: 'start' | 'end') => string;
 	    /**
-	     * ReactNode to render as this component's content
+	     * Early return checks
 	     */
-	    children: (ref?: (node: RefT) => void, innerText?: string) => ReactElement;
-	    fallback?: string;
+	    checkIfTruncationIsNeeded: () => false | undefined;
+	    checkSufficientEllipsisWidth: (truncation: string) => false | undefined;
+	    checkTruncationOffsetWidth: (text: string) => false | undefined;
+	    /**
+	     * Truncation types logic. This is where the magic happens
+	     */
+	    truncateStart: (truncationOffset?: number | undefined) => string;
+	    truncateEnd: (truncationOffset?: number | undefined) => string;
+	    truncateStartEndAtPosition: (truncationPosition: number) => string;
+	    truncateStartEndAtMiddle: () => string;
+	    truncateMiddle: () => string;
 	}
-	export const EuiInnerText: FunctionComponent<EuiInnerTextProps>;
 	export {};
 
 }
-declare module '@elastic/eui/src/components/inner_text' {
-	export type { EuiInnerTextProps } from '@elastic/eui/src/components/inner_text/inner_text';
-	export { useInnerText, EuiInnerText } from '@elastic/eui/src/components/inner_text/inner_text';
+declare module '@elastic/eui/src/components/text_truncate/text_truncate.styles' {
+	export const euiTextTruncateStyles: {
+	    euiTextTruncate: import("@emotion/utils").SerializedStyles;
+	    /**
+	     * The below CSS is a hack to get double clicking and selecting the *full* text
+	     * instead of the truncated text (useful for copying/pasting, and mimics how
+	     * `text-overflow: ellipsis` works).
+	     *
+	     * Real talk: I'm lowkey amazed it works and it wouldn't surprise me if we ran into
+	     * cross-browser issues with this at some point. Hopefully CSS natively implements
+	     * custom text truncation some day (https://github.com/w3c/csswg-drafts/issues/3937)
+	     * and there'll be no need for the entire component at that point 🙏
+	     */
+	    euiTextTruncate__truncatedText: import("@emotion/utils").SerializedStyles;
+	    euiTextTruncate__fullText: import("@emotion/utils").SerializedStyles;
+	};
 
 }
-declare module '@elastic/eui/src/components/table/table_header_button' {
-	import { ButtonHTMLAttributes, FunctionComponent } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	import { IconType } from '@elastic/eui/src/components/icon';
-	export type EuiTableHeaderButtonProps = CommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
-	    iconType?: IconType;
+declare module '@elastic/eui/src/components/text_truncate/text_truncate' {
+	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
+	import type { CommonProps } from '@elastic/eui/src/components/common'; const TRUNCATION_TYPES: readonly ["end", "start", "startEnd", "middle"];
+	export type EuiTextTruncationTypes = (typeof TRUNCATION_TYPES)[number];
+	export type EuiTextTruncateProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onResize'> & CommonProps & {
+	    /**
+	     * The full text string to truncate
+	     */
+	    text: string;
+	    /**
+	     * The truncation type desired. Determines where the ellipses are placed.
+	     */
+	    truncation?: EuiTextTruncationTypes;
+	    /**
+	     * This prop **only** applies to the `start` and `end` truncation types.
+	     * It allows preserving a certain number of characters of either the
+	     * starting or ending text.
+	     *
+	     * If the passed offset is greater than the total text length,
+	     * the offset will be ignored.
+	     */
+	    truncationOffset?: number;
+	    /**
+	     * This prop **only** applies to the `startEnd` truncation type.
+	     * It allows customizing the anchor position of the displayed text,
+	     * which otherwise defaults to the middle of the text string.
+	     *
+	     * The primary use case for this prop for is search highlighting - e.g., if
+	     * a user searches for a specific word in the text, pass the index of that
+	     * found word to ensure it is always visible.
+	     *
+	     * This behavior will intelligently detect when positions are close to the start
+	     * or end of the text, and omit leading or trailing ellipses when necessary.
+	     * If the passed position is greater than the total text length,
+	     * the truncation will simply default to `start` instead.
+	     */
+	    truncationPosition?: number;
+	    /**
+	     * Defaults to the horizontal ellipsis character.
+	     * Can be optionally configured to use other punctuation,
+	     * e.g. spaces, brackets, hyphens, asterisks, etc.
+	     */
+	    ellipsis?: string;
+	    /**
+	     * By default, EuiTextTruncate will render a resize observer to detect the
+	     * available width it has. For performance reasons (e.g. multiple truncated
+	     * text items within the same container), you may opt to pass in your own
+	     * container width, which will skip initializing a resize observer.
+	     */
+	    width?: number;
+	    /**
+	     * Optional callback that fires when the default resizer observer both mounts and
+	     * registers a size change. This callback will **not** fire if `width` is passed.
+	     */
+	    onResize?: (width: number) => void;
+	    /**
+	     * By default, EuiTextTruncate will render the truncated string directly.
+	     * You can optionally pass a render prop function to the component, which
+	     * allows for more flexible text rendering, e.g. adding custom markup
+	     * or highlighting
+	     */
+	    children?: (truncatedString: string) => ReactNode;
+	    /**
+	     * For some edge case scenarios, EuiTextTruncate's calculations may be off until
+	     * fonts are done loading or layout is done shifting or settling. Adding a delay
+	     * may help resolve any rendering issues.
+	     */
+	    calculationDelayMs?: number;
 	};
-	export const EuiTableHeaderButton: FunctionComponent<EuiTableHeaderButtonProps>;
+	export const EuiTextTruncate: FunctionComponent<EuiTextTruncateProps>;
+	export {};
 
 }
-declare module '@elastic/eui/src/components/table/table_header_cell' {
-	import { FunctionComponent, ThHTMLAttributes } from 'react';
-	import { CommonProps, NoArgCallback } from '@elastic/eui/src/components/common';
-	import { HorizontalAlignment } from '@elastic/eui/src/services';
-	export type TableHeaderCellScope = 'col' | 'row' | 'colgroup' | 'rowgroup';
-	export type EuiTableHeaderCellProps = CommonProps & Omit<ThHTMLAttributes<HTMLTableHeaderCellElement>, 'align' | 'scope'> & {
-	    align?: HorizontalAlignment;
-	    isSortAscending?: boolean;
-	    isSorted?: boolean;
+declare module '@elastic/eui/src/components/text_truncate/text_block_truncate' {
+	import { FunctionComponent, HTMLAttributes, PropsWithChildren } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	export type EuiTextBlockTruncateProps = PropsWithChildren & CommonProps & HTMLAttributes<HTMLDivElement> & {
 	    /**
-	     * Mobile options for displaying differently at small screens
+	     * Number of lines of text to truncate to
 	     */
-	    mobileOptions?: {
-	        /**
-	         * If false, will not render the column at all for mobile
-	         */
-	        show?: boolean;
-	        /**
-	         * Only show for mobile? If true, will not render the column at all
-	         * for desktop
-	         */
-	        only?: boolean;
-	    };
-	    onSort?: NoArgCallback<void>;
-	    scope?: TableHeaderCellScope;
-	    width?: string | number;
-	    description?: string;
+	    lines: number;
 	    /**
-	     * Shows the sort indicator but removes the button
+	     * Applies styling to the child element instead of rendering a parent wrapper `div`.
+	     * Can only be used when wrapping a *single* child element/tag, and not raw text.
 	     */
-	    readOnly?: boolean;
+	    cloneElement?: boolean;
 	};
-	export const EuiTableHeaderCell: FunctionComponent<EuiTableHeaderCellProps>;
+	export const EuiTextBlockTruncate: FunctionComponent<EuiTextBlockTruncateProps>;
 
 }
-declare module '@elastic/eui/src/components/table/table_header_cell_checkbox' {
-	import { FunctionComponent, ThHTMLAttributes } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export type EuiTableHeaderCellCheckboxScope = 'col' | 'row' | 'colgroup' | 'rowgroup';
+declare module '@elastic/eui/src/components/text_truncate' {
+	export type { EuiTextTruncateProps, EuiTextTruncationTypes, } from '@elastic/eui/src/components/text_truncate/text_truncate';
+	export { EuiTextTruncate } from '@elastic/eui/src/components/text_truncate/text_truncate';
+	export type { EuiTextBlockTruncateProps } from '@elastic/eui/src/components/text_truncate/text_block_truncate';
+	export { EuiTextBlockTruncate } from '@elastic/eui/src/components/text_truncate/text_block_truncate';
+	export { TruncationUtils } from '@elastic/eui/src/components/text_truncate/utils';
+
+}
+declare module '@elastic/eui/src/components/table/table_row_cell.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableRowCellStyles: (euiThemeContext: UseEuiTheme) => {
+	    euiTableRowCell: import("@emotion/utils").SerializedStyles;
+	    rowHeader: import("@emotion/utils").SerializedStyles;
+	    isExpander: import("@emotion/utils").SerializedStyles;
+	    hasActions: import("@emotion/utils").SerializedStyles;
+	    middle: import("@emotion/utils").SerializedStyles;
+	    baseline: import("@emotion/utils").SerializedStyles;
+	    top: import("@emotion/utils").SerializedStyles;
+	    bottom: import("@emotion/utils").SerializedStyles;
+	    desktop: {
+	        desktop: import("@emotion/utils").SerializedStyles;
+	        actions: import("@emotion/utils").SerializedStyles;
+	    };
+	    mobile: {
+	        mobile: import("@emotion/utils").SerializedStyles;
+	        enlarge: import("@emotion/utils").SerializedStyles;
+	        rightColumnContent: string;
+	        readonly actions: import("@emotion/utils").SerializedStyles;
+	        readonly expander: import("@emotion/utils").SerializedStyles;
+	        /**
+	         * Custom actions may not be icons and therefore may not fit in a column
+	         * If they're the last cell, we can create a pseudo "row"/"border-top"
+	         * that mimicks the visual separation that the right column has
+	         */
+	        customActions: import("@emotion/utils").SerializedStyles;
+	    };
+	    euiTableRowCell__mobileHeader: import("@emotion/utils").SerializedStyles;
+	};
+
+}
+declare module '@elastic/eui/src/components/table/table_row_cell' {
+	import { CSSProperties, FunctionComponent, ReactNode, TdHTMLAttributes } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	import { HorizontalAlignment } from '@elastic/eui/src/services';
+	interface EuiTableRowCellSharedPropsShape {
+	    /**
+	     * Horizontal alignment of the text in the cell
+	     */
+	    align?: HorizontalAlignment;
+	    /**
+	     * Creates a text wrapper around cell content that helps word break or truncate
+	     * long text correctly.
+	     * @default true
+	     */
+	    textOnly?: boolean;
+	    /**
+	     * Indicates whether this column should truncate overflowing text content.
+	     * - Set to `true` to enable single-line truncation.
+	     * - To enable multi-line truncation, use a configuration object with `lines`
+	     * set to a number of lines to truncate to.
+	     * @default false
+	     */
+	    truncateText?: boolean | {
+	        lines: number;
+	    };
+	    width?: CSSProperties['width'];
+	}
+	export interface EuiTableRowCellMobileOptionsShape extends EuiTableRowCellSharedPropsShape {
+	    /**
+	     * If false, will not render the cell at all for mobile
+	     * @default true
+	     */
+	    show?: boolean;
+	    /**
+	     * Only show for mobile? If true, will not render the column at all for desktop
+	     * @default false
+	     */
+	    only?: boolean;
+	    /**
+	     * Custom render/children if different from desktop
+	     */
+	    render?: ReactNode;
+	    /**
+	     * The column's header for use in mobile view (automatically passed down
+	     * when using `EuiBasicTable`).
+	     * Or pass `false` to not show a header at all.
+	     */
+	    header?: ReactNode | boolean;
+	    /**
+	     * Increase text size compared to rest of cells
+	     * @default false
+	     */
+	    enlarge?: boolean;
+	    /**
+	     * Applies the value to the width of the cell in mobile view (typically 50%)
+	     * @default 50%
+	     */
+	    width?: CSSProperties['width'];
+	}
+	export interface EuiTableRowCellProps extends EuiTableRowCellSharedPropsShape {
+	    /**
+	     * Vertical alignment of the content in the cell
+	     */
+	    valign?: TdHTMLAttributes<HTMLTableCellElement>['valign'];
+	    /**
+	     * Indicates whether the cell should be marked as the heading for its row
+	     */
+	    setScopeRow?: boolean;
+	    /**
+	     * Indicates if the cell is dedicated to row actions
+	     * (used for mobile styling and desktop action hover behavior)
+	     */
+	    hasActions?: boolean | 'custom';
+	    /**
+	     * Indicates if the column is dedicated as the expandable row toggle
+	     */
+	    isExpander?: boolean;
+	    /**
+	     * Mobile options for displaying differently at small screens;
+	     * See #EuiTableRowCellMobileOptionsShape
+	     */
+	    mobileOptions?: EuiTableRowCellMobileOptionsShape;
+	} type Props = CommonProps & Omit<TdHTMLAttributes<HTMLTableCellElement>, 'valign'> & EuiTableRowCellProps;
+	export const EuiTableRowCell: FunctionComponent<Props>;
+	export {};
+
+}
+declare module '@elastic/eui/src/components/table/_table_cell_content.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableCellContentStyles: ({ euiTheme }: UseEuiTheme) => {
+	    euiTableCellContent: import("@emotion/utils").SerializedStyles;
+	    left: null;
+	    right: import("@emotion/utils").SerializedStyles;
+	    center: import("@emotion/utils").SerializedStyles;
+	    truncateText: import("@emotion/utils").SerializedStyles;
+	    wrapText: import("@emotion/utils").SerializedStyles;
+	    hasActions: {
+	        actions: import("@emotion/utils").SerializedStyles;
+	        desktop: import("@emotion/utils").SerializedStyles;
+	        mobile: import("@emotion/utils").SerializedStyles;
+	    };
+	};
+
+}
+declare module '@elastic/eui/src/components/table/_table_cell_content' {
+	import { FunctionComponent, HTMLAttributes } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	import type { EuiTableRowCellProps } from '@elastic/eui/src/components/table/table_row_cell';
+	export type EuiTableCellContentProps = CommonProps & HTMLAttributes<HTMLDivElement> & Pick<EuiTableRowCellProps, 'align' | 'hasActions' | 'textOnly'> & {
+	    truncateText?: EuiTableRowCellProps['truncateText'] | null;
+	};
+	export const EuiTableCellContent: FunctionComponent<EuiTableCellContentProps>;
+
+}
+declare module '@elastic/eui/src/components/table/table_cells_shared.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableHeaderFooterCellStyles: (euiThemeContext: UseEuiTheme) => {
+	    euiTableHeaderCell: import("@emotion/utils").SerializedStyles;
+	    euiTableHeaderCell__content: import("@emotion/utils").SerializedStyles;
+	    euiTableHeaderCell__button: import("@emotion/utils").SerializedStyles;
+	    euiTableFooterCell: import("@emotion/utils").SerializedStyles;
+	};
+	export const euiTableCellCheckboxStyles: (euiThemeContext: UseEuiTheme) => {
+	    euiTableHeaderCellCheckbox: import("@emotion/utils").SerializedStyles;
+	    euiTableRowCellCheckbox: import("@emotion/utils").SerializedStyles;
+	    desktop: import("@emotion/utils").SerializedStyles;
+	    mobile: import("@emotion/utils").SerializedStyles;
+	};
+
+}
+declare module '@elastic/eui/src/components/table/table_footer_cell' {
+	import { FunctionComponent, TdHTMLAttributes } from 'react';
+	import { HorizontalAlignment } from '@elastic/eui/src/services';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	export type EuiTableFooterCellProps = CommonProps & TdHTMLAttributes<HTMLTableCellElement> & {
+	    align?: HorizontalAlignment;
+	    width?: string | number;
+	};
+	export const EuiTableFooterCell: FunctionComponent<EuiTableFooterCellProps>;
+
+}
+declare module '@elastic/eui/src/components/table/table_header' {
+	import { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	export type EuiTableHeaderProps = CommonProps & HTMLAttributes<HTMLElement> & {
+	    /**
+	     * Children must be valid DOM structure residing within `<thead>`.
+	     * Use `<td> | <th>` by default, or `<tr><th/></tr>` when `wrapWithTableRow=false`
+	     */
+	    children?: ReactNode;
+	    /**
+	     * Automatically adds a wrapping `<tr>` element around the children
+	     */
+	    wrapWithTableRow?: boolean;
+	};
+	export const EuiTableHeader: FunctionComponent<EuiTableHeaderProps>;
+
+}
+declare module '@elastic/eui/src/components/inner_text/inner_text' {
+	import { FunctionComponent, ReactElement } from 'react'; type RefT = HTMLElement | Element | undefined | null;
+	export function useInnerText(innerTextFallback?: string): [(node: RefT) => void, string | undefined];
+	export interface EuiInnerTextProps {
+	    /**
+	     * ReactNode to render as this component's content
+	     */
+	    children: (ref?: (node: RefT) => void, innerText?: string) => ReactElement;
+	    fallback?: string;
+	}
+	export const EuiInnerText: FunctionComponent<EuiInnerTextProps>;
+	export {};
+
+}
+declare module '@elastic/eui/src/components/inner_text' {
+	export type { EuiInnerTextProps } from '@elastic/eui/src/components/inner_text/inner_text';
+	export { useInnerText, EuiInnerText } from '@elastic/eui/src/components/inner_text/inner_text';
+
+}
+declare module '@elastic/eui/src/components/table/table_header_cell' {
+	import { FunctionComponent, ThHTMLAttributes } from 'react';
+	import { HorizontalAlignment } from '@elastic/eui/src/services';
+	import { CommonProps, NoArgCallback } from '@elastic/eui/src/components/common';
+	import type { EuiTableRowCellMobileOptionsShape } from '@elastic/eui/src/components/table/table_row_cell';
+	export type TableHeaderCellScope = 'col' | 'row' | 'colgroup' | 'rowgroup';
+	export type EuiTableHeaderCellProps = CommonProps & Omit<ThHTMLAttributes<HTMLTableHeaderCellElement>, 'align' | 'scope'> & {
+	    align?: HorizontalAlignment;
+	    isSortAscending?: boolean;
+	    isSorted?: boolean;
+	    mobileOptions?: Pick<EuiTableRowCellMobileOptionsShape, 'only' | 'show'>;
+	    onSort?: NoArgCallback<void>;
+	    scope?: TableHeaderCellScope;
+	    width?: string | number;
+	    description?: string;
+	    /**
+	     * Shows the sort indicator but removes the button
+	     */
+	    readOnly?: boolean;
+	};
+	export const EuiTableHeaderCell: FunctionComponent<EuiTableHeaderCellProps>;
+
+}
+declare module '@elastic/eui/src/components/table/table_header_cell_checkbox' {
+	import { FunctionComponent, ThHTMLAttributes } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	export type EuiTableHeaderCellCheckboxScope = 'col' | 'row' | 'colgroup' | 'rowgroup';
 	export interface EuiTableHeaderCellCheckboxProps {
 	    width?: string | number;
 	    scope?: EuiTableHeaderCellCheckboxScope;
@@ -5219,410 +5626,174 @@ declare module '@elastic/eui/src/components/table/table_pagination/table_paginat
 	     *
 	     * @default true
 	     */
-	    showPerPageOptions?: boolean;
-	    /**
-	     * Current selection for "Rows per page".
-	     * Pass `0` to display the selected "Show all" option and hide the pagination.
-	     *
-	     * @default 10
-	     */
-	    itemsPerPage?: number;
-	    /**
-	     * Custom array of options for "Rows per page".
-	     * Pass `0` as one of the options to create a "Show all" option.
-	     *
-	     * @default [10, 25, 50]
-	     */
-	    itemsPerPageOptions?: number[];
-	    /**
-	     * Click handler that passes back selected `pageSize` number
-	     */
-	    onChangeItemsPerPage?: ItemsPerPageChangeHandler;
-	    onChangePage?: PageChangeHandler;
-	    /**
-	     * Requires the `id` of the table being controlled
-	     */
-	    'aria-controls'?: string;
-	    'aria-label'?: string;
-	}
-	export const EuiTablePagination: FunctionComponent<EuiTablePaginationProps>;
-
-}
-declare module '@elastic/eui/src/components/table/table_pagination' {
-	export type { EuiTablePaginationProps } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
-	export { EuiTablePagination } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
-	export { useEuiTablePaginationDefaults, euiTablePaginationDefaults, } from '@elastic/eui/src/components/table/table_pagination/table_pagination_defaults';
-
-}
-declare module '@elastic/eui/src/components/table/mobile/table_header_mobile' {
-	import { FunctionComponent, HTMLAttributes } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export const EuiTableHeaderMobile: FunctionComponent<CommonProps & HTMLAttributes<HTMLDivElement>>;
-
-}
-declare module '@elastic/eui/src/components/table/mobile/table_sort_mobile_item' {
-	import { FunctionComponent, PropsWithChildren } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export interface EuiTableSortMobileItemProps extends PropsWithChildren, CommonProps {
-	    /**
-	     * Callback to know when an item has been clicked
-	     */
-	    onSort?: () => void;
-	    /**
-	     * Indicates current option is the sorted on column
-	     */
-	    isSorted?: boolean;
-	    /**
-	     * Indicates which direction the current column is sorted on
-	     */
-	    isSortAscending?: boolean;
-	    ariaLabel?: string;
-	}
-	export const EuiTableSortMobileItem: FunctionComponent<EuiTableSortMobileItemProps>;
-
-}
-declare module '@elastic/eui/src/components/table/mobile/table_sort_mobile' {
-	import React, { Component, ReactNode, Key } from 'react';
-	import { PopoverAnchorPosition } from '@elastic/eui/src/components/popover';
-	interface ItemProps {
-	    name: ReactNode;
-	    key?: Key;
-	    onSort?: () => void;
-	    isSorted?: boolean;
-	    isSortAscending?: boolean;
-	}
-	export interface EuiTableSortMobileProps {
-	    className?: string;
-	    anchorPosition?: PopoverAnchorPosition;
-	    items?: ItemProps[];
-	}
-	interface State {
-	    isPopoverOpen: boolean;
-	}
-	export class EuiTableSortMobile extends Component<EuiTableSortMobileProps, State> {
-	    state: {
-	        isPopoverOpen: boolean;
-	    };
-	    onButtonClick: () => void;
-	    closePopover: () => void;
-	    render(): React.JSX.Element;
-	}
-	export {};
-
-}
-declare module '@elastic/eui/src/components/table/table_row' {
-	import { FunctionComponent, HTMLAttributes, KeyboardEventHandler, MouseEventHandler } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export interface EuiTableRowProps {
-	    /**
-	     * Indicates if the table has a single column of checkboxes for selecting
-	     * rows (affects mobile only)
-	     */
-	    isSelectable?: boolean;
-	    /**
-	     * Indicates the current row has been selected
-	     */
-	    isSelected?: boolean;
-	    /**
-	     * Indicates if the table has a dedicated column for icon-only actions
-	     * (affects mobile only)
-	     */
-	    hasActions?: boolean;
-	    /**
-	     * Indicates if the row will have an expanded row
-	     */
-	    isExpandable?: boolean;
-	    /**
-	     * Indicates if the row will be the expanded row
-	     */
-	    isExpandedRow?: boolean;
-	    onClick?: MouseEventHandler<HTMLTableRowElement> & KeyboardEventHandler<HTMLTableRowElement>;
-	} type Props = CommonProps & HTMLAttributes<HTMLTableRowElement> & EuiTableRowProps;
-	export const EuiTableRow: FunctionComponent<Props>;
-	export {};
-
-}
-declare module '@elastic/eui/src/services/canvas/canvas_text_utils' {
-	import type { ExclusiveUnion } from '@elastic/eui/src/components/common';
-	export type CanvasTextParams = ExclusiveUnion<{
-	    container: HTMLElement;
-	}, {
-	    font: CanvasTextDrawingStyles['font'];
-	}>;
-	/**
-	 * Creates a temporary Canvas element for manipulating text & determining text width.
-	 *
-	 * To accurately measure text, canvas rendering requires either a container to
-	 * compute/derive font styles from, or a static font string (useful for usage
-	 * outside the DOM). Particular care should be applied when fallback fonts are
-	 * used, as more fallback fonts can lead to less precision.
-	 *
-	 * Please note that while canvas is more significantly more performant than DOM
-	 * measurement, there are subpixel to single digit pixel differences between
-	 * DOM and canvas measurement due to the different rendering engines used.
-	 */
-	export class CanvasTextUtils {
-	    context: CanvasRenderingContext2D;
-	    currentText: string;
-	    constructor({ font, container }: CanvasTextParams);
-	    computeFontFromElement: (element: HTMLElement) => string;
-	    get textWidth(): number;
-	    setTextToCheck: (text: string) => void;
-	}
-
-}
-declare module '@elastic/eui/src/services/canvas' {
-	export { CanvasTextUtils } from '@elastic/eui/src/services/canvas/canvas_text_utils';
-	export type { CanvasTextParams } from '@elastic/eui/src/services/canvas/canvas_text_utils';
-
-}
-declare module '@elastic/eui/src/components/text_truncate/utils' {
-	import { CanvasTextParams, CanvasTextUtils } from '@elastic/eui/src/services/canvas'; type TruncationParams = CanvasTextParams & {
-	    fullText: string;
-	    ellipsis: string;
-	    availableWidth: number;
-	};
-	/**
-	 * Utilities for truncating types at various positions, as well as
-	 * determining whether truncation is possible or even necessary.
-	 */
-	export class TruncationUtils extends CanvasTextUtils {
-	    protected fullText: TruncationParams['fullText'];
-	    protected ellipsis: TruncationParams['ellipsis'];
-	    protected availableWidth: TruncationParams['availableWidth'];
-	    constructor({ fullText, ellipsis, availableWidth, ...rest }: TruncationParams);
-	    /**
-	     * Performance utilities
-	     */
-	    debugPerformance: boolean;
-	    debugCounter: number;
-	    get textWidth(): number;
-	    /**
-	     * Internal utils for calculating a ratio based on the passed available width
-	     * vs the full text width.
-	     * This ratio is used to get an initial _approximate_ text string that should
-	     * be slightly over the available width, which we can then remove from
-	     * character-by-character until the text just fits within the available width.
-	     */
-	    widthRatio: number;
-	    setTextWidthRatio: (text?: string, textToOffset?: string) => void;
-	    getTextFromRatio: (text: string, type: 'start' | 'end') => string;
-	    /**
-	     * Early return checks
-	     */
-	    checkIfTruncationIsNeeded: () => false | undefined;
-	    checkSufficientEllipsisWidth: (truncation: string) => false | undefined;
-	    checkTruncationOffsetWidth: (text: string) => false | undefined;
-	    /**
-	     * Truncation types logic. This is where the magic happens
-	     */
-	    truncateStart: (truncationOffset?: number | undefined) => string;
-	    truncateEnd: (truncationOffset?: number | undefined) => string;
-	    truncateStartEndAtPosition: (truncationPosition: number) => string;
-	    truncateStartEndAtMiddle: () => string;
-	    truncateMiddle: () => string;
-	}
-	export {};
-
-}
-declare module '@elastic/eui/src/components/text_truncate/text_truncate.styles' {
-	export const euiTextTruncateStyles: {
-	    euiTextTruncate: import("@emotion/utils").SerializedStyles;
-	    /**
-	     * The below CSS is a hack to get double clicking and selecting the *full* text
-	     * instead of the truncated text (useful for copying/pasting, and mimics how
-	     * `text-overflow: ellipsis` works).
-	     *
-	     * Real talk: I'm lowkey amazed it works and it wouldn't surprise me if we ran into
-	     * cross-browser issues with this at some point. Hopefully CSS natively implements
-	     * custom text truncation some day (https://github.com/w3c/csswg-drafts/issues/3937)
-	     * and there'll be no need for the entire component at that point 🙏
-	     */
-	    euiTextTruncate__truncatedText: import("@emotion/utils").SerializedStyles;
-	    euiTextTruncate__fullText: import("@emotion/utils").SerializedStyles;
-	};
-
-}
-declare module '@elastic/eui/src/components/text_truncate/text_truncate' {
-	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
-	import type { CommonProps } from '@elastic/eui/src/components/common'; const TRUNCATION_TYPES: readonly ["end", "start", "startEnd", "middle"];
-	export type EuiTextTruncationTypes = (typeof TRUNCATION_TYPES)[number];
-	export type EuiTextTruncateProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onResize'> & CommonProps & {
-	    /**
-	     * The full text string to truncate
-	     */
-	    text: string;
-	    /**
-	     * The truncation type desired. Determines where the ellipses are placed.
-	     */
-	    truncation?: EuiTextTruncationTypes;
-	    /**
-	     * This prop **only** applies to the `start` and `end` truncation types.
-	     * It allows preserving a certain number of characters of either the
-	     * starting or ending text.
-	     *
-	     * If the passed offset is greater than the total text length,
-	     * the offset will be ignored.
-	     */
-	    truncationOffset?: number;
-	    /**
-	     * This prop **only** applies to the `startEnd` truncation type.
-	     * It allows customizing the anchor position of the displayed text,
-	     * which otherwise defaults to the middle of the text string.
-	     *
-	     * The primary use case for this prop for is search highlighting - e.g., if
-	     * a user searches for a specific word in the text, pass the index of that
-	     * found word to ensure it is always visible.
-	     *
-	     * This behavior will intelligently detect when positions are close to the start
-	     * or end of the text, and omit leading or trailing ellipses when necessary.
-	     * If the passed position is greater than the total text length,
-	     * the truncation will simply default to `start` instead.
-	     */
-	    truncationPosition?: number;
-	    /**
-	     * Defaults to the horizontal ellipsis character.
-	     * Can be optionally configured to use other punctuation,
-	     * e.g. spaces, brackets, hyphens, asterisks, etc.
-	     */
-	    ellipsis?: string;
-	    /**
-	     * By default, EuiTextTruncate will render a resize observer to detect the
-	     * available width it has. For performance reasons (e.g. multiple truncated
-	     * text items within the same container), you may opt to pass in your own
-	     * container width, which will skip initializing a resize observer.
-	     */
-	    width?: number;
-	    /**
-	     * Optional callback that fires when the default resizer observer both mounts and
-	     * registers a size change. This callback will **not** fire if `width` is passed.
-	     */
-	    onResize?: (width: number) => void;
+	    showPerPageOptions?: boolean;
 	    /**
-	     * By default, EuiTextTruncate will render the truncated string directly.
-	     * You can optionally pass a render prop function to the component, which
-	     * allows for more flexible text rendering, e.g. adding custom markup
-	     * or highlighting
+	     * Current selection for "Rows per page".
+	     * Pass `0` to display the selected "Show all" option and hide the pagination.
+	     *
+	     * @default 10
 	     */
-	    children?: (truncatedString: string) => ReactNode;
+	    itemsPerPage?: number;
 	    /**
-	     * For some edge case scenarios, EuiTextTruncate's calculations may be off until
-	     * fonts are done loading or layout is done shifting or settling. Adding a delay
-	     * may help resolve any rendering issues.
+	     * Custom array of options for "Rows per page".
+	     * Pass `0` as one of the options to create a "Show all" option.
+	     *
+	     * @default [10, 25, 50]
 	     */
-	    calculationDelayMs?: number;
-	};
-	export const EuiTextTruncate: FunctionComponent<EuiTextTruncateProps>;
-	export {};
-
-}
-declare module '@elastic/eui/src/components/text_truncate/text_block_truncate' {
-	import { FunctionComponent, HTMLAttributes, PropsWithChildren } from 'react';
-	import { CommonProps } from '@elastic/eui/src/components/common';
-	export type EuiTextBlockTruncateProps = PropsWithChildren & CommonProps & HTMLAttributes<HTMLDivElement> & {
+	    itemsPerPageOptions?: number[];
 	    /**
-	     * Number of lines of text to truncate to
+	     * Click handler that passes back selected `pageSize` number
 	     */
-	    lines: number;
+	    onChangeItemsPerPage?: ItemsPerPageChangeHandler;
+	    onChangePage?: PageChangeHandler;
 	    /**
-	     * Applies styling to the child element instead of rendering a parent wrapper `div`.
-	     * Can only be used when wrapping a *single* child element/tag, and not raw text.
+	     * Requires the `id` of the table being controlled
 	     */
-	    cloneElement?: boolean;
+	    'aria-controls'?: string;
+	    'aria-label'?: string;
+	}
+	export const EuiTablePagination: FunctionComponent<EuiTablePaginationProps>;
+
+}
+declare module '@elastic/eui/src/components/table/table_pagination' {
+	export type { EuiTablePaginationProps } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
+	export { EuiTablePagination } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
+	export { useEuiTablePaginationDefaults, euiTablePaginationDefaults, } from '@elastic/eui/src/components/table/table_pagination/table_pagination_defaults';
+
+}
+declare module '@elastic/eui/src/components/table/mobile/table_header_mobile.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableHeaderMobileStyles: ({ euiTheme }: UseEuiTheme) => {
+	    euiTableHeaderMobile: import("@emotion/utils").SerializedStyles;
 	};
-	export const EuiTextBlockTruncate: FunctionComponent<EuiTextBlockTruncateProps>;
 
 }
-declare module '@elastic/eui/src/components/text_truncate' {
-	export type { EuiTextTruncateProps, EuiTextTruncationTypes, } from '@elastic/eui/src/components/text_truncate/text_truncate';
-	export { EuiTextTruncate } from '@elastic/eui/src/components/text_truncate/text_truncate';
-	export type { EuiTextBlockTruncateProps } from '@elastic/eui/src/components/text_truncate/text_block_truncate';
-	export { EuiTextBlockTruncate } from '@elastic/eui/src/components/text_truncate/text_block_truncate';
-	export { TruncationUtils } from '@elastic/eui/src/components/text_truncate/utils';
+declare module '@elastic/eui/src/components/table/mobile/table_header_mobile' {
+	import { FunctionComponent, HTMLAttributes } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	import type { EuiTableProps } from '@elastic/eui/src/components/table/table';
+	export const EuiTableHeaderMobile: FunctionComponent<CommonProps & HTMLAttributes<HTMLDivElement> & Pick<EuiTableProps, 'responsiveBreakpoint'>>;
 
 }
-declare module '@elastic/eui/src/components/table/table_row_cell' {
-	import { CSSProperties, FunctionComponent, ReactNode, TdHTMLAttributes } from 'react';
+declare module '@elastic/eui/src/components/table/mobile/table_sort_mobile_item' {
+	import { FunctionComponent, PropsWithChildren } from 'react';
 	import { CommonProps } from '@elastic/eui/src/components/common';
-	import { HorizontalAlignment } from '@elastic/eui/src/services';
-	interface EuiTableRowCellSharedPropsShape {
-	    /**
-	     * Horizontal alignment of the text in the cell
-	     */
-	    align?: HorizontalAlignment;
+	export interface EuiTableSortMobileItemProps extends PropsWithChildren, CommonProps {
 	    /**
-	     * _Should only be used for action cells_
+	     * Callback to know when an item has been clicked
 	     */
-	    showOnHover?: boolean;
+	    onSort?: () => void;
 	    /**
-	     * Creates a text wrapper around cell content that helps word break or truncate
-	     * long text correctly.
+	     * Indicates current option is the sorted on column
 	     */
-	    textOnly?: boolean;
+	    isSorted?: boolean;
 	    /**
-	     * Indicates whether this column should truncate overflowing text content.
-	     * - Set to `true` to enable single-line truncation.
-	     * - To enable multi-line truncation, use a configuration object with `lines`
-	     * set to a number of lines to truncate to.
+	     * Indicates which direction the current column is sorted on
 	     */
-	    truncateText?: boolean | {
-	        lines: number;
+	    isSortAscending?: boolean;
+	    ariaLabel?: string;
+	}
+	export const EuiTableSortMobileItem: FunctionComponent<EuiTableSortMobileItemProps>;
+
+}
+declare module '@elastic/eui/src/components/table/mobile/table_sort_mobile' {
+	import React, { Component, ReactNode, Key } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	import { PopoverAnchorPosition } from '@elastic/eui/src/components/popover';
+	interface ItemProps {
+	    name: ReactNode;
+	    key?: Key;
+	    onSort?: () => void;
+	    isSorted?: boolean;
+	    isSortAscending?: boolean;
+	}
+	export interface EuiTableSortMobileProps extends CommonProps {
+	    anchorPosition?: PopoverAnchorPosition;
+	    items?: ItemProps[];
+	}
+	interface State {
+	    isPopoverOpen: boolean;
+	}
+	export class EuiTableSortMobile extends Component<EuiTableSortMobileProps, State> {
+	    state: {
+	        isPopoverOpen: boolean;
 	    };
-	    width?: CSSProperties['width'];
+	    onButtonClick: () => void;
+	    closePopover: () => void;
+	    euiTableSortMobileStyles: {
+	        marginInlineStart: string;
+	        label: string;
+	    };
+	    render(): React.JSX.Element;
 	}
-	export interface EuiTableRowCellMobileOptionsShape extends EuiTableRowCellSharedPropsShape {
-	    /**
-	     * If false, will not render the cell at all for mobile
-	     */
-	    show?: boolean;
-	    /**
-	     * Only show for mobile? If true, will not render the column at all for desktop
-	     */
-	    only?: boolean;
-	    /**
-	     * Custom render/children if different from desktop
-	     */
-	    render?: ReactNode;
-	    /**
-	     * The column's header for use in mobile view (automatically passed down
-	     * when using `EuiBasicTable`).
-	     * Or pass `false` to not show a header at all.
-	     */
-	    header?: ReactNode | boolean;
-	    /**
-	     * Increase text size compared to rest of cells
-	     */
-	    enlarge?: boolean;
+	export {};
+
+}
+declare module '@elastic/eui/src/components/table/table_row.styles' {
+	import { UseEuiTheme } from '@elastic/eui/src/services';
+	export const euiTableRowStyles: (euiThemeContext: UseEuiTheme) => {
+	    euiTableRow: import("@emotion/utils").SerializedStyles;
+	    desktop: {
+	        desktop: import("@emotion/utils").SerializedStyles;
+	        expanded: import("@emotion/utils").SerializedStyles;
+	        clickable: import("@emotion/utils").SerializedStyles;
+	        selected: import("@emotion/utils").SerializedStyles;
+	        checkboxOffset: import("@emotion/utils").SerializedStyles;
+	    };
+	    mobile: {
+	        mobile: import("@emotion/utils").SerializedStyles;
+	        selected: import("@emotion/utils").SerializedStyles;
+	        /**
+	         * Left column offset (no border)
+	         * Used for selection checkbox, which will be absolutely positioned
+	         */
+	        hasLeftColumn: import("@emotion/utils").SerializedStyles;
+	        /**
+	         * Right column styles + border
+	         * Used for cell actions and row expander arrow
+	         */
+	        hasRightColumn: import("@emotion/utils").SerializedStyles;
+	        /**
+	         * Bottom of card - expanded rows
+	         */
+	        expanded: import("@emotion/utils").SerializedStyles;
+	    };
+	};
+
+}
+declare module '@elastic/eui/src/components/table/table_row' {
+	import { FunctionComponent, HTMLAttributes, KeyboardEventHandler, MouseEventHandler } from 'react';
+	import { CommonProps } from '@elastic/eui/src/components/common';
+	export interface EuiTableRowProps {
 	    /**
-	     * Applies the value to the width of the cell in mobile view (typically 50%)
+	     * Indicates if the table has a single column of checkboxes for selecting
+	     * rows (used for mobile styling)
 	     */
-	    width?: CSSProperties['width'];
-	}
-	export interface EuiTableRowCellProps extends EuiTableRowCellSharedPropsShape {
+	    hasSelection?: boolean;
 	    /**
-	     * Vertical alignment of the content in the cell
+	     * Indicates that the current row's checkbox is selectable / not disabled
 	     */
-	    valign?: TdHTMLAttributes<HTMLTableCellElement>['valign'];
+	    isSelectable?: boolean;
 	    /**
-	     * Indicates whether the cell should be marked as the heading for its row
+	     * Indicates the current row has been selected
 	     */
-	    setScopeRow?: boolean;
+	    isSelected?: boolean;
 	    /**
-	     * Indicates if the column is dedicated to icon-only actions (currently
-	     * affects mobile only)
+	     * Indicates if the table has a dedicated column for actions
+	     * (used for mobile styling and desktop action hover behavior)
 	     */
-	    hasActions?: boolean;
+	    hasActions?: boolean | 'custom';
 	    /**
-	     * Indicates if the column is dedicated as the expandable row toggle
+	     * Indicates if the row will have an expanded row
 	     */
-	    isExpander?: boolean;
+	    isExpandable?: boolean;
 	    /**
-	     * Mobile options for displaying differently at small screens;
-	     * See #EuiTableRowCellMobileOptionsShape
+	     * Indicates if the row will be the expanded row
 	     */
-	    mobileOptions?: EuiTableRowCellMobileOptionsShape;
-	} type Props = CommonProps & Omit<TdHTMLAttributes<HTMLTableCellElement>, 'valign'> & EuiTableRowCellProps;
-	export const EuiTableRowCell: FunctionComponent<Props>;
+	    isExpandedRow?: boolean;
+	    onClick?: MouseEventHandler<HTMLTableRowElement> & KeyboardEventHandler<HTMLTableRowElement>;
+	} type Props = CommonProps & HTMLAttributes<HTMLTableRowElement> & EuiTableRowProps;
+	export const EuiTableRow: FunctionComponent<Props>;
 	export {};
 
 }
@@ -5642,8 +5813,6 @@ declare module '@elastic/eui/src/components/table' {
 	export { EuiTableFooterCell } from '@elastic/eui/src/components/table/table_footer_cell';
 	export type { EuiTableHeaderProps } from '@elastic/eui/src/components/table/table_header';
 	export { EuiTableHeader } from '@elastic/eui/src/components/table/table_header';
-	export type { EuiTableHeaderButtonProps } from '@elastic/eui/src/components/table/table_header_button';
-	export { EuiTableHeaderButton } from '@elastic/eui/src/components/table/table_header_button';
 	export type { EuiTableHeaderCellProps } from '@elastic/eui/src/components/table/table_header_cell';
 	export { EuiTableHeaderCell } from '@elastic/eui/src/components/table/table_header_cell';
 	export type { EuiTableHeaderCellCheckboxProps } from '@elastic/eui/src/components/table/table_header_cell_checkbox';
@@ -5666,7 +5835,7 @@ declare module '@elastic/eui/src/components/provider/component_defaults/componen
 	import React, { FunctionComponent, PropsWithChildren } from 'react';
 	import type { EuiPortalProps } from '@elastic/eui/src/components/portal';
 	import type { EuiFocusTrapProps } from '@elastic/eui/src/components/focus_trap';
-	import type { EuiTablePaginationProps } from '@elastic/eui/src/components/table';
+	import type { EuiTablePaginationProps, EuiTableProps } from '@elastic/eui/src/components/table';
 	export type EuiComponentDefaults = {
 	    /**
 	     * Provide a global configuration for EuiPortal's default insertion position.
@@ -5683,6 +5852,12 @@ declare module '@elastic/eui/src/components/provider/component_defaults/componen
 	     * These defaults will be inherited all table and grid components that utilize EuiTablePagination.
 	     */
 	    EuiTablePagination?: Pick<EuiTablePaginationProps, 'itemsPerPage' | 'itemsPerPageOptions' | 'showPerPageOptions'>;
+	    /**
+	     * Provide a global configuration for EuiTable's `responsiveBreakpoint` prop. Defaults to `'s'`.
+	     *
+	     * Defaults will be inherited by all `EuiBasicTable`s and `EuiInMemoryTable`s.
+	     */
+	    EuiTable?: Pick<EuiTableProps, 'responsiveBreakpoint'>;
 	};
 	export const EuiComponentDefaultsContext: React.Context<EuiComponentDefaults>;
 	export type EuiComponentDefaultsProviderProps = PropsWithChildren & {
@@ -22464,7 +22639,7 @@ declare module '@elastic/eui/src/components/tour' {
 
 }
 declare module '@elastic/eui/src/components/basic_table/action_types' {
-	import { ReactElement, ReactNode } from 'react';
+	import { ReactElement, ReactNode, MouseEvent } from 'react';
 	import { EuiIconType } from '@elastic/eui/src/components/icon/icon';
 	import { EuiButtonIconProps } from '@elastic/eui/src/components/button/button_icon/button_icon';
 	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button/button_empty';
@@ -22479,9 +22654,11 @@ declare module '@elastic/eui/src/components/basic_table/action_types' {
 	     */
 	    description: string | ((item: T) => string);
 	    /**
-	     * A handler function to execute the action
+	     * A handler function to execute the action. Passes back the current row
+	     * item as the first argument, and the originating React click event
+	     * as a second argument.
 	     */
-	    onClick?: (item: T) => void;
+	    onClick?: (item: T, event: MouseEvent) => void;
 	    href?: string | ((item: T) => string);
 	    target?: string;
 	    /**
@@ -22492,8 +22669,21 @@ declare module '@elastic/eui/src/components/basic_table/action_types' {
 	     * A callback function that determines whether the action is enabled
 	     */
 	    enabled?: (item: T) => boolean;
-	    isPrimary?: boolean;
 	    'data-test-subj'?: string | ((item: T) => string);
+	    /**
+	     * If more than 3 actions are passed, 2 primary actions will show (on hover)
+	     * next to an expansion menu of all actions.
+	     *
+	     * On mobile, primary actions will be tucked away in the expansion menu for space.
+	     */
+	    isPrimary?: boolean;
+	    /**
+	     * Allows only showing the action on mouse hover or keyboard focus.
+	     * If more than 3 actions are passed, this will always be true for `isPrimary` actions.
+	     *
+	     * Has no effect on mobile, or if `hasActions` is not set.
+	     */
+	    showOnHover?: boolean;
 	}
 	export interface DefaultItemEmptyButtonAction<T extends object> extends DefaultItemActionBase<T> {
 	    /**
@@ -22514,7 +22704,7 @@ declare module '@elastic/eui/src/components/basic_table/action_types' {
 	    color?: EuiButtonIconProps['color'] | EuiButtonIconColorFunction<T>;
 	}
 	export type DefaultItemAction<T extends object> = ExclusiveUnion<DefaultItemEmptyButtonAction<T>, DefaultItemIconButtonAction<T>>;
-	export interface CustomItemAction<T> {
+	export type CustomItemAction<T> = {
 	    /**
 	     * Allows rendering a totally custom action
 	     */
@@ -22527,8 +22717,7 @@ declare module '@elastic/eui/src/components/basic_table/action_types' {
 	     * A callback that defines whether the action is enabled
 	     */
 	    enabled?: (item: T) => boolean;
-	    isPrimary?: boolean;
-	}
+	} & Pick<DefaultItemActionBase<{}>, 'isPrimary' | 'showOnHover'>;
 	export type Action<T extends object> = DefaultItemAction<T> | CustomItemAction<T>;
 	export const isCustomItemAction: <T extends object>(action: (import ("@elastic/eui/src/components/common").DisambiguateSet<DefaultItemEmptyButtonAction<T>, DefaultItemIconButtonAction<T>> & DefaultItemIconButtonAction<T>) | (import ("@elastic/eui/src/components/common").DisambiguateSet<DefaultItemIconButtonAction<T>, DefaultItemEmptyButtonAction<T>> & DefaultItemEmptyButtonAction<T>) | CustomItemAction<T>) => action is CustomItemAction<T>;
 	export const callWithItemIfFunction: <T>(item: T) => <U>(prop: U | ((item: T) => U)) => U;
@@ -22596,7 +22785,7 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	    items: T[];
 	    pagination?: Pagination;
 	}
-	export interface EuiTableFieldDataColumnType<T> extends CommonProps, TdHTMLAttributes<HTMLTableDataCellElement> {
+	export interface EuiTableFieldDataColumnType<T> extends CommonProps, Omit<TdHTMLAttributes<HTMLTableCellElement>, 'width' | 'align'> {
 	    /**
 	     * A field of the item (may be a nested field)
 	     */
@@ -22621,16 +22810,22 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	     * Defines whether the user can sort on this column. If a function is provided, this function returns the value to sort against
 	     */
 	    sortable?: boolean | ((item: T) => Primitive);
-	    isExpander?: boolean;
 	    /**
-	     * Creates a text wrapper around cell content that helps word break or truncate
-	     * long text correctly.
+	     * Disables the user's ability to change the sort, but will still
+	     * show the current sort direction in the column header
 	     */
-	    textOnly?: boolean;
+	    readOnly?: boolean;
 	    /**
 	     * Defines the horizontal alignment of the column
+	     * @default left
 	     */
 	    align?: HorizontalAlignment;
+	    /**
+	     * Creates a text wrapper around cell content that helps word break or truncate
+	     * long text correctly.
+	     * @default true
+	     */
+	    textOnly?: boolean;
 	    /**
 	     * Indicates whether this column should truncate overflowing text content.
 	     * - Set to `true` to enable single-line truncation.
@@ -22638,6 +22833,10 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	     * set to a number of lines to truncate to.
 	     */
 	    truncateText?: EuiTableRowCellProps['truncateText'];
+	    /**
+	     * Allows configuring custom render options or appearances for column cells
+	     * when the table responsively collapses into a mobile-friendly view
+	     */
 	    mobileOptions?: Omit<EuiTableRowCellMobileOptionsShape, 'render'> & {
 	        render?: (item: T) => ReactNode;
 	    };
@@ -22650,11 +22849,12 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	     */
 	    footer?: string | ReactElement | ((props: EuiTableFooterProps<T>) => ReactNode);
 	    /**
-	     * Disables the user's ability to change the sort but still shows the current direction
+	     * If passing `itemIdToExpandedRowMap` to your table, set this flag to `true`
+	     * for the custom column or cell used to toggle the expanded row.
 	     */
-	    readOnly?: boolean;
+	    isExpander?: boolean;
 	}
-	export interface EuiTableComputedColumnType<T> extends CommonProps, TdHTMLAttributes<HTMLTableDataCellElement> {
+	export type EuiTableComputedColumnType<T> = CommonProps & Omit<TdHTMLAttributes<HTMLTableCellElement>, 'width' | 'align'> & {
 	    /**
 	     * A function that computes the value for each item and renders it
 	     */
@@ -22663,30 +22863,12 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	     * The display name of the column
 	     */
 	    name?: ReactNode;
-	    /**
-	     * A description of the column (will be presented as a title over the column header
-	     */
-	    description?: string;
 	    /**
 	     * If provided, allows this column to be sorted on. Must return the value to sort against.
 	     */
 	    sortable?: (item: T) => Primitive;
-	    /**
-	     * A CSS width property. Hints for the required width of the column
-	     */
-	    width?: string;
-	    /**
-	     * Indicates whether this column should truncate its content when it doesn't fit
-	     */
-	    truncateText?: boolean;
-	    isExpander?: boolean;
-	    align?: HorizontalAlignment;
-	    /**
-	     * Disables the user's ability to change the sort but still shows the current direction
-	     */
-	    readOnly?: boolean;
-	}
-	export interface EuiTableActionsColumnType<T extends object> {
+	} & Pick<EuiTableFieldDataColumnType<T>, 'readOnly' | 'description' | 'width' | 'align' | 'truncateText' | 'isExpander'>;
+	export type EuiTableActionsColumnType<T extends object> = {
 	    /**
 	     * An array of one of the objects: #DefaultItemAction or #CustomItemAction
 	     */
@@ -22695,15 +22877,7 @@ declare module '@elastic/eui/src/components/basic_table/table_types' {
 	     * The display name of the column
 	     */
 	    name?: ReactNode;
-	    /**
-	     * A description of the column (will be presented as a title over the column header
-	     */
-	    description?: string;
-	    /**
-	     * A CSS width property. Hints for the required width of the column
-	     */
-	    width?: string;
-	}
+	} & Pick<EuiTableFieldDataColumnType<T>, 'description' | 'width'>;
 	export interface EuiTableSortingType<T> {
 	    /**
 	     * Indicates the property/field to sort on
@@ -22812,8 +22986,7 @@ declare module '@elastic/eui/src/components/basic_table/expanded_item_actions' {
 declare module '@elastic/eui/src/components/basic_table/basic_table.styles' {
 	import { UseEuiTheme } from '@elastic/eui/src/services';
 	export const euiBasicTableBodyLoading: ({ euiTheme }: UseEuiTheme) => import("@emotion/utils").SerializedStyles;
-	export const safariLoadingWorkaround: () => import("@emotion/utils").SerializedStyles;
-	export const euiBasicTableActionsWrapper: import("@emotion/utils").SerializedStyles;
+	export const safariLoadingWorkaround: import("@emotion/utils").SerializedStyles;
 
 }
 declare module '@elastic/eui/src/components/basic_table/basic_table' {
@@ -22886,9 +23059,6 @@ declare module '@elastic/eui/src/components/basic_table/basic_table' {
 	     * Indicates which column should be used as the identifying cell in each row. Should match a "field" prop in FieldDataColumn
 	     */
 	    rowHeader?: string;
-	    hasActions?: boolean;
-	    isExpandable?: boolean;
-	    isSelectable?: boolean;
 	    /**
 	     * Provides an infinite loading indicator
 	     */
@@ -22905,10 +23075,6 @@ declare module '@elastic/eui/src/components/basic_table/basic_table' {
 	     * Configures #Pagination
 	     */
 	    pagination?: undefined;
-	    /**
-	     * If true, will convert table to cards in mobile view
-	     */
-	    responsive?: boolean;
 	    /**
 	     * Applied to `EuiTableRow`
 	     */
@@ -22925,13 +23091,6 @@ declare module '@elastic/eui/src/components/basic_table/basic_table' {
 	     * Sets the table-layout CSS property. Note that auto tableLayout prevents truncateText from working properly.
 	     */
 	    tableLayout?: 'fixed' | 'auto';
-	    /**
-	     * Applied to table cells. Any cell using a render function will set this to be false.
-	     *
-	     * Creates a text wrapper around cell content that helps word break or truncate
-	     * long text correctly.
-	     */
-	    textOnly?: boolean;
 	} type BasicTableWithPaginationProps<T extends object> = Omit<BasicTableProps<T>, 'pagination' | 'onChange'> & {
 	    pagination: Pagination;
 	    onChange?: (criteria: CriteriaWithPagination<T>) => void;
@@ -22945,7 +23104,6 @@ declare module '@elastic/eui/src/components/basic_table/basic_table' {
 	    static contextType: React.Context<import ("@elastic/eui/src/components/provider/component_defaults").EuiComponentDefaults>;
 	    context: ContextType<typeof EuiComponentDefaultsContext>;
 	    static defaultProps: {
-	        responsive: boolean;
 	        tableLayout: string;
 	        noItemsMessage: React.JSX.Element;
 	    };
@@ -22977,8 +23135,8 @@ declare module '@elastic/eui/src/components/basic_table/basic_table' {
 	    renderErrorMessage(error: string): React.JSX.Element;
 	    renderEmptyMessage(): React.JSX.Element;
 	    renderItemRow(item: T, rowIndex: number): React.JSX.Element;
-	    renderItemSelectionCell(itemId: ItemId<T>, item: T, selected: boolean): React.JSX.Element;
-	    renderItemActionsCell(itemId: ItemIdResolved, item: T, column: EuiTableActionsColumnType<T>, columnIndex: number): React.JSX.Element;
+	    renderItemSelectionCell(itemId: ItemId<T>, item: T, selected: boolean): (boolean | React.JSX.Element | undefined)[];
+	    renderItemActionsCell(itemId: ItemIdResolved, item: T, column: EuiTableActionsColumnType<T>, columnIndex: number, hasCustomActions: boolean): React.JSX.Element;
 	    renderItemFieldDataCell(itemId: ItemId<T>, item: T, column: EuiTableFieldDataColumnType<T>, columnIndex: number, setScopeRow: boolean): React.JSX.Element;
 	    renderItemComputedCell(itemId: ItemId<T>, item: T, column: EuiTableComputedColumnType<T>, columnIndex: number): React.JSX.Element;
 	    renderItemCell(item: T, column: EuiBasicTableColumn<T>, key: string | number, content: ReactNode, setScopeRow: boolean): React.JSX.Element;
@@ -23094,7 +23252,6 @@ declare module '@elastic/eui/src/components/basic_table/in_memory_table' {
 	export class EuiInMemoryTable<T extends object = object> extends Component<EuiInMemoryTableProps<T>, State<T>> {
 	    static contextType: React.Context<EuiComponentDefaults>;
 	    static defaultProps: {
-	        responsive: boolean;
 	        tableLayout: string;
 	        searchFormat: string;
 	    };