declare module '@elastic/eui/src/services/keys' {
	export const ENTER = "Enter";
	export const SPACE = " ";
	export const ESCAPE = "Escape";
	export const TAB = "Tab";
	export const BACKSPACE = "Backspace";
	export const F2 = "F2";
	export const ALT = "Alt";
	export const SHIFT = "Shift";
	export const CTRL = "Control";
	export const META = "Meta";
	export const ARROW_DOWN = "ArrowDown";
	export const ARROW_UP = "ArrowUp";
	export const ARROW_LEFT = "ArrowLeft";
	export const ARROW_RIGHT = "ArrowRight";
	export const PAGE_UP = "PageUp";
	export const PAGE_DOWN = "PageDown";
	export const END = "End";
	export const HOME = "Home";
	export enum keys {
	    ENTER = "Enter",
	    SPACE = " ",
	    ESCAPE = "Escape",
	    TAB = "Tab",
	    BACKSPACE = "Backspace",
	    F2 = "F2",
	    ALT = "Alt",
	    SHIFT = "Shift",
	    CTRL = "Control",
	    META = "Meta",// Windows, Command, Option
	    ARROW_DOWN = "ArrowDown",
	    ARROW_UP = "ArrowUp",
	    ARROW_LEFT = "ArrowLeft",
	    ARROW_RIGHT = "ArrowRight",
	    PAGE_UP = "PageUp",
	    PAGE_DOWN = "PageDown",
	    END = "End",
	    HOME = "Home"
	}

}
declare module '@elastic/eui/src/services/accessibility/html_id_generator' {
	/**
	 * This function returns a function to generate ids.
	 * This can be used to generate unique, but predictable ids to pair labels
	 * with their inputs. It takes an optional prefix as a parameter. If you don't
	 * specify it, it generates a random id prefix. If you specify a custom prefix
	 * it should begin with an letter to be HTML4 compliant.
	 */
	export function htmlIdGenerator(idPrefix?: string): (idSuffix?: string) => string;
	/**
	 * Generates a memoized ID that remains static until component unmount.
	 * This prevents IDs from being re-randomized on every component update.
	 */
	export type UseGeneratedHtmlIdOptions = {
	    /**
	     * Optional prefix to prepend to the generated ID
	     */
	    prefix?: string;
	    /**
	     * Optional suffix to append to the generated ID
	     */
	    suffix?: string;
	    /**
	     * Optional conditional ID to use instead of a randomly generated ID.
	     * Typically used by EUI components where IDs can be passed in as custom props
	     */
	    conditionalId?: string;
	};
	export const useGeneratedHtmlId: ({ prefix, suffix, conditionalId, }?: UseGeneratedHtmlIdOptions) => string;

}
declare module '@elastic/eui/src/services/accessibility' {
	export { htmlIdGenerator, useGeneratedHtmlId } from '@elastic/eui/src/services/accessibility/html_id_generator';

}
declare module '@elastic/eui/src/services/alignment' {
	export const LEFT_ALIGNMENT = "left";
	export const RIGHT_ALIGNMENT = "right";
	export const CENTER_ALIGNMENT = "center";
	export type HorizontalAlignment = 'left' | 'right' | 'center';

}
declare module '@elastic/eui/src/global_styling/variables/breakpoint' {
	export { EuiThemeBreakpoints, type _EuiThemeBreakpoint, type _EuiThemeBreakpoints, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/components/common' {
	import { AnchorHTMLAttributes, ButtonHTMLAttributes, ComponentProps, Component, FunctionComponent, JSXElementConstructor, MouseEventHandler, JSX } from 'react';
	import { Interpolation, Theme } from '@emotion/react';
	export type { RecursivePartial, ValueOf } from '@elastic/eui-theme-common';
	export interface CommonProps {
	    className?: string;
	    'aria-label'?: string;
	    'data-test-subj'?: string;
	    css?: Interpolation<Theme>;
	}
	export interface DataAttributeProps {
	    [key: `data-${string}`]: string | undefined;
	}
	export type NoArgCallback<T> = () => T;
	export const assertNever: (x: never) => never;
	/**
	 * XOR for some properties applied to a type
	 * (XOR is one of these but not both or neither)
	 *
	 * Usage: OneOf<typeToExtend, one | but | not | multiple | of | these | are | required>
	 *
	 * To require aria-label or aria-labelledby but not both
	 * Example: OneOf<Type, 'aria-label' | 'aria-labelledby'>
	 */
	export type OneOf<T, K extends keyof T> = Omit<T, K> & {
	    [k in K]: Pick<Required<T>, k> & {
	        [k1 in Exclude<K, k>]?: never;
	    };
	}[K];
	/**
	 * Wraps Object.keys with proper typescript definition of the resulting array
	 */
	export function keysOf<T extends object, K extends keyof T>(obj: T): K[];
	export type PropsOf<C> = C extends FunctionComponent<infer SFCProps> ? SFCProps : C extends FunctionComponent<infer FunctionProps> ? FunctionProps : C extends Component<infer ComponentProps> ? ComponentProps : never;
	export type PropsOfElement<C extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>> = JSX.LibraryManagedAttributes<C, ComponentProps<C>>;
	type ExtractDefaultProps<T> = T extends {
	    defaultProps: infer D;
	} ? D : never;
	type ExtractProps<C extends new (...args: any) => any, IT = InstanceType<C>> = IT extends Component<infer P> ? P : never;
	/**
	 * Because of how TypeScript's LibraryManagedAttributes is designed to handle defaultProps (https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#support-for-defaultprops-in-jsx)
	 * we can't directly export the props definition as the defaulted values are not made optional,
	 * because it isn't processed by LibraryManagedAttributes. To get around this, we:
	 * - remove the props which have default values applied
	 * - export (Props - Defaults) & Partial<Defaults>
	 */
	export type ApplyClassComponentDefaults<C extends new (...args: any) => any, D = ExtractDefaultProps<C>, P = ExtractProps<C>> = Omit<P, keyof D> & {
	    [K in keyof D]?: K extends keyof P ? P[K] : never;
	};
	type UnionKeys<T> = T extends any ? keyof T : never;
	export type DistributivePick<T, K extends UnionKeys<T>> = T extends any ? Pick<T, Extract<keyof T, K>> : never;
	export type DistributiveOmit<T, K extends UnionKeys<T>> = T extends any ? Omit<T, Extract<keyof T, K>> : never;
	type RecursiveDistributiveOmit<T, K extends PropertyKey> = T extends any ? T extends object ? RecursiveOmit<T, K> : T : never;
	export type RecursiveOmit<T, K extends PropertyKey> = Omit<{
	    [P in keyof T]: RecursiveDistributiveOmit<T[P], K>;
	}, K>;
	/**
	 * Returns member keys in U not present in T set to never
	 * T = { 'one', 'two', 'three' }
	 * U = { 'three', 'four', 'five' }
	 * returns { 'four': never, 'five': never }
	 */
	export type DisambiguateSet<T, U> = {
	    [P in Exclude<keyof T, keyof U>]?: never;
	};
	/**
	 * Allow either T or U, preventing any additional keys of the other type from being present
	 */
	export type ExclusiveUnion<T, U> = T | U extends object ? (DisambiguateSet<T, U> & U) | (DisambiguateSet<U, T> & T) : T | U;
	/**
	 * For components that conditionally render <button> or <a>
	 * Convenience types for extending base props (T) and
	 * element-specific props (P) with standard clickable properties
	 *
	 * These will likely be used together, along with `ExclusiveUnion`:
	 *
	 * type AnchorLike = PropsForAnchor<BaseProps>
	 * type ButtonLike = PropsForButton<BaseProps>
	 * type ComponentProps = ExclusiveUnion<AnchorLike, ButtonLike>
	 * const Component: FunctionComponent<ComponentProps> ...
	 */
	export type PropsForAnchor<T, P = {}> = T & {
	    href?: string;
	    onClick?: MouseEventHandler<HTMLAnchorElement>;
	} & AnchorHTMLAttributes<HTMLAnchorElement> & P;
	export type PropsForButton<T, P = {}> = T & {
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	} & ButtonHTMLAttributes<HTMLButtonElement> & P;

}
declare module '@elastic/eui/src/services/theme/types' {
	export { COLOR_MODES_STANDARD, COLOR_MODES_INVERSE, type EuiThemeColorModeInverse, type EuiThemeColorModeStandard, type EuiThemeColorMode, type ColorModeSwitch, type StrictColorModeSwitch, type EuiThemeShape, type EuiThemeSystem, type EuiThemeModifications, type ComputedThemeShape, type EuiThemeComputed, type EuiThemeNested, type EuiThemeHighContrastMode, type EuiThemeHighContrastModeProp, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/services/theme/utils' {
	export { DEFAULT_COLOR_MODE, isInverseColorMode, getColorMode, getOn, setOn, Computed, computed, getComputed, buildTheme, mergeDeep, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/services/theme/context' {
	import { EuiThemeColorModeStandard, EuiThemeHighContrastMode, EuiThemeSystem, EuiThemeComputed, EuiThemeNested } from '@elastic/eui/src/services/theme/types';
	export const DEFAULTS: {
	    system: {
	        model: import("@elastic/eui-theme-common/lib/cjs/services/theme/types").EuiThemeShape;
	        root: import("@elastic/eui-theme-common/lib/cjs/services/theme/types").EuiThemeShape;
	        key: string;
	    };
	    modifications: {};
	    colorMode: "LIGHT";
	    highContrastMode: false;
	};
	export const EuiSystemContext: import("react").Context<EuiThemeSystem>;
	export const EuiModificationsContext: import("react").Context<import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common").EuiThemeShapeBase & {
	    overrides?: import("@elastic/eui-theme-common")._EuiThemeOverrides;
	}>>;
	export const EuiColorModeContext: import("react").Context<EuiThemeColorModeStandard>;
	export const EuiHighContrastModeContext: import("react").Context<EuiThemeHighContrastMode>;
	export const defaultComputedTheme: EuiThemeComputed<import("@elastic/eui-theme-common/lib/cjs/services/theme/types").EuiThemeShape>;
	export const EuiThemeContext: import("react").Context<EuiThemeComputed>;
	export const EuiNestedThemeContext: import("react").Context<EuiThemeNested>;

}
declare module '@elastic/eui/src/services/theme/warning' {
	type LEVELS = 'log' | 'warn' | 'error';
	type ProviderCallback = (message: string | Error) => void; let providerWarning: LEVELS | ProviderCallback | undefined;
	export const setEuiDevProviderWarning: (warningType: typeof providerWarning) => LEVELS | ProviderCallback | undefined;
	export const getEuiDevProviderWarning: () => LEVELS | ProviderCallback | undefined;
	export const emitEuiProviderWarning: (providerMessage: string) => void;
	export {};

}
declare module '@elastic/eui/src/services/theme/hooks' {
	import React from 'react';
	import { type EuiThemeColorModeStandard, type EuiThemeHighContrastMode, type EuiThemeModifications, type EuiThemeComputed } from '@elastic/eui-theme-common';
	/**
	 * Hook for function components
	 */
	export interface UseEuiTheme<T extends {} = {}> {
	    euiTheme: EuiThemeComputed<T>;
	    colorMode: EuiThemeColorModeStandard;
	    highContrastMode: EuiThemeHighContrastMode;
	    modifications: EuiThemeModifications<T>;
	}
	export const useEuiTheme: <T extends {} = {}>() => UseEuiTheme<T>;
	/**
	 * HOC for class components
	 */
	export interface WithEuiThemeProps<P extends {} = {}> {
	    theme: UseEuiTheme<P>;
	}
	export const withEuiTheme: <T extends {} = {}, U extends {} = {}>(Component: React.ComponentType<T & WithEuiThemeProps<U>>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<Omit<T, "theme">> & React.RefAttributes<Omit<T, "theme">>>;
	/**
	 * Render prop alternative for complex class components
	 * Most useful for scenarios where a HOC may interfere with typing
	 */
	export const RenderWithEuiTheme: <T extends {} = {}>({ children, }: {
	    children: (theme: UseEuiTheme) => React.ReactElement;
	}) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
	/**
	 * Minor syntactical sugar hook for theme CSS variables.
	 * Primarily meant for internal EUI usage.
	 */
	export const useEuiThemeCSSVariables: () => {
	    setGlobalCSSVariables: Function;
	    globalCSSVariables: import("@emotion/serialize").CSSObject | undefined;
	    setNearestThemeCSSVariables: Function;
	    themeCSSVariables: import("@emotion/serialize").CSSObject | undefined;
	};
	/**
	 * Checks whether the current active `colorMode` is set to `DARK`;
	 * In case of nested providers this returns the value of the nearest provider context.
	 */
	export const useIsDarkMode: () => boolean;

}
declare module '@elastic/eui/src/services/throttle' {
	export const throttle: (fn: (...args: any[]) => void, wait?: number) => (...args: any[]) => void;

}
declare module '@elastic/eui/src/services/breakpoint/_sorting' {
	import { _EuiThemeBreakpoints } from '@elastic/eui/src/global_styling/variables/breakpoint';
	export const sortMapByLargeToSmallValues: (breakpointsMap: _EuiThemeBreakpoints) => _EuiThemeBreakpoints;
	export const sortMapBySmallToLargeValues: (breakpointsMap: _EuiThemeBreakpoints) => _EuiThemeBreakpoints;

}
declare module '@elastic/eui/src/services/breakpoint/current_breakpoint' {
	import React, { FunctionComponent, PropsWithChildren } from 'react';
	import { _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling/variables/breakpoint';
	type CurrentEuiBreakpoint = _EuiThemeBreakpoint | undefined;
	export const CurrentEuiBreakpointContext: React.Context<CurrentEuiBreakpoint>;
	/**
	 * Returns the current breakpoint based on window width.
	 * Typically only called by the top-level `EuiProvider` (to reduce the number
	 * of window resize listeners on the page). Also conditionally called if a
	 * nested `EuiThemeProvider` defines a `modify.breakpoint` override
	 */
	export const CurrentEuiBreakpointProvider: FunctionComponent<PropsWithChildren>;
	export {};

}
declare module '@elastic/eui/src/services/breakpoint/current_breakpoint_hook' {
	/**
	 * Hook util / syntactical sugar for useContext()
	 *
	 * This hook is in its own separate file to make mocking it
	 * as a testenv easy for Jest unit tests
	 */
	export const useCurrentEuiBreakpoint: () => string | undefined;

}
declare module '@elastic/eui/src/services/emotion/clone_element' {
	import React from 'react';
	/**
	 * React.cloneElement does not work if the cloned element does not already have the
	 * `css` prop - as a result, we need to use `jsx()` to manually clone the element
	 * See https://github.com/emotion-js/emotion/issues/1404
	 */
	export const cloneElementWithCss: (element: any, props: any, cssOrder?: "before" | "after") => React.ReactElement;

}
declare module '@elastic/eui/src/services/emotion/prefixer' {
	import { type Element } from 'stylis';
	/**
	 * This is a stylis plugin which handles auto-prefixing CSS output by Emotion.
	 *
	 * *Please note*: EUI/Elastic targets latest evergreen browsers for support only.
	 * @see https://www.elastic.co/support/matrix#matrix_browsers
	 */
	export const euiStylisPrefixer: (element: Element) => void;

}
declare module '@elastic/eui/src/services/emotion' {
	export * from '@elastic/eui/src/services/emotion/clone_element';
	export * from '@elastic/eui/src/services/emotion/prefixer';

}
declare module '@elastic/eui/src/services/emotion/css' {
	/**
	 * This custom instance is needed for internal EUI components to call
	 * `@emotion/css` with EUI's custom prefixer plugin
	 * @see https://emotion.sh/docs/@emotion/css#custom-instances
	 *
	 * NOTE: Usage is currently being beta tested internally,
	 * and is not yet intended to be a public export
	 */
	export const css: {
	    (template: TemplateStringsArray, ...args: Array<import("@emotion/serialize").CSSInterpolation>): string;
	    (...args: Array<import("@emotion/serialize").CSSInterpolation>): string;
	}, cx: (...classNames: Array<import("@emotion/css/create-instance").ClassNamesArg>) => string, cache: import("@emotion/css/create-instance").EmotionCache;

}
declare module '@elastic/eui/src/services/theme/emotion' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	/**
	 * @see https://emotion.sh/docs/theming
	 * This Emotion theme provider is added for *consumer usage* & convenience only.
	 *
	 * EUI should stick to using our own context/`useEuiTheme` internally
	 * instead of Emotion's shorthand `css={theme => {}}` API. If consumers
	 * set their own theme via <ThemeProvider>; EUI's styles should continue
	 * working as-is.
	 */
	export const EuiEmotionThemeProvider: FunctionComponent<PropsWithChildren<{}>>;

}
declare module '@elastic/eui/src/services/hooks/useUpdateEffect' {
	export const useUpdateEffect: (effect: Function, deps: unknown[]) => void;

}
declare module '@elastic/eui/src/services/hooks/useDependentState' {
	export function useDependentState<T>(valueFn: (previousState: undefined | T) => T, deps: unknown[]): readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>];

}
declare module '@elastic/eui/src/services/hooks/useCombinedRefs' {
	import { MutableRefObject, Ref } from 'react';
	type Refs<T> = Array<Ref<T> | MutableRefObject<T | undefined> | undefined>;
	export const useCombinedRefs: <T>(refs: Refs<T>) => (node: T) => void;
	/**
	 * Non-hook util for setting multiple refs/ref types.
	 * Useful for non-functional components
	 */
	export const setMultipleRefs: <T>(refs: Refs<T>, node: T) => void;
	export {};

}
declare module '@elastic/eui/src/services/hooks/useForceRender' {
	export const useForceRender: () => () => void;

}
declare module '@elastic/eui/src/services/hooks/useLatest' {
	import { MutableRefObject } from 'react';
	/**
	 * Wraps the given `value` into a `MutableRefObject` and keeps the `current`
	 * value up-to-date on every render cycle.
	 */
	export function useLatest<Value>(value: Value): MutableRefObject<Value | null>;

}
declare module '@elastic/eui/src/services/hooks/useDeepEqual' {
	/**
	 * This hook is mostly a performance concern for third-party objs/arrays that EUI
	 * has no control over and may not be correctly memoized (i.e., will create a new
	 * reference on every rerender unless passed through this hook).
	 */
	export const useDeepEqual: <T = Record<string, any> | any[] | undefined>(object: T) => T;

}
declare module '@elastic/eui/src/services/hooks/useMouseMove' {
	import { MouseEvent, TouchEvent } from 'react';
	export function isMouseEvent<T = HTMLDivElement>(event: MouseEvent<T> | TouchEvent<T>): event is MouseEvent<T>;
	export function useMouseMove<T = HTMLDivElement>(handleChange: (location: {
	    x: number;
	    y: number;
	}, isFirstInteraction?: boolean) => void, interactionConditional?: any): [
	    (e: MouseEvent<T>) => void,
	    (e: MouseEvent<T> | TouchEvent<T>, isFirstInteraction?: boolean) => void
	];

}
declare module '@elastic/eui/src/services/hooks/useIsPointerDown' {
	import { type MutableRefObject } from 'react';
	/**
	 * A hook that tracks whether the pointer is currently down/pressed.
	 * Useful for detecting text selection in progress.
	 */
	export function useIsPointerDown(container?: MutableRefObject<HTMLElement | null>): MutableRefObject<boolean>;

}
declare module '@elastic/eui/src/services/hooks/useEuiDisabledElement' {
	export type EuiDisabledProps = {
	    /**
	     * Controls the disabled behavior via the native `disabled` attribute.
	     */
	    isDisabled?: boolean;
	    /**
	     * NOTE: Beta feature, may be changed or removed in the future
	     *
	     * Changes the native `disabled` attribute to `aria-disabled` to preserve focusability.
	     * This results in a semantically disabled button without the default browser handling of the disabled state.
	     *
	     * Use e.g. when a disabled button should have a tooltip.
	     */
	    hasAriaDisabled?: boolean;
	};
	type DisabledElementKeyEventHandlers = {
	    onKeyDown?: React.KeyboardEventHandler<HTMLElement>;
	    onKeyUp?: React.KeyboardEventHandler<HTMLElement>;
	    onKeyPress?: React.KeyboardEventHandler<HTMLElement>;
	};
	export type DisabledElementEventHandlers = DisabledElementKeyEventHandlers & {
	    onClick?: React.MouseEventHandler<HTMLElement>;
	    onMouseDown?: React.MouseEventHandler<HTMLElement>;
	    onMouseUp?: React.MouseEventHandler<HTMLElement>;
	    onMouseEnter?: React.MouseEventHandler<HTMLElement>;
	    onMouseLeave?: React.MouseEventHandler<HTMLElement>;
	    onMouseOut?: React.MouseEventHandler<HTMLElement>;
	    onMouseMove?: React.MouseEventHandler<HTMLElement>;
	    onMouseOver?: React.MouseEventHandler<HTMLElement>;
	    onPointerDown?: React.PointerEventHandler<HTMLElement>;
	    onPointerUp?: React.PointerEventHandler<HTMLElement>;
	    onPointerEnter?: React.PointerEventHandler<HTMLElement>;
	    onPointerLeave?: React.PointerEventHandler<HTMLElement>;
	    onPointerMove?: React.PointerEventHandler<HTMLElement>;
	    onPointerOver?: React.PointerEventHandler<HTMLElement>;
	    onTouchStart?: React.TouchEventHandler<HTMLElement>;
	    onTouchEnd?: React.TouchEventHandler<HTMLElement>;
	    onTouchMove?: React.TouchEventHandler<HTMLElement>;
	    onSubmit?: React.FormEventHandler<HTMLElement>;
	};
	type DisabledElementProps<T extends HTMLElement> = {
	    ref: React.Ref<T>;
	    disabled?: boolean;
	};
	type AriaDisabledElementProps<T extends HTMLElement> = DisabledElementEventHandlers & DisabledElementProps<T> & {
	    ref: React.Ref<T>;
	    'aria-disabled'?: boolean;
	};
	type EuiDisabledElementArgs = EuiDisabledProps & DisabledElementKeyEventHandlers;
	/**
	 * NOTE: Beta feature, may be changed or removed in the future
	 *
	 * Utility to apply either the native or a custom semantic disabled state.
	 *
	 * It applies `aria-disabled` instead of `disabled`  when `hasAriaDisabled=true`
	 * to ensure the element is semantically disabled while still focusable.
	 *
	 * It mimics the native `disabled` behavior by removing any programmatic mouse, pointer, touch
	 * or keyboard event handler but it differs to the native `disabled` behavior in that it preserves
	 * the focus, blur and tabIndex behavior.
	 */
	export const useEuiDisabledElement: <T extends HTMLElement>({ isDisabled, hasAriaDisabled, onKeyDown, onKeyUp, onKeyPress, }: EuiDisabledElementArgs) => DisabledElementProps<T> | AriaDisabledElementProps<T>;
	export {};

}
declare module '@elastic/eui/src/services/hooks' {
	export { useDependentState } from '@elastic/eui/src/services/hooks/useDependentState';
	export { useCombinedRefs, setMultipleRefs } from '@elastic/eui/src/services/hooks/useCombinedRefs';
	export { useForceRender } from '@elastic/eui/src/services/hooks/useForceRender';
	export { useLatest } from '@elastic/eui/src/services/hooks/useLatest';
	export { useDeepEqual } from '@elastic/eui/src/services/hooks/useDeepEqual';
	export { isMouseEvent, useMouseMove } from '@elastic/eui/src/services/hooks/useMouseMove';
	export { useIsPointerDown } from '@elastic/eui/src/services/hooks/useIsPointerDown';
	export { useUpdateEffect } from '@elastic/eui/src/services/hooks/useUpdateEffect';
	export { type EuiDisabledProps, useEuiDisabledElement, } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';

}
declare module '@elastic/eui/src/services/theme/style_memoization' {
	import React, { FunctionComponent, PropsWithChildren } from 'react';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme/hooks';
	type StylesMap = Record<string, any>;
	type MemoizedStylesMap = WeakMap<Function, StylesMap>;
	export const EuiThemeMemoizedStylesContext: React.Context<MemoizedStylesMap>;
	export const EuiThemeMemoizedStylesProvider: FunctionComponent<PropsWithChildren>;
	/**
	 * Hook that memoizes the returned values of components style fns/generators
	 * per-theme
	 */
	export const useEuiMemoizedStyles: <T extends (theme: UseEuiTheme) => StylesMap>(stylesGenerator: T) => ReturnType<T>;
	/**
	 * HOC for class components
	 * Syntax is mostly copied from withEuiTheme HOC
	 */
	export interface WithEuiStylesMemoizerProps {
	    stylesMemoizer: typeof useEuiMemoizedStyles;
	}
	export const withEuiStylesMemoizer: <T extends {} = {}>(Component: React.ComponentType<T & WithEuiStylesMemoizerProps>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<Omit<T, "stylesMemoizer">> & React.RefAttributes<Omit<T, "stylesMemoizer">>>;
	/**
	 * Render prop alternative for complex class components
	 * Most useful for scenarios where a HOC may interfere with typing
	 */
	export const RenderWithEuiStylesMemoizer: ({ children, }: {
	    children: (stylesMemoizer: typeof useEuiMemoizedStyles) => React.ReactElement;
	}) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
	export {};

}
declare module '@elastic/eui/src/services/theme/high_contrast_overrides' {
	import type { EuiThemeHighContrastMode, EuiThemeColorModeStandard, EuiThemeSystem, EuiThemeModifications } from '@elastic/eui/src/services/theme/types';
	export const useHighContrastModifications: ({ highContrastMode, colorMode, system, modifications, }: {
	    highContrastMode: EuiThemeHighContrastMode;
	    colorMode: EuiThemeColorModeStandard;
	    system: EuiThemeSystem;
	    modifications: EuiThemeModifications;
	}) => import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common").EuiThemeShapeBase & {
	    overrides?: import("@elastic/eui-theme-common")._EuiThemeOverrides;
	}> | {
	    colors: {
	        LIGHT: {
	            borderBasePrimary: string;
	            borderBaseAccent: string;
	            borderBaseAccentSecondary: string;
	            borderBaseNeutral: string;
	            borderBaseSuccess: string;
	            borderBaseWarning: string;
	            borderBaseRisk: string;
	            borderBaseDanger: string;
	            borderBasePlain: string;
	            borderBaseSubdued: string;
	            borderBaseProminent: string;
	            borderBaseDisabled: string;
	            borderBaseFloating: string;
	            borderStrongPrimary: string;
	            borderStrongAccent: string;
	            borderStrongAccentSecondary: string;
	            borderStrongNeutral: string;
	            borderStrongSuccess: string;
	            borderStrongWarning: string;
	            borderStrongRisk: string;
	            borderStrongDanger: string;
	        };
	        DARK: {
	            borderBasePrimary: string;
	            borderBaseAccent: string;
	            borderBaseAccentSecondary: string;
	            borderBaseNeutral: string;
	            borderBaseSuccess: string;
	            borderBaseWarning: string;
	            borderBaseRisk: string;
	            borderBaseDanger: string;
	            borderBasePlain: string;
	            borderBaseSubdued: string;
	            borderBaseProminent: string;
	            borderBaseDisabled: string;
	            borderBaseFloating: string;
	            borderStrongPrimary: string;
	            borderStrongAccent: string;
	            borderStrongAccentSecondary: string;
	            borderStrongNeutral: string;
	            borderStrongSuccess: string;
	            borderStrongWarning: string;
	            borderStrongRisk: string;
	            borderStrongDanger: string;
	        };
	    };
	    border: {
	        color: string;
	        thin: string;
	        thick: string;
	    };
	    base?: number | undefined;
	    size?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeSizes> | undefined;
	    font?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeFont> | undefined;
	    focus?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeFocus> | undefined;
	    animation?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeAnimation> | undefined;
	    breakpoint?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeBreakpoints> | undefined;
	    levels?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeLevels> | undefined;
	    shadows?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeShadows> | undefined;
	    components?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeComponents> | undefined;
	    flags?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common").EuiThemeVariantFlags> | undefined;
	    overrides?: import("@elastic/eui-theme-common").RecursivePartial<import("@elastic/eui-theme-common")._EuiThemeOverrides | undefined>;
	};

}
declare module '@elastic/eui/src/services/color/is_color_dark' {
	/**
	 * This function calculates if the specified color is "dark", which usually means
	 * you need light text if you use it as a background color to fulfill WCAG contrast
	 * requirement.
	 * The color must be specified via its red, green and blue value in the range of
	 * 0 to 255.
	 * The formula is based on this Stackoverflow answer: https://stackoverflow.com/a/3943023
	 * which itself is based upon the WCAG recommendation for color contrast.
	 *
	 * @param {number} red The red component in the range 0 to 255
	 * @param {number} green The green component in the range 0 to 255
	 * @param {number} blue The blue component in the range 0 to 255
	 * @returns {boolean} True if the color is dark, false otherwise.
	 */
	export function isColorDark(red: number, green: number, blue: number): boolean;

}
declare module '@elastic/eui/src/services/color/is_valid_hex' {
	export function isValidHex(hex: string): boolean;

}
declare module '@elastic/eui/src/services/color/color_types' {
	export type rgbDef = [number, number, number];
	export interface HSV {
	    h: number;
	    s: number;
	    v: number;
	}
	export interface RGB {
	    r: number;
	    g: number;
	    b: number;
	}
	export type HEX = string;

}
declare module '@elastic/eui/src/services/color/hex_to_rgb' {
	import { rgbDef } from '@elastic/eui/src/services/color/color_types';
	export function hexToRgb(hex: string): rgbDef;

}
declare module '@elastic/eui/src/services/color/rgb_to_hsv' {
	import { HSV, RGB } from '@elastic/eui/src/services/color/color_types';
	export function rgbToHsv({ r, g, b }: RGB): HSV;

}
declare module '@elastic/eui/src/services/color/hex_to_hsv' {
	import { HEX, HSV } from '@elastic/eui/src/services/color/color_types';
	export function hexToHsv(hex: HEX): HSV;

}
declare module '@elastic/eui/src/services/color/hsv_to_rgb' {
	import { HSV, RGB } from '@elastic/eui/src/services/color/color_types';
	export function hsvToRgb({ h, s, v }: HSV): RGB;

}
declare module '@elastic/eui/src/services/color/rgb_to_hex' {
	export function rgbToHex(rgb: string): string;

}
declare module '@elastic/eui/src/services/color/hsv_to_hex' {
	import { HEX, HSV } from '@elastic/eui/src/services/color/color_types';
	export function hsvToHex({ h, s, v }: HSV): HEX;

}
declare module '@elastic/eui/src/services/color/luminance_and_contrast' {
	import { rgbDef } from '@elastic/eui/src/services/color/color_types';
	export function calculateLuminance(r: number, g: number, b: number): number;
	export function calculateContrast(rgb1: rgbDef, rgb2: rgbDef): number;

}
declare module '@elastic/eui/src/services/color/color_palette' {
	export const MID_COLOR_STOP = "#EBEFF5";
	/**
	 * This function takes an array of colors and returns an array of interpolated
	 * colors based on the number of steps/len needed for use in UI elements such as charts.
	 * Derived from https://github.com/gka/palettes (Unlicensed)
	 */
	export function colorPalette(
	/**
	 * The main color code or array of codes
	 */
	colors: string[], 
	/**
	 * The number of colors in the resulting array (default 10)
	 */
	len?: number, 
	/**
	 * Forces color interpolation to be calculated separately for each half (default false)
	 */
	diverging?: boolean, 
	/**
	 * Uses a more static interpolation for non-continuous spectrums
	 */
	categorical?: boolean): string[];

}
declare module '@elastic/eui/src/services/color/vis_color_store' {
	import { _EuiVisColorStore } from '@elastic/eui-theme-common';
	export const EUI_VIS_COLOR_STORE: _EuiVisColorStore;

}
declare module '@elastic/eui/src/services/color/eui_palettes' {
	import { _EuiThemeVisColors } from '@elastic/eui-theme-common';
	export type EuiPalette = string[];
	export type EuiPaletteCommonProps = {
	    /**
	     * Defines the default set of colors the palette uses.
	     * Defaults to vis colors from `EUI_VIS_COLOR_STORE`.
	     * Use this to specify colors when you can't rely on the EuiProvider updates.
	     */
	    colors?: _EuiThemeVisColors;
	};
	export type EuiPaletteRotationProps = {
	    /**
	     * How many variations of the series is needed
	     */
	    rotations?: number;
	    /**
	     * Order similar colors as `group`s or just `append` each variation
	     */
	    order?: 'append' | 'group';
	    /**
	     * Specifies if the direction of the color variations
	     */
	    direction?: 'lighter' | 'darker' | 'both';
	    /**
	     * Use the default sort order, or re-sort them based on the color wheel (natural)
	     */
	    sortBy?: 'default' | 'natural';
	    /**
	     * Shift the sorting order by a certain number when used in conjunction with `'natural'` `sortBy`.
	     * Defaults to a number close to green.
	     */
	    sortShift?: string;
	};
	export type EuiPaletteColorBlindProps = EuiPaletteCommonProps & EuiPaletteRotationProps;
	/**
	 * For usage in React use the `useEuiPaletteColorBlind` hook instead.
	 *
	 * NOTE: These functions rely on base vis colors of the theme which are provided via a global
	 * singleton instance `EUI_VIS_COLOR_STORE` that's updated by the EuiProvider on theme change.
	 * Make sure the function is recalled on theme change to retrieve theme-related colors.
	 *
	 * Outside of a react component you can use the `subscibe()` method on the `EUI_VIS_COLOR_STORE`
	 * to subscribe to updates and update your usages to ensure latest colors are loaded.
	 */
	export const euiPaletteColorBlind: ({ rotations, order, direction, sortBy, sortShift, colors, }?: EuiPaletteColorBlindProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteColorBlindBehindText` hook instead.
	 *
	 * Color blind palette with text is meant for use when text is applied on top of the color.
	 * It increases the brightness of the color to give the text more contrast.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteColorBlindBehindText: (paletteProps?: EuiPaletteColorBlindProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteForStatus` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteForStatus: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteForTemperature` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteForTemperature: (steps: any, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteComplementary` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteComplementary: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteRed` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteRed: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteGreen` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteGreen: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteSkyBlue` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteSkyBlue: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteYellow` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteYellow: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteOrange` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteOrange: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteCool` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteCool: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteWarm` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteWarm: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;
	/**
	 * For usage in React use the `useEuiPaletteGray` hook instead.
	 *
	 * NOTE: This function is not pure. It relies on `EUI_VIS_COLOR_STORE` which is updated by the
	 * EuiProvider on theme change. Ensure to recall the function on theme change or subscribe to the store.
	 */
	export const euiPaletteGray: (steps: number, { colors }?: EuiPaletteCommonProps) => EuiPalette;

}
declare module '@elastic/eui/src/services/color/visualization_colors' {
	/** @deprecated - use the data vis colors on `euiTheme.colors.vis` instead */
	export const VISUALIZATION_COLORS: import ("@elastic/eui/src/services/color/eui_palettes").EuiPalette;
	/** @deprecated - use the data vis colors on `euiTheme.colors.vis` instead */
	export const DEFAULT_VISUALIZATION_COLOR: string;

}
declare module '@elastic/eui/src/services/color/eui_palettes_hooks' {
	import { EuiPalette, EuiPaletteColorBlindProps } from '@elastic/eui/src/services/color/eui_palettes';
	export const useEuiPaletteColorBlind: (args?: EuiPaletteColorBlindProps) => EuiPalette;
	export const useEuiPaletteColorBlindBehindText: (args?: EuiPaletteColorBlindProps) => EuiPalette;
	export const useEuiPaletteForStatus: (steps: number) => EuiPalette;
	export const useEuiPaletteForTemperature: (steps: number) => EuiPalette;
	export const useEuiPaletteComplementary: (steps: number) => EuiPalette;
	export const useEuiPaletteRed: (steps: number) => EuiPalette;
	export const useEuiPaletteGreen: (steps: number) => EuiPalette;
	export const useEuiPaletteSkyBlue: (steps: number) => EuiPalette;
	export const useEuiPaletteYellow: (steps: number) => EuiPalette;
	export const useEuiPaletteOrange: (steps: number) => EuiPalette;
	export const useEuiPaletteCool: (steps: number) => EuiPalette;
	export const useEuiPaletteWarm: (steps: number) => EuiPalette;
	export const useEuiPaletteGray: (steps: number) => EuiPalette;

}
declare module '@elastic/eui/src/global_styling/functions/high_contrast' {
	import type { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Minor syntactical sugar for conditional high contrast styles.
	 * Ternaries are otherwise somewhat ugly in css`` template literals,
	 * and this makes life just a little more beautiful ✨
	 */
	export const highContrastModeStyles: (euiThemeContext: UseEuiTheme, options: {
	    /** Default styles to render (no high contrast mode) */
	    none?: string;
	    /** Styles to render when high contrast mode is preferred or forced */
	    preferred?: string;
	    /** Styles to render when high contrast mode is being forced */
	    forced?: string;
	}) => string;
	/**
	 * Small uitility that allows component styles to ignore/override
	 * forced colors modes (primarily Windows high contrast themes)
	 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/forced-color-adjust
	 *
	 * WARNING: Do *not* use this utility unless:
	 * 1. Colors/backgrounds are **essential** to the semantic meaning of the UI,
	 *    and users will lose all meaning without them
	 * 2. Tweaks have been made to existing styles to increase color contrast
	 *    as necessary
	 */
	export const preventForcedColors: ({ highContrastMode }: UseEuiTheme) => "" | "forced-color-adjust: none;";

}
declare module '@elastic/eui/src/global_styling/functions/logicals' {
	import { CSSProperties } from 'react';
	/**
	 * EUI utilizes logical CSS properties to enable directional writing-modes.
	 * To encourage use of logical properties, we provide a few helper utilities to
	 * convert certain directional properties to logical properties.
	 * https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties
	 */
	export const logicalSide: {
	    left: string;
	    right: string;
	    top: string;
	    bottom: string;
	    horizontal: string;
	    vertical: string;
	};
	export const LOGICAL_SIDES: ("left" | "right" | "top" | "bottom" | "horizontal" | "vertical")[];
	export type LogicalSides = (typeof LOGICAL_SIDES)[number];
	export const logicals: {
	    height: string;
	    width: string;
	    "max-height": string;
	    "max-width": string;
	    "min-height": string;
	    "min-width": string;
	    top: string;
	    right: string;
	    bottom: string;
	    left: string;
	    horizontal: string;
	    vertical: string;
	    "margin-left": string;
	    "margin-right": string;
	    "margin-top": string;
	    "margin-bottom": string;
	    "margin-horizontal": string;
	    "margin-vertical": string;
	    "padding-left": string;
	    "padding-right": string;
	    "padding-top": string;
	    "padding-bottom": string;
	    "padding-horizontal": string;
	    "padding-vertical": string;
	    "overflow-x": string;
	    "overflow-y": string;
	    "border-horizontal": string;
	    "border-horizontal-color": string;
	    "border-horizontal-width": string;
	    "border-horizontal-style": string;
	    "border-vertical": string;
	    "border-vertical-color": string;
	    "border-vertical-width": string;
	    "border-vertical-style": string;
	    "border-bottom": string;
	    "border-bottom-color": string;
	    "border-bottom-style": string;
	    "border-bottom-width": string;
	    "border-top": string;
	    "border-top-color": string;
	    "border-top-style": string;
	    "border-top-width": string;
	    "border-right": string;
	    "border-right-color": string;
	    "border-right-style": string;
	    "border-right-width": string;
	    "border-left": string;
	    "border-left-color": string;
	    "border-left-style": string;
	    "border-left-width": string;
	    "border-top-left-radius": string;
	    "border-top-right-radius": string;
	    "border-bottom-left-radius": string;
	    "border-bottom-right-radius": string;
	    _shorthands: string[];
	};
	export const LOGICAL_PROPERTIES: ("left" | "right" | "width" | "top" | "bottom" | "horizontal" | "vertical" | "height" | "max-height" | "max-width" | "min-height" | "min-width" | "margin-left" | "margin-right" | "margin-top" | "margin-bottom" | "margin-horizontal" | "margin-vertical" | "padding-left" | "padding-right" | "padding-top" | "padding-bottom" | "padding-horizontal" | "padding-vertical" | "overflow-x" | "overflow-y" | "border-horizontal" | "border-horizontal-color" | "border-horizontal-width" | "border-horizontal-style" | "border-vertical" | "border-vertical-color" | "border-vertical-width" | "border-vertical-style" | "border-bottom" | "border-bottom-color" | "border-bottom-style" | "border-bottom-width" | "border-top" | "border-top-color" | "border-top-style" | "border-top-width" | "border-right" | "border-right-color" | "border-right-style" | "border-right-width" | "border-left" | "border-left-color" | "border-left-style" | "border-left-width" | "border-top-left-radius" | "border-top-right-radius" | "border-bottom-left-radius" | "border-bottom-right-radius")[];
	export type LogicalProperties = (typeof LOGICAL_PROPERTIES)[number];
	/**
	 *
	 * @param property A string that is a valid CSS logical property
	 * @param value String to output as the property value
	 * @returns `string` Returns the logical CSS property version for the given `property: value` pair
	 */
	export const logicalCSS: (property: LogicalProperties, value?: any) => string;
	/**
	 * Some logical properties are not yet fully supported by all browsers.
	 * For those cases, we should use the old property as a fallback for
	 * browsers missing support, while allowing supporting browsers to use
	 * the logical properties.
	 *
	 * Examples:
	 * https://caniuse.com/?search=overflow-block
	 * https://caniuse.com/mdn-css_properties_float_flow_relative_values
	 */
	export const logicalCSSWithFallback: (property: LogicalProperties, value?: any) => string;
	/**
	 *
	 * @param property A string that is a valid CSS logical property
	 * @param value String to output as the property value
	 * @returns `object` Returns the logical CSS property version for the given `property: value` pair
	 */
	export const logicalStyle: (property: LogicalProperties, value?: any) => {
	    [x: string]: any;
	};
	/**
	 * Given a style object with any amount of unknown CSS properties,
	 * find ones that can be converted to logical properties and convert them
	 *
	 * @param styleObject - A React object of camelCased styles
	 * @returns `object`
	 */
	export const logicalStyles: (styleObject: CSSProperties) => Record<string, string | number | undefined>;
	/**
	 *
	 * @param width A string value for the LTR width
	 * @param height A string value for the LTR height
	 * @returns `string` Returns the logical CSS properties for height and width
	 */
	export const logicalSizeCSS: (width: any, height?: any) => string;
	/**
	 *
	 * @param width A string value for the LTR width
	 * @param height A string value for the LTR height
	 * @returns `object` Returns the logical CSS properties for height and width
	 */
	export const logicalSizeStyle: (width: any, height: any) => {
	    [x: string]: any;
	};
	export const logicalText: {
	    'text-align': {
	        left: string;
	        center: string;
	        right: string;
	    };
	};
	export const LOGICAL_TEXT_ALIGNMENT: ("left" | "right" | "center")[];
	export type LogicalText = (typeof LOGICAL_TEXT_ALIGNMENT)[number];
	/**
	 *
	 * @param property A string that is a valid CSS logical property
	 * @param value String to output as the property value
	 * @returns `string` Returns the logical CSS property version for the given `property: value` pair
	 */
	export const logicalTextAlignCSS: (value: LogicalText) => string;
	/**
	 *
	 * @param property A string that is a valid CSS logical property
	 * @param value String to output as the property value
	 * @returns `object` Returns the logical CSS property version for the given `property: value` pair
	 */
	export const logicalTextAlignStyle: (value: LogicalText) => {
	    textAlign: string;
	};

}
declare module '@elastic/eui/src/global_styling/functions/logical_shorthands' {
	export const LOGICAL_SHORTHANDS: string[];
	export type LogicalShorthands = (typeof LOGICAL_SHORTHANDS)[number];
	/**
	 * Unfortunately, shorthand properties that describe boxes
	 * (@see https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties#edges_of_a_box)
	 * do not currently automatically respond to logical changes in display direction
	 * (@see https://github.com/w3c/csswg-drafts/issues/1282)
	 *
	 * This utility is essentially a stop-gap for those shorthand properties,
	 * converting them to corresponding longer logical `-inline` and `-block` properties
	 *
	 * 🗑 NOTE: This file is in a separate util file from logicals.ts due to its relatively
	 * convoluted logic, & to make deleting it easier when an official CSS spec is implemented.
	 */
	export const logicalShorthandCSS: (property: LogicalShorthands, value: string | number) => string;
	/**
	 * Logical border radius is unfortunately a very special case as it handles corners
	 * and not sides (@see https://developer.mozilla.org/en-US/docs/Web/CSS/Shorthand_properties#corners_of_a_box)
	 * and does not have `-inline` or `-block` shorthands.
	 *
	 * It also needs to account for `/` syntax (horizontal vs vertical radii)
	 * @see https://www.sitepoint.com/setting-css3-border-radius-with-slash-syntax/
	 */
	export const logicalBorderRadiusCSS: (value: string, ignoreZeroes?: boolean) => string;

}
declare module '@elastic/eui/src/global_styling/functions/math' {
	export { mathWithUnits } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/functions/size' {
	export { sizeToPixel } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/typography' {
	export { EuiThemeFontUnits, EuiThemeFontScales, EuiThemeFontWeights, type _EuiThemeFontUnit, type _EuiThemeFontScale, type _EuiThemeFontScales, type _EuiThemeFontBase, type _EuiThemeFontWeight, type _EuiThemeFontWeights, type _EuiThemeBody, type _EuiThemeTitle, type _EuiThemeFont, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/functions/typography' {
	import { _EuiThemeFontScale, _EuiThemeFontUnit, _EuiThemeFontWeights } from '@elastic/eui/src/global_styling/variables/typography';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme/hooks';
	export interface _FontScaleOptions {
	    /**
	     * The font-size or line-height unit to return
	     */
	    unit?: _EuiThemeFontUnit;
	    /**
	     * An additional custom scale multiplier to use against the current scale
	     * This parameter can be used (e.g. by EuiText sizes) to get sizes of text smaller than the default
	     */
	    customScale?: _EuiThemeFontScale;
	}
	/**
	 * Calculates the font-size value based on the provided scale key
	 * @param scale - The font scale key
	 * @param theme - Requires the `base` and `font` keys
	 * @param options - Optional parameters - see _FontScaleOptions
	 *
	 * @returns string - Calculated font-size value
	 */
	export function euiFontSizeFromScale(scale: _EuiThemeFontScale, { base, font }: UseEuiTheme['euiTheme'], { unit, customScale }?: _FontScaleOptions): string;
	/**
	 * Calculates the line-height to the closest multiple of the baseline
	 * EX: A proper line-height for text is 1.5 times the font-size.
	 *     If our base font size (euiFontSize) is 16, and our baseline is 4. To ensure the
	 *     text stays on the baseline, we pass a multiplier to calculate a line-height.
	 * @param scale - The font scale key
	 * @param theme - Requires the `base` and `font` keys
	 * @param options - Optional parameters - see _FontScaleOptions
	 *
	 * @returns string - Calculated line-height value aligned to baseline
	 */
	export function euiLineHeightFromBaseline(scale: _EuiThemeFontScale, { base, font }: UseEuiTheme['euiTheme'], { unit, customScale }?: _FontScaleOptions): string;
	/**
	 * Text weight shifting
	 *
	 * When changing the font-weight based on the state of the component,
	 * this mixin will ensure that the sizing is dependent on the boldest
	 * weight so it doesn't shift sibling content.
	 */
	export const euiTextShift: (fontWeight: keyof _EuiThemeFontWeights | undefined, attribute: string | undefined, euiTheme: UseEuiTheme["euiTheme"]) => string;

}
declare module '@elastic/eui/src/global_styling/functions' {
	export * from '@elastic/eui/src/global_styling/functions/high_contrast';
	export * from '@elastic/eui/src/global_styling/functions/logicals';
	export * from '@elastic/eui/src/global_styling/functions/logical_shorthands';
	export * from '@elastic/eui/src/global_styling/functions/math';
	export * from '@elastic/eui/src/global_styling/functions/size';
	export * from '@elastic/eui/src/global_styling/functions/typography';

}
declare module '@elastic/eui/src/global_styling/utility/selectors' {
	export const euiDisabledSelector = ":disabled, [aria-disabled=\"true\"]";

}
declare module '@elastic/eui/src/global_styling/mixins/_button' {
	import { type SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/** Tentative usage; these exist only to be used as button directly when used within other components */
	export const SEVERITY_COLORS: readonly ["neutral", "risk"];
	export const BUTTON_COLORS: readonly ["text", "accent", "accentSecondary", "primary", "success", "warning", "danger"];
	export const EXTENDED_BUTTON_COLORS: readonly ["text", "accent", "accentSecondary", "primary", "success", "warning", "danger", "neutral", "risk"];
	export type _EuiButtonColor = (typeof BUTTON_COLORS)[number];
	export type _EuiExtendedButtonColor = (typeof EXTENDED_BUTTON_COLORS)[number];
	export const BUTTON_DISPLAYS: readonly ["base", "fill", "empty"];
	export type _EuiButtonDisplay = (typeof BUTTON_DISPLAYS)[number];
	export interface _EuiButtonOptions {
	    display?: _EuiButtonDisplay;
	}
	type ButtonVariantColors = {
	    color: string;
	    background: string;
	    backgroundHover: string;
	    backgroundActive: string;
	    borderColor: string;
	};
	export const getEuiButtonColorValues: (euiThemeContext: UseEuiTheme, color: _EuiExtendedButtonColor | "disabled") => {
	    color: string;
	    backgroundColor: string;
	    borderColor: string;
	    backgroundHover: string;
	    backgroundActive: string;
	};
	/**
	 * Creates the `base` version of button styles with proper text contrast.
	 * @param euiThemeContext
	 * @param color One of the named button colors or 'disabled'
	 * @returns Style object `{ backgroundColor, color }`
	 */
	export const euiButtonColor: (euiThemeContext: UseEuiTheme, color: _EuiExtendedButtonColor | "disabled") => {
	    border: string;
	    color: string;
	    backgroundColor: string;
	} | {
	    border?: undefined;
	    color: string;
	    backgroundColor: string;
	};
	export const getEuiFilledButtonColorValues: (euiThemeContext: UseEuiTheme, color: _EuiExtendedButtonColor | "disabled") => {
	    color: string;
	    backgroundColor: string;
	    borderColor: string;
	    backgroundHover: string;
	    backgroundActive: string;
	};
	/**
	 * Creates the `fill` version of buttons styles with proper text contrast.
	 * @param euiThemeContext
	 * @param color One of the named button colors or 'disabled'
	 * @returns Style object `{ backgroundColor, color }`
	 */
	export const euiButtonFillColor: (euiThemeContext: UseEuiTheme, color: _EuiExtendedButtonColor | "disabled") => {
	    border: string;
	    color: string;
	    backgroundColor: string;
	} | {
	    border?: undefined;
	    color: string;
	    backgroundColor: string;
	};
	/**
	 * Creates the `empty` version of button styles using the text-variant and adding interactive styles.
	 * @param euiThemeContext
	 * @param color One of the named button colors or 'disabled'
	 * @returns Style object `{ backgroundColor, color }` where `background` is typically used for interactive states
	 */
	export const euiButtonEmptyColor: (euiThemeContext: UseEuiTheme, color: _EuiExtendedButtonColor | "disabled") => {
	    color: string;
	    backgroundColor: string;
	};
	/**
	 * Given the button display type, returns the Emotion based color keys.
	 * @param options Button display type
	 * @returns An object of `_EuiExtendedButtonColor` keys including `disabled`
	 */
	export const useEuiButtonColorCSS: (options?: _EuiButtonOptions) => Record<"text" | "primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "disabled" | "neutral" | "risk", SerializedStyles>;
	export const euiButtonDisplaysColors: (euiThemeContext: UseEuiTheme) => Record<"base" | "fill" | "empty", Record<"text" | "primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "disabled" | "neutral" | "risk", SerializedStyles>>;
	/**
	 * Creates the translate animation when button is in focus.
	 * @returns string
	 */
	export const useEuiButtonFocusCSS: () => SerializedStyles;
	/**
	 * Map of `size` props to various sizings/scales
	 * that should remain consistent across all buttons
	 */
	export const euiButtonSizeMap: (euiThemeContext: UseEuiTheme) => {
	    xs: {
	        minWidth: number;
	        height: string;
	        padding: string;
	        radius: import("csstype").Property.BorderRadius<string | number> | undefined;
	        fontScale: "xs";
	    };
	    s: {
	        minWidth: number;
	        height: string;
	        padding: string;
	        radius: import("csstype").Property.BorderRadius<string | number> | undefined;
	        fontScale: "s";
	    };
	    m: {
	        minWidth: number;
	        height: string;
	        padding: string;
	        radius: import("csstype").Property.BorderRadius<string | number> | undefined;
	        fontScale: "s";
	    };
	};
	/**
	 * internal styles util for applying button background color on hover
	 */
	export const euiButtonInteractionStyles: (euiThemeContext: UseEuiTheme, buttonColors: ButtonVariantColors, type?: "fill" | "overlay") => string;
	/**
	 * creates a bottom border on hover/focus to ensure a visible change as forced mode removed background colors
	 */
	export const highContrastHoverIndicatorStyles: ({ euiTheme }: UseEuiTheme) => string;
	export {};

}
declare module '@elastic/eui/src/global_styling/mixins/_color' {
	import { SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const BACKGROUND_COLORS: readonly ["transparent", "plain", "subdued", "highlighted", "accent", "accentSecondary", "primary", "success", "warning", "danger", "neutral", "risk"];
	export type _EuiBackgroundColor = (typeof BACKGROUND_COLORS)[number];
	export interface _EuiBackgroundColorOptions {
	    /**
	     * Use `opaque` for containers of unknown content.
	     * Use `transparent` for interactive states like hover and focus.
	     */
	    method?: 'opaque' | 'transparent';
	}
	/**
	 * @deprecated - use background tokens directly
	 * @returns A single background color with optional alpha transparency
	 */
	export const euiBackgroundColor: ({ euiTheme }: UseEuiTheme, color: _EuiBackgroundColor, { method }?: _EuiBackgroundColorOptions) => string;
	/**
	 * @deprecated
	 */
	export const useEuiBackgroundColor: (color: _EuiBackgroundColor, { method }?: _EuiBackgroundColorOptions) => string;
	/**
	 * Hook to retrieve background style for a background color variant
	 * @returns An object map of color keys to CSS,
	 * e.g. { danger: css``, success: css``, ... }
	 */
	export const useEuiBackgroundColorCSS: () => Record<"primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "neutral" | "risk" | "transparent" | "plain" | "subdued" | "highlighted", SerializedStyles>;
	/**
	 * Border colors
	 * @deprecated - use border tokens directly or use
	 * `useEuiBorderColorCSS()` for composed styles
	 */
	export const euiBorderColor: ({ euiTheme }: UseEuiTheme, color: _EuiBackgroundColor) => string;
	/**
	 * Hook to retrieve border style for a border variant
	 * @returns An object map of color keys to CSS,
	 * e.g. { danger: css``, success: css``, ... }
	 */
	export const useEuiBorderColorCSS: () => Record<"primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "neutral" | "risk" | "transparent" | "plain" | "subdued" | "highlighted", SerializedStyles>;

}
declare module '@elastic/eui/src/global_styling/mixins/_container_query' {
	 const CONTAINER_TYPES: readonly ["normal", "size", "inline-size"];
	/**
	 * Type of container context used in container queries.
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/container-type}
	 */
	export type EuiContainerType = (typeof CONTAINER_TYPES)[number];
	/**
	 * Establish element as a query container.
	 * The scroll state is applied through the `scrollState` argument
	 * and not the `type` argument.
	 *
	 * @example
	 * // Export container name to use across the application
	 * export const PAGE_CONTENT_CONTAINER_NAME = 'my-app-page-content';
	 * const pageContentStyles = css`
	 *   ${euiContainer('inline-size', PAGE_CONTENT_CONTAINER_NAME)}
	 *   margin: 0 auto;
	 * `;
	 *
	 * @returns A style string to be used inside Emotion's `css` template literal
	 * @beta
	 */
	export const euiContainer: (type: EuiContainerType, name?: string, scrollState?: boolean) => string;
	/**
	 * Establish element as a query container.
	 * The scroll state is applied through the `scrollState` argument
	 * and not the `type` argument.
	 *
	 * @example
	 * // Export container name to use across the application
	 * export const PAGE_CONTENT_CONTAINER_NAME = 'my-app-page-content';
	 * const PageContent = ({ children }: PropsWithChildren) => (
	 *   <main css={euiContainerCSS('inline-size', PAGE_CONTENT_CONTAINER_NAME)}>
	 *     {children}
	 *   </main>
	 * );
	 * @returns Emotion's `SerializedStyles` object to be passed to the `css` prop
	 *   of a React component.
	 * @beta
	 */
	export const euiContainerCSS: (type: EuiContainerType, name?: string, scrollState?: boolean) => import("@emotion/react").SerializedStyles;
	/**
	 * Get a @container rule for given conditions and an optional container name.
	 *
	 * Container queries can be used to apply conditional styles based on container
	 * size, its scroll state or even its styles.
	 *
	 * It's hugely useful to conditionally show or hide information based
	 * on the **container** dimensions instead of the **viewport** dimensions.
	 *
	 * When container name is provided, it will be used to target the containment
	 * context. When skipped, it will target the nearest ancestor with containment.
	 *
	 * @example
	 * const itemDetailsStyles = css`
	 *   background: red;
	 *
	 *   ${euiContainerQuery('(width > 250px)')} {
	 *     background: blue;
	 *   }
	 * `;
	 *
	 * @param conditions one or many conditions to query the container with.
	 *   Similarly to media queries, you can use
	 *   size queries (e.g., `(width > 300px)`),
	 *   scroll state queries (e.g., `(scroll-state(scrollable: top))`),
	 *   or even style queries.
	 *   You can use the `and`, `or` and `not` logical keywords to define container
	 *   conditions. Note that all conditions must be wrapped in parentheses.
	 *
	 * @param containerName When provided, it will be used to target
	 *   the containment context and run queries against it. Otherwise, the nearest
	 *   ancestor with containment will be queried instead.
	 *
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@container}
	 * @beta
	 */
	export const euiContainerQuery: (conditions: string, containerName?: string) => string;
	export {};

}
declare module '@elastic/eui/src/global_styling/mixins/_helpers' {
	import { CSSProperties } from 'react';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme';
	/**
	 * Set scroll bar appearance on Chrome (and firefox).
	 * All parameters are optional and default to specific global settings.
	 */
	export interface EuiScrollBarStyles {
	    thumbColor?: CSSProperties['backgroundColor'];
	    trackColor?: CSSProperties['backgroundColor'];
	    /**
	     * Defaults to `thin`. Use `auto` only for large page scrollbars
	     */
	    width?: CSSProperties['scrollbarWidth'];
	    /**
	     * Overall width (height for horizontal scrollbars)
	     */
	    size?: CSSProperties['width'];
	    /**
	     * Corner sizes are usually determined by `width` and
	     * are used as an inset border and therefore a smaller corner size means a larger thumb
	     */
	    corner?: CSSProperties['borderWidth'];
	}
	export const euiScrollBarStyles: ({ euiTheme: { colors, size } }: UseEuiTheme, { thumbColor: _thumbColor, trackColor, width, size: _size, corner: _corner, }?: EuiScrollBarStyles) => string;
	export const useEuiScrollBar: (options?: EuiScrollBarStyles) => string;
	/**
	 * *INTERNAL*
	 * Overflow shadow masks for use in YScroll and XScroll helpers
	 */
	interface EuiOverflowShadowStyles {
	    direction?: 'y' | 'x';
	    side?: 'both' | 'start' | 'end';
	    /**
	     * When enabled, uses scroll animated pseudo elements to create a soft scroll container edge.
	     * Otherwise uses `mask-image` to create a static, soft gradient edge.
	     * It falls back to `mask-image` for `prefers-reduced-motion: reduce` settings and browsers that don't
	     * support the scroll timeline API.
	     */
	    hasAnimatedOverflowShadow?: boolean;
	}
	export const euiOverflowShadowStyles: ({ euiTheme: { size, colors } }: UseEuiTheme, { direction: _direction, side: _side, hasAnimatedOverflowShadow, }?: EuiOverflowShadowStyles) => string;
	/**
	 * 1. Focus rings shouldn't be visible on scrollable regions, but a11y requires them to be focusable.
	 *    Browser's supporting `:focus-visible` will still show outline on keyboard focus only.
	 *    Others like Safari, won't show anything at all.
	 */
	interface _EuiYScroll {
	    height?: CSSProperties['height'];
	}
	export const euiYScroll: (euiTheme: UseEuiTheme, { height }?: _EuiYScroll) => string;
	export const useEuiYScroll: ({ height }?: _EuiYScroll) => string;
	interface _EuiYScrollWithShadows extends _EuiYScroll {
	    side?: 'both' | 'start' | 'end';
	    hasAnimatedOverflowShadow?: boolean;
	}
	export const euiYScrollWithShadows: (euiTheme: UseEuiTheme, { height, side, hasAnimatedOverflowShadow, }?: _EuiYScrollWithShadows) => string;
	export const useEuiYScrollWithShadows: ({ height, side, hasAnimatedOverflowShadow, }?: _EuiYScrollWithShadows) => string;
	export const euiXScroll: (euiTheme: UseEuiTheme) => string;
	export const useEuiXScroll: () => string;
	export const euiXScrollWithShadows: (euiTheme: UseEuiTheme) => string;
	export const useEuiXScrollWithShadows: () => string;
	interface EuiScrollOverflowStyles {
	    direction?: 'y' | 'x';
	    mask?: boolean;
	}
	export const euiOverflowScroll: (euiTheme: UseEuiTheme, { direction, mask }?: EuiScrollOverflowStyles) => string;
	export const useEuiOverflowScroll: (direction: EuiScrollOverflowStyles["direction"], mask?: EuiScrollOverflowStyles["mask"]) => string;
	/**
	 * For quickly applying a full-height element whether using flex or not
	 */
	export const euiFullHeight: () => string;
	export {};

}
declare module '@elastic/eui/src/global_styling/mixins/_padding' {
	import { SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme';
	import { LogicalSides } from '@elastic/eui/src/global_styling/functions';
	export const PADDING_SIZES: readonly ["none", "xs", "s", "m", "l", "xl"];
	export type EuiPaddingSize = (typeof PADDING_SIZES)[number];
	/**
	 * Get a single padding size
	 */
	export const euiPaddingSize: ({ euiTheme }: UseEuiTheme, size: EuiPaddingSize) => string | null;
	export const useEuiPaddingSize: (size: EuiPaddingSize) => string;
	export const useEuiPaddingCSS: (side?: LogicalSides) => Record<"s" | "xs" | "m" | "l" | "xl" | "none", SerializedStyles>;

}
declare module '@elastic/eui/src/global_styling/mixins/_states' {
	import { CSSProperties } from 'react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export type _EuiFocusRingOffset = 'inset' | 'outset' | 'center' | CSSProperties['outlineOffset'];
	/**
	 * It is best practice to utilize the browser's default `outline` property for handling focus rings.
	 * However, some components need to be forced to have the same behavior, or adjust the display.
	 * This function re-applies the same default outline with a couple parameters
	 * @param euiTheme UseEuiTheme
	 * @param offset Accepts a specific measurement or 'inset', 'outset' or 'center' to adjust outline position
	 * @param color Accepts any CSS color
	 */
	export const euiOutline: ({ euiTheme }: UseEuiTheme, offset?: _EuiFocusRingOffset, color?: CSSProperties["outlineColor"]) => string;
	export const euiFocusRing: (euiThemeContext: UseEuiTheme, offset?: _EuiFocusRingOffset, options?: {
	    color?: CSSProperties["outlineColor"];
	}) => string;
	export const useEuiFocusRing: (offset?: _EuiFocusRingOffset, color?: CSSProperties["outlineColor"]) => string;

}
declare module '@elastic/eui/src/global_styling/mixins/_typography' {
	import { CSSProperties } from 'react';
	import { _FontScaleOptions } from '@elastic/eui/src/global_styling/functions/typography';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme';
	import { _EuiThemeFontScale } from '@elastic/eui/src/global_styling/variables/typography';
	export type EuiThemeFontSize = {
	    fontSize: CSSProperties['fontSize'];
	    lineHeight: CSSProperties['lineHeight'];
	};
	/**
	 * Returns font-size and line-height
	 */
	export const euiFontSize: ({ euiTheme }: UseEuiTheme, scale: _EuiThemeFontScale, options?: _FontScaleOptions) => EuiThemeFontSize;
	export const useEuiFontSize: (scale: _EuiThemeFontScale, options?: _FontScaleOptions) => EuiThemeFontSize;
	/**
	 * Force text to wrap on natural word breaks (e.g. spaces & hyphens)
	 * https://css-tricks.com/snippets/css/prevent-long-urls-from-breaking-out-of-container/
	 */
	export const euiTextBreakWord: () => string;
	/**
	 * Prevent text from wrapping onto multiple lines, and truncate with an ellipsis.
	 */
	export const euiTextTruncate: (maxWidth?: CSSProperties["maxWidth"]) => string;
	/**
	 * Emotion CSS wrapper around `euiTextTruncate` style.
	 */
	export const euiTextTruncateCSS: (maxWidth?: CSSProperties["maxWidth"]) => import("@emotion/react").SerializedStyles;
	/**
	 * Fixed-width numbers for tabular data
	 */
	export const euiNumberFormat: ({ euiTheme }: UseEuiTheme) => string;

}
declare module '@elastic/eui/src/global_styling/variables/animations' {
	export { euiCanAnimate, euiCantAnimate, EuiThemeAnimationSpeeds, EuiThemeAnimationEasings, type _EuiThemeAnimationSpeed, type _EuiThemeAnimationSpeeds, type _EuiThemeAnimationEasing, type _EuiThemeAnimationEasings, type _EuiThemeAnimation, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/borders' {
	export type { _EuiThemeBorderWidthValues, _EuiThemeBorderRadiusValues, _EuiThemeBorderColorValues, _EuiThemeBorderValues, _EuiThemeBorderTypes, _EuiThemeBorder, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/colors' {
	export type { _EuiThemeBrandColors, _EuiThemeBrandTextColors, _EuiThemeShadeColors, _EuiThemeTextColors, _EuiThemeSpecialColors, _EuiThemeConstantColors, _EuiThemeColorsMode, _EuiThemeColors, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/levels' {
	export { EuiThemeLevels, type _EuiThemeLevel, type _EuiThemeLevels, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/size' {
	export { EuiThemeSizes, type _EuiThemeBase, type _EuiThemeSize, type _EuiThemeSizes, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/shadow' {
	export { EuiThemeShadowSizes, _EuiShadowSizesDescriptions, type _EuiThemeShadows, type _EuiThemeShadowSize, type _EuiThemeShadowLayer, type _EuiThemeShadowCustomColor, } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables/states' {
	export type { _EuiThemeFocus } from '@elastic/eui-theme-common';

}
declare module '@elastic/eui/src/global_styling/variables' {
	export * from '@elastic/eui/src/global_styling/variables/animations';
	export * from '@elastic/eui/src/global_styling/variables/borders';
	export * from '@elastic/eui/src/global_styling/variables/breakpoint';
	export * from '@elastic/eui/src/global_styling/variables/colors';
	export * from '@elastic/eui/src/global_styling/variables/levels';
	export * from '@elastic/eui/src/global_styling/variables/size';
	export * from '@elastic/eui/src/global_styling/variables/shadow';
	export * from '@elastic/eui/src/global_styling/variables/states';
	export * from '@elastic/eui/src/global_styling/variables/typography';

}
declare module '@elastic/eui/src/global_styling/mixins/_responsive' {
	import { UseEuiTheme } from '@elastic/eui/src/services/theme/hooks';
	import { _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling/variables';
	/**
	 * Generates a CSS media query rule string based on the input breakpoint *ranges*.
	 * Examples with default theme breakpoints:
	 *
	 * euiBreakpoint(['s']) becomes `@media only screen and (min-width: 575px) and (max-width: 767px)`
	 * euiBreakpoint(['s', 'l']) becomes `@media only screen and (min-width: 575px) and (max-width: 1199px)`
	 *
	 * Use the smallest and largest sizes to generate media queries with only min/max-width.
	 * Examples with default theme breakpoints:
	 *
	 * euiBreakpoint(['xs', 'm']) becomes `@media only screen and (max-width: 991px)`
	 * euiBreakpoint(['l', 'xl']) becomes `@media only screen and (min-width: 992px)`
	 */
	export const euiBreakpoint: ({ euiTheme }: UseEuiTheme, sizes: [_EuiThemeBreakpoint, ..._EuiThemeBreakpoint[]]) => string;
	export const useEuiBreakpoint: (sizes: [_EuiThemeBreakpoint, ..._EuiThemeBreakpoint[]]) => string;
	/**
	 * Min/Max width breakpoint utilities that generate only a single min/max query/bound
	 *
	 * *Unlike the above euiBreakpoint utility*, these utilities treat breakpoint
	 * sizes as a one-dimensional point, rather than a two-dimensional *screen range*.
	 * Examples with default theme breakpoints:
	 *
	 * euiMaxBreakpoint('m') becomes `@media only screen and (max-width: 767px)`
	 * euiMinBreakpoint('m') becomes `@media only screen and (min-width: 768px)`
	 *
	 * This is safer and more intentional to use than euiBreakpoint(['xs', 's']) / euiBreakpoint(['m', 'xl'])
	 * in the event that consumers add larger or smaller custom breakpoints (e.g 'xxs' or `xxl`)
	 * and if the intention of the media query is actually "m and below/above" vs. "only screens m/l/xl".
	 */
	export const euiMinBreakpoint: ({ euiTheme }: UseEuiTheme, size: _EuiThemeBreakpoint) => string;
	export const useEuiMinBreakpoint: (size: _EuiThemeBreakpoint) => string;
	export const euiMaxBreakpoint: ({ euiTheme }: UseEuiTheme, size: _EuiThemeBreakpoint) => string;
	export const useEuiMaxBreakpoint: (size: _EuiThemeBreakpoint) => string;

}
declare module '@elastic/eui/src/global_styling/mixins/_shadow' {
	import { euiShadowFlat, euiShadow, euiSlightShadowHover, euiShadowXSmall, euiShadowSmall, euiShadowMedium, euiShadowLarge, euiShadowXLarge, euiShadowHover, type _EuiThemeShadowSize, type EuiShadowOptions } from '@elastic/eui-theme-common';
	export { euiShadowFlat, euiShadow, euiSlightShadowHover, euiShadowXSmall, euiShadowSmall, euiShadowMedium, euiShadowLarge, euiShadowXLarge, euiShadowHover, };
	/** @deprecated */
	export interface EuiShadowCustomColor {
	    color?: string;
	}
	/** @deprecated use euiShadowHover/useEuiShadowHover instead */
	export const useEuiSlightShadowHover: (options?: EuiShadowOptions) => string;
	/** @deprecated - useEuiShadow instead */
	export const useEuiShadowFlat: (options?: EuiShadowOptions) => string;
	export const useEuiShadow: (size?: _EuiThemeShadowSize, options?: EuiShadowOptions) => string;
	export const useEuiShadowHover: (size?: _EuiThemeShadowSize, options?: EuiShadowOptions) => string;

}
declare module '@elastic/eui/src/global_styling/mixins' {
	export * from '@elastic/eui/src/global_styling/mixins/_color';
	export * from '@elastic/eui/src/global_styling/mixins/_container_query';
	export * from '@elastic/eui/src/global_styling/mixins/_helpers';
	export * from '@elastic/eui/src/global_styling/mixins/_padding';
	export * from '@elastic/eui/src/global_styling/mixins/_states';
	export * from '@elastic/eui/src/global_styling/mixins/_typography';
	export * from '@elastic/eui/src/global_styling/mixins/_responsive';
	export * from '@elastic/eui/src/global_styling/mixins/_button';
	export * from '@elastic/eui/src/global_styling/mixins/_shadow';

}
declare module '@elastic/eui/src/global_styling/reset/reset' {
	export const resetStyles = "\n/* // Adapted from Eric Meyer's reset (http://meyerweb.com/eric/tools/css/reset/, v2.0 | 20110126). */\n\n\n*, *:before, *:after {\n  box-sizing: border-box;\n}\n\nhtml, body, div, span, applet, object, iframe,\nh1, h2, h3, h4, h5, h6, p, blockquote, pre,\na, abbr, acronym, address, big, cite, code,\ndel, dfn, em, img, ins, kbd, q, s, samp,\nsmall, strike, strong, sub, sup, tt, var,\nb, u, i, center,\ndl, dt, dd, ol, ul, li,\nfieldset, form, label, legend,\ntable, caption, tbody, tfoot, thead, tr, th, td,\narticle, aside, canvas, details, embed,\nfigure, figcaption, footer, header, hgroup,\nmenu, nav, output, ruby, section, summary,\ntime, mark, audio, video {\n  margin: 0;\n  padding: 0;\n  border: none;\n  vertical-align: baseline;\n}\n\nh1, h2, h3, h4, h5, h6, p {\n  font-family: inherit;\n  font-weight: inherit;\n  font-size: inherit;\n}\n\n/* HTML5 display-role reset for older browsers */\narticle, aside, details, figcaption, figure,\nfooter, header, hgroup, menu, nav, section {\n  display: block;\n}\n\na[href],\nbutton,\n[role='button'] {\n  cursor: pointer;\n}\n\nbutton {\n  background: none;\n  border: none;\n  padding: 0;\n  margin: 0;\n  color: inherit;\n  border-radius: 0;\n  font-size: inherit;\n}\n\ninput {\n  margin: 0;\n  padding: 0;\n}\n\ninput:disabled {\n  opacity: 1; /* required on iOS */\n}\n\nol,\nul {\n  list-style: none;\n}\n\nblockquote,\nq {\n  quotes: none;\n}\n\nblockquote:before,\nblockquote:after,\nq:before,\nq:after {\n  content: '';\n}\n\ntable {\n  border-collapse: collapse;\n  border-spacing: 0;\n}\n\nhr {\n  margin: 0;\n}\n\nfieldset {\n  min-inline-size: auto;\n}\n\n/* Chrome has an issue around RTL languages in SVGs when letter-spacing is negative\n * https://bugs.chromium.org/p/chromium/issues/detail?id=966480\n */\nsvg text {\n  letter-spacing: normal !important;\n}";

}
declare module '@elastic/eui/src/global_styling/reset/global_styles' {
	import React from 'react';
	export interface EuiGlobalStylesProps {
	}
	export const EuiGlobalStyles: ({}: EuiGlobalStylesProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/global_styling/utility/animations' {
	export const euiAnimFadeIn: import("@emotion/serialize").Keyframes;
	export const euiAnimSlideInUp: (size: string) => import("@emotion/serialize").Keyframes;
	export const euiAnimSlideX: (size: string) => import("@emotion/serialize").Keyframes;
	export const euiAnimScale: import("@emotion/serialize").Keyframes;

}
declare module '@elastic/eui/src/global_styling' {
	export * from '@elastic/eui/src/global_styling/reset/global_styles';
	export * from '@elastic/eui/src/global_styling/functions';
	export * from '@elastic/eui/src/global_styling/variables';
	export * from '@elastic/eui/src/global_styling/mixins';
	export * from '@elastic/eui/src/global_styling/utility/animations';
	export { euiDisabledSelector } from '@elastic/eui/src/global_styling/utility/selectors';

}
declare module '@elastic/eui/src/components/spacer/spacer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSpacerStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiSpacer: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    xxl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/spacer/spacer' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["xs", "s", "m", "l", "xl", "xxl"];
	export type SpacerSize = (typeof SIZES)[number];
	export type EuiSpacerProps = HTMLAttributes<HTMLDivElement> & CommonProps & {
	    size?: SpacerSize;
	};
	export const EuiSpacer: FunctionComponent<EuiSpacerProps>;

}
declare module '@elastic/eui/src/components/spacer' {
	export type { EuiSpacerProps } from '@elastic/eui/src/components/spacer/spacer';
	export { EuiSpacer } from '@elastic/eui/src/components/spacer/spacer';

}
declare module '@elastic/eui/src/components/text/text_color.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTextColorStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiTextColor: import("@emotion/react").SerializedStyles;
	    default: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    accentSecondary: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    ghost: import("@emotion/react").SerializedStyles;
	    inherit: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/text/text_color' {
	import { FunctionComponent } from 'react';
	import type { SharedTextProps, CloneElement, EuiTextColors } from '@elastic/eui/src/components/text/types';
	export const COLORS: readonly ["default", "subdued", "success", "accent", "accentSecondary", "danger", "warning", "ghost", "inherit"];
	export type TextColor = (typeof COLORS)[number];
	export const _isNamedColor: (color: any) => color is TextColor;
	export type EuiTextColorProps = SharedTextProps & CloneElement & EuiTextColors;
	export const EuiTextColor: FunctionComponent<EuiTextColorProps>;

}
declare module '@elastic/eui/src/components/text/text_align.styles' {
	export const euiTextAlignStyles: {
	    euiTextAlign: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/text/text_align' {
	import { FunctionComponent } from 'react';
	import type { SharedTextProps, CloneElement, EuiTextAlignment } from '@elastic/eui/src/components/text/types';
	export const ALIGNMENTS: readonly ["left", "right", "center"];
	export type TextAlignment = (typeof ALIGNMENTS)[number];
	export type EuiTextAlignProps = SharedTextProps & CloneElement & EuiTextAlignment;
	export const EuiTextAlign: FunctionComponent<EuiTextAlignProps>;

}
declare module '@elastic/eui/src/components/text/types' {
	import type { HTMLAttributes, CSSProperties } from 'react';
	import type { CommonProps } from '@elastic/eui/src/components/common';
	import type { TextColor } from '@elastic/eui/src/components/text/text_color';
	import type { TextAlignment } from '@elastic/eui/src/components/text/text_align';
	export type SharedTextProps = CommonProps & Omit<HTMLAttributes<HTMLElement>, 'color'> & {
	    /**
	     * The HTML element/tag to render.
	     * Use with care when nesting multiple components to ensure valid XHTML:
	     * - `<div>` and other block tags are not valid to use inside `<p>`. If using the `<p>` tag, we recommend passing strings/text only.
	     * - `<span>` is valid to be nested in any tag, and can have any tag nested within it.
	     */
	    component?: 'div' | 'span' | 'p';
	};
	export type CloneElement = {
	    /**
	     * Applies text styling to the child element instead of rendering a parent wrapper.
	     * Can only be used when wrapping a *single* child element/tag, and not raw text.
	     */
	    cloneElement?: boolean;
	};
	export type EuiTextColors = {
	    /**
	     * Any of our named colors or a `hex`, `rgb` or `rgba` value.
	     * @default inherit
	     */
	    color?: TextColor | CSSProperties['color'];
	};
	export type EuiTextAlignment = {
	    /**
	     * Applies horizontal text alignment
	     * @default left
	     */
	    textAlign?: TextAlignment;
	};

}
declare module '@elastic/eui/src/components/link/link.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiLinkCSS: (euiThemeContext: UseEuiTheme) => string;
	export const euiLinkStyles: (euiThemeContext: UseEuiTheme) => {
	    euiLink: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    ghost: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/title/title' {
	import { FunctionComponent, ReactElement } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const TITLE_SIZES: readonly ["xxxs", "xxs", "xs", "s", "m", "l"];
	export type EuiTitleSize = (typeof TITLE_SIZES)[number];
	export const TEXT_TRANSFORM: readonly ["uppercase"];
	export type EuiTitleTextTransform = (typeof TEXT_TRANSFORM)[number];
	export type EuiTitleProps = CommonProps & {
	    /**
	     * ReactElement to render as this component's content
	     */
	    children: ReactElement<any>;
	    size?: EuiTitleSize;
	    textTransform?: EuiTitleTextTransform;
	    id?: string;
	};
	export const EuiTitle: FunctionComponent<EuiTitleProps>;

}
declare module '@elastic/eui/src/components/title/title.styles' {
	import { CSSProperties } from 'react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { _FontScaleOptions } from '@elastic/eui/src/global_styling';
	import { EuiTitleSize } from '@elastic/eui/src/components/title/title';
	/**
	 * Mixin
	 */
	type EuiThemeTitle = {
	    fontSize: CSSProperties['fontSize'];
	    lineHeight: CSSProperties['lineHeight'];
	    fontWeight: CSSProperties['fontWeight'];
	    color: CSSProperties['color'];
	};
	export const euiTitle: (euiThemeContext: UseEuiTheme, scale?: EuiTitleSize, options?: _FontScaleOptions) => EuiThemeTitle;
	/**
	 * Styles
	 */
	export const euiTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTitle: import("@emotion/react").SerializedStyles;
	    uppercase: import("@emotion/react").SerializedStyles;
	    xxxs: import("@emotion/react").SerializedStyles;
	    xxs: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	};
	export {};

}
declare module '@elastic/eui/src/components/code/code_syntax.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeTextColors: ({ euiTheme }: UseEuiTheme) => {
	    backgroundColor: string;
	    color: string;
	};
	/**
	 * These variables are computationally expensive - do not call them outside `useEuiMemoizedStyles`
	 */
	export const euiCodeSyntaxVariables: (euiThemeContext: UseEuiTheme) => {
	    backgroundColor: string;
	    color: string;
	    inlineBackgroundColor: string;
	    inlineCodeColor: string;
	    selectedBackgroundColor: string;
	    commentColor: string;
	    selectorTagColor: string;
	    stringColor: string;
	    tagColor: string;
	    nameColor: string;
	    numberColor: string;
	    keywordColor: string;
	    inlineCodeKeywordColor: string;
	    functionTitleColor: string;
	    typeColor: string;
	    attributeColor: string;
	    symbolColor: string;
	    paramsColor: string;
	    metaColor: string;
	    titleColor: string;
	    sectionColor: string;
	    additionColor: string;
	    deletionColor: string;
	    selectorClassColor: string;
	    selectorIdColor: string;
	    readonly tokensCss: string;
	};

}
declare module '@elastic/eui/src/components/text/text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * TODO: Make this a global value so it can be set by theme?
	 */
	export const euiTextConstrainedMaxWidth = "max(64ch, 75%)";
	/**
	 * Mixins
	 */
	export const euiText: (euiTheme: UseEuiTheme["euiTheme"], inheritColor?: boolean) => {
	    color: string;
	    fontWeight: import("csstype").Property.FontWeight | undefined;
	};
	/**
	 * Styles
	 */
	export const euiTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiText: import("@emotion/react").SerializedStyles;
	    constrainedWidth: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    relative: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/text/text' {
	import { FunctionComponent } from 'react';
	import type { SharedTextProps, EuiTextColors, EuiTextAlignment } from '@elastic/eui/src/components/text/types';
	export const TEXT_SIZES: readonly ["xs", "s", "m", "relative"];
	export type TextSize = (typeof TEXT_SIZES)[number];
	export type EuiTextProps = SharedTextProps & EuiTextColors & EuiTextAlignment & {
	    /**
	     * Determines the text size. Choose `relative` to control the `font-size` based on the value of a parent container.
	     */
	    size?: TextSize;
	    grow?: boolean;
	};
	export const EuiText: FunctionComponent<EuiTextProps>;

}
declare module '@elastic/eui/src/components/text' {
	export type { EuiTextProps } from '@elastic/eui/src/components/text/text';
	export { EuiText } from '@elastic/eui/src/components/text/text';
	export type { EuiTextColorProps } from '@elastic/eui/src/components/text/text_color';
	export { EuiTextColor } from '@elastic/eui/src/components/text/text_color';
	export type { EuiTextAlignProps } from '@elastic/eui/src/components/text/text_align';
	export { EuiTextAlign } from '@elastic/eui/src/components/text/text_align';

}
declare module '@elastic/eui/src/components/context/context' {
	import React, { Context, FunctionComponent, ReactNode } from 'react';
	export interface RenderableValues {
	    [key: string]: ReactNode | undefined;
	}
	export type Renderable<T> = ReactNode | ((values: T) => ReactNode);
	export interface I18nShape {
	    mapping?: {
	        [key: string]: Renderable<object>;
	    };
	    mappingFunc?: (value: string) => string;
	    /**
	     * Some browsers' translation features don't work with a rendered `<Fragment>` component.
	     * The `render` function allows you to pass in another component instead, e.g. `<div>`
	     */
	    render?: (children: any) => FunctionComponent;
	    formatNumber?: (x: number) => string;
	    formatDateTime?: (x: Date) => string;
	    locale?: string;
	} const I18nContext: Context<I18nShape>; const EuiI18nConsumer: React.Consumer<I18nShape>;
	export interface EuiContextProps {
	    i18n: I18nShape;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	} const EuiContext: FunctionComponent<EuiContextProps>;
	export { EuiContext, EuiI18nConsumer, I18nContext };

}
declare module '@elastic/eui/src/components/context' {
	export type { EuiContextProps } from '@elastic/eui/src/components/context/context';
	export { EuiContext, EuiI18nConsumer } from '@elastic/eui/src/components/context/context';

}
declare module '@elastic/eui/src/services/predicate/common_predicates' {
	import moment from 'moment';
	export const always: (_value?: any) => boolean;
	export const never: (_value?: any) => boolean;
	export const isUndefined: (value: any) => value is undefined;
	export const isNull: (value: any) => value is null;
	export const isNil: (value: any) => value is null | undefined;
	export const isMoment: (value: any) => value is moment.Moment;
	export const isDate: (value: any) => value is Date;
	export const isDateLike: (value: any) => value is moment.Moment | Date;

}
declare module '@elastic/eui/src/services/predicate/lodash_predicates' {
	export const isFunction: (value: any) => value is (...args: any[]) => any;
	export const isArray: (value: any) => value is any[];
	export const isString: (value: any) => value is string;
	export const isBoolean: (value: any) => value is boolean;
	export const isNumber: (value: any) => value is number;
	export const isNaN: (value: any) => boolean;
	export const isObject: (value: any) => value is object;

}
declare module '@elastic/eui/src/services/predicate' {
	export * from '@elastic/eui/src/services/predicate/common_predicates';
	export * from '@elastic/eui/src/services/predicate/lodash_predicates';

}
declare module '@elastic/eui/src/components/i18n/i18n_util' {
	import { ReactNode } from 'react';
	import { RenderableValues } from '@elastic/eui/src/components/context/context';
	/**
	 * Replaces placeholder values in `input` with their matching value in `values`
	 * e.g. input:'Hello, {name}' will replace `{name}` with `values[name]`
	 * @param {string} input
	 * @param {RenderableValues} values
	 * @param {Function} i18nMappingFunc
	 * @returns {string | ReactNode[]}
	 */
	export function processStringToChildren(input: string, values: RenderableValues, i18nMappingFunc?: (token: string) => string): string | ReactNode[];

}
declare module '@elastic/eui/src/components/i18n/i18n' {
	import React, { ReactElement, ReactNode } from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { Renderable } from '@elastic/eui/src/components/context/context';
	type ResolvedType<T> = T extends (...args: any[]) => any ? ReturnType<T> : T;
	interface I18nTokenShape<T, DEFAULT extends Renderable<T>> {
	    token: string;
	    default: DEFAULT;
	    /**
	     * Render function that returns a ReactElement
	     */
	    children?: (x: ResolvedType<DEFAULT>) => ReactNode;
	    values?: T;
	}
	export interface I18nTokensShape<T extends any[]> {
	    tokens: string[];
	    defaults: T;
	    /**
	     * Render function that returns a ReactElement
	     */
	    children: (x: Array<T[number]>) => ReactNode;
	    values?: Record<string, ReactNode>;
	}
	export type EuiI18nProps<T, DEFAULT extends Renderable<T>, DEFAULTS extends any[]> = ExclusiveUnion<I18nTokenShape<T, DEFAULT>, I18nTokensShape<DEFAULTS>>; const EuiI18n: <T extends {}, DEFAULT extends Renderable<T>, DEFAULTS extends any[]>(props: EuiI18nProps<T, DEFAULT, DEFAULTS>) => React.JSX.Element;
	type DefaultRenderType<T, K extends Renderable<T>> = K extends ReactNode ? K : K extends () => infer RetValue ? RetValue : never;
	type DefaultsRenderType<K extends Array<string | ReactElement>> = K extends Array<infer Item> ? Item : never; function useEuiI18n<T extends {}, DEFAULT extends Renderable<T>>(token: string, defaultValue: DEFAULT, values?: T): DefaultRenderType<T, DEFAULT>; function useEuiI18n<DEFAULTS extends Array<string | ReactElement>>(tokens: string[], defaultValues: DEFAULTS): Array<DefaultsRenderType<DEFAULTS>>;
	export { EuiI18n, useEuiI18n };

}
declare module '@elastic/eui/src/components/i18n/i18n_number' {
	import { FunctionComponent, ReactElement, ReactNode } from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	interface EuiI18nNumberValueShape {
	    value: number;
	    children?: (x: ReactNode) => ReactElement<any>;
	}
	interface EuiI18nNumberValuesShape {
	    values: number[];
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: (x: ReactNode[]) => ReactElement<any>;
	}
	export type EuiI18nNumberProps = ExclusiveUnion<EuiI18nNumberValueShape, EuiI18nNumberValuesShape>; const EuiI18nNumber: FunctionComponent<EuiI18nNumberProps>;
	export { EuiI18nNumber };

}
declare module '@elastic/eui/src/components/i18n' {
	export type { EuiI18nProps } from '@elastic/eui/src/components/i18n/i18n';
	export { EuiI18n, useEuiI18n } from '@elastic/eui/src/components/i18n/i18n';
	export type { EuiI18nNumberProps } from '@elastic/eui/src/components/i18n/i18n_number';
	export { EuiI18nNumber } from '@elastic/eui/src/components/i18n/i18n_number';

}
declare module '@elastic/eui/src/components/observer/use_observer' {
	export interface Observer {
	    disconnect: () => void;
	    observe: (element: Element, options?: {
	        [key: string]: any;
	    }) => void;
	}
	/**
	 * A shared custom hook that provides a pattern for observing DOM nodes
	 * via browser observer APIs. Used by `EuiResizeObserver` and `EuiMutationObserver`.
	 *
	 * @param beginObserve - A callback that receives the target DOM element and should
	 *   create and return the observer instance (e.g., `ResizeObserver`).
	 * @param componentName - Optional name used in error messages when no ref is
	 *   attached on mount, mirroring the guard previously in `EuiObserver`.
	 */
	export const useObserver: (beginObserve: (node: Element) => Observer | undefined, componentName?: string) => (ref: Element | null) => void;

}
declare module '@elastic/eui/src/components/observer/resize_observer/resize_observer' {
	import { ReactNode, FunctionComponent } from 'react';
	export interface EuiResizeObserverProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: (ref: (e: HTMLElement | null) => void) => ReactNode;
	    onResize: (dimensions: {
	        height: number;
	        width: number;
	    }) => void;
	}
	export const hasResizeObserver: boolean;
	export const EuiResizeObserver: FunctionComponent<EuiResizeObserverProps>;
	export const useResizeObserver: (container: Element | null, dimension?: "width" | "height") => {
	    width: number;
	    height: number;
	};

}
declare module '@elastic/eui/src/components/observer/resize_observer' {
	export type { EuiResizeObserverProps } from '@elastic/eui/src/components/observer/resize_observer/resize_observer';
	export { EuiResizeObserver, useResizeObserver } from '@elastic/eui/src/components/observer/resize_observer/resize_observer';

}
declare module '@elastic/eui/src/components/portal/portal' {
	import { FunctionComponent, ReactNode } from 'react'; const INSERT_POSITIONS: readonly ["after", "before"];
	type EuiPortalInsertPosition = (typeof INSERT_POSITIONS)[number];
	export interface EuiPortalProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * If not specified, `EuiPortal` will insert itself
	     * into the end of the `document.body` by default
	     */
	    insert?: {
	        sibling: HTMLElement;
	        position: EuiPortalInsertPosition;
	    };
	    /**
	     * Optional ref callback
	     */
	    portalRef?: (ref: HTMLDivElement | null) => void;
	}
	export const EuiPortal: FunctionComponent<EuiPortalProps>;
	export {};

}
declare module '@elastic/eui/src/components/portal' {
	export type { EuiPortalProps } from '@elastic/eui/src/components/portal/portal';
	export { EuiPortal } from '@elastic/eui/src/components/portal/portal';

}
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: (breakpoint?: EuiBreakpointSize | boolean) => 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_context' {
	export const EuiTableVariantContext: import("react").Context<{
	    hasBackground: 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/react").SerializedStyles;
	    euiTableScrollableInline: import("@emotion/react").SerializedStyles;
	    layout: {
	        fixed: import("@emotion/react").SerializedStyles;
	        auto: import("@emotion/react").SerializedStyles;
	    };
	    hasBackground: import("@emotion/react").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/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	    /**
	     * Responsive/mobile vs desktop styles
	     * Individual row/cells handle their own desktop vs mobile styles
	     */
	    desktop: import("@emotion/react").SerializedStyles;
	    mobile: import("@emotion/react").SerializedStyles;
	    scrollableWrapper: import("@emotion/react").SerializedStyles;
	};
	export const euiTableCaptionStyles: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/table/const' {
	/**
	 * CSS Container name of the `EuiTable` component.
	 * It can be used for dimensional and scroll-state queries.
	 *
	 * @see {@link EuiTable}
	 */
	export const EUI_TABLE_CSS_CONTAINER_NAME = "EuiTable";

}
declare module '@elastic/eui/src/components/table/sticky_scrollbar/sticky_scrollbar.styles' {
	import { type UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTableStickyScrollbarStyles: ({ euiTheme }: UseEuiTheme) => {
	    wrapper: import("@emotion/react").SerializedStyles;
	    wrapperHidden: import("@emotion/react").SerializedStyles;
	    track: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/table/sticky_scrollbar/sticky_scrollbar' {
	import React, { type RefObject } from 'react';
	export interface EuiTableStickyScrollbarProps {
	    tableWrapperRef: RefObject<HTMLDivElement>;
	}
	export const EuiTableStickyScrollbar: ({ tableWrapperRef, }: EuiTableStickyScrollbarProps) => React.JSX.Element | null;

}
declare module '@elastic/eui/src/components/table/sticky_scrollbar' {
	export { EuiTableStickyScrollbar } from '@elastic/eui/src/components/table/sticky_scrollbar/sticky_scrollbar';

}
declare module '@elastic/eui/src/utils/publisher' {
	type Subscriber<TSubject> = (subject: TSubject) => void;
	/**
	 * @internal
	 */
	export type PublisherSubscribeFunc<TSubject> = (subscriber: Subscriber<TSubject>) => () => void;
	/**
	 * @internal
	 */
	interface Publisher<TSubject> {
	    subscribe: PublisherSubscribeFunc<TSubject>;
	    unsubscribe: (subscriber: Subscriber<TSubject>) => void;
	    notify: (subject: TSubject) => void;
	}
	/**
	 * @internal
	 */
	export const createPublisher: <TSubject>() => Publisher<TSubject>;
	export {};

}
declare module '@elastic/eui/src/components/table/store/store' {
	import { MutableRefObject, ReactNode, RefAttributes } from 'react';
	import { type PublisherSubscribeFunc } from '@elastic/eui/src/utils/publisher';
	/**
	 * @internal
	 */
	export type EuiTableStoreRenderHeaderCell = (extraProps: RefAttributes<HTMLTableCellElement>) => ReactNode;
	/**
	 * @internal
	 */
	export interface EuiTableStoreColumnData {
	    currentWidth?: number;
	    renderHeaderCellRef: MutableRefObject<EuiTableStoreRenderHeaderCell | undefined>;
	}
	type EuiTableStoreColumnsMap = ReadonlyMap<string, EuiTableStoreColumnData>;
	type EuiTableStoreColumnWidthsMap = ReadonlyMap<string, number>;
	/**
	 * EuiTable store that helps with column and width synchronization between
	 * the original table and the "virtual" sticky header table.
	 *
	 * This store is currently only used for these synchronization purposes, but
	 * that may extend as we implement resizable columns.
	 * If that's not implemented by the time per-axis `position: sticky`
	 * is supported in all browsers natively, this can be removed.
	 * @internal
	 */
	export interface EuiTableStore {
	    /**
	     * Register a table column with the store.
	     * Registration must be performed on the first render of the column
	     * to keep things in sync.
	     *
	     * @returns {Function} A function that unregisters the column from the store.
	     */
	    registerColumn: (id: string, data: EuiTableStoreColumnData) => () => void;
	    /**
	     * Update a table column with new data.
	     */
	    updateColumn: (id: string, data: EuiTableStoreColumnData) => void;
	    /**
	     * Update the current width of a column.
	     */
	    updateColumnWidth: (id: string, width: number) => void;
	    /**
	     * Subscribe to changes in table columns.
	     *
	     * @returns {Function} A function that unsubscribes the subscriber from the store.
	     */
	    subscribe: PublisherSubscribeFunc<EuiTableStoreColumnsMap>;
	    /**
	     * Subscribe to changes in table column widths.
	     *
	     * @returns {Function} A function that unsubscribes the subscriber from the store.
	     */
	    subscribeToColumnWidths: PublisherSubscribeFunc<EuiTableStoreColumnWidthsMap>;
	    /**
	     * Get all registered columns as a readonly map.
	     */
	    getColumns: () => EuiTableStoreColumnsMap;
	    /**
	     * Get all column widths as a readonly map.
	     */
	    getColumnWidths: () => EuiTableStoreColumnWidthsMap;
	}
	export const createEuiTableStore: () => EuiTableStore;
	export {};

}
declare module '@elastic/eui/src/components/table/store/provider' {
	import React, { type PropsWithChildren } from 'react';
	import { EuiTableStore } from '@elastic/eui/src/components/table/store/store';
	/**
	 * @internal
	 */
	export const EuiTableStoreProvider: ({ children }: PropsWithChildren) => React.JSX.Element;
	/**
	 * @internal
	 */
	export const useEuiTableColumnDataStore: () => EuiTableStore;

}
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/table/sticky_header/context' {
	import React, { PropsWithChildren } from 'react';
	/**
	 * React context provider to detect whether a component is rendered
	 * inside <EuiTableStickyHeader> to prevent duplicated header cell renders.
	 * @internal
	 */
	export const EuiTableWithinStickyHeaderProvider: ({ children, }: PropsWithChildren) => React.JSX.Element;
	/**
	 * Returns true if the component (usually the EuiTableHeaderCell or EuiTableHeaderCellCheckbox)
	 * is rendered inside EuiTableStickyHeader.
	 * @internal
	 */
	export const useEuiTableWithinStickyHeader: () => boolean;

}
declare module '@elastic/eui/src/components/table/sticky_header/sticky_header.styles' {
	import type { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTableStickyHeaderStyles: ({ euiTheme }: UseEuiTheme) => {
	    wrapper: import("@emotion/react").SerializedStyles;
	    innerWrapper: import("@emotion/react").SerializedStyles;
	    table: import("@emotion/react").SerializedStyles;
	    header: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/table/sticky_header/sticky_header' {
	import React, { type RefObject } from 'react';
	import type { EuiTableProps } from '@elastic/eui/src/components/table/table';
	/**
	 * @internal
	 */
	export interface EuiTableStickyHeaderProps extends Pick<EuiTableProps, 'scrollableInline' | 'compressed'> {
	    tableRef: RefObject<HTMLTableElement>;
	    tableWrapperRef: RefObject<HTMLDivElement>;
	    isResponsive: boolean;
	}
	export const EuiTableStickyHeader: ({ tableRef, tableWrapperRef, compressed, scrollableInline, isResponsive, }: EuiTableStickyHeaderProps) => React.JSX.Element | null;

}
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;
	    /**
	     * 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
	     * @default 'fixed'
	     */
	    tableLayout?: 'fixed' | 'auto';
	    /**
	     * Toggle the table's background
	     * @default true
	     */
	    hasBackground?: boolean;
	    /**
	     * Allow the table to grow over 100% of the container inline size
	     * (width in horizontal writing-mode) and enable scrolling on overflow.
	     *
	     * This should only be used with [`tableLayout`]{@link EuiTableProps#tableLayout}
	     * set to `auto`.
	     * @beta
	     * @default false
	     */
	    scrollableInline?: boolean;
	    /**
	     * Make the horizontal scrollbar visible even if the table is larger
	     * than the viewport height. Useful for long tables when the native browser
	     * scrollbar is at the bottom of the table and hard to reach.
	     *
	     * This prop requires [`scrollableInline`](#scrollableInline) to be `true`.
	     * @beta
	     * @default false
	     */
	    stickyScrollbar?: boolean;
	    /**
	     * When enabled, the table header will stick to the top of the viewport as users
	     * scroll through long tables. This enhances usability by maintaining column
	     * context during vertical scrolling and unifies the scrolling experience
	     * between EuiTable components and EuiDataGrid.
	     *
	     * This feature should be used in places where it's possible for the table
	     * to grow longer than the viewport.
	     *
	     * @beta
	     * @default false
	     */
	    stickyHeader?: boolean;
	}
	/**
	 * EuiTable is a low-level building block component used to render tabular data
	 * in a customized way.
	 *
	 * It should only be used when confirmed that [EuiBasicTable]{@link EuiBasicTable}
	 * and [EuiInMemoryTable]{@link EuiInMemoryTable} are not flexible enough
	 * for the purposes of the job.
	 *
	 * @see {@link https://eui.elastic.co/docs/components/tables/custom/|EuiTable documentation}
	 */
	export const EuiTable: FunctionComponent<EuiTableProps>;

}
declare module '@elastic/eui/src/components/table/table_body' {
	import { FunctionComponent, PropsWithChildren, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiTableBodyProps = PropsWithChildren & CommonProps & {
	    bodyRef?: Ref<HTMLTableSectionElement>;
	};
	export const EuiTableBody: FunctionComponent<EuiTableBodyProps>;

}
declare module '@elastic/eui/src/components/table/table_footer' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const EuiTableFooter: FunctionComponent<PropsWithChildren & CommonProps>;

}
declare module '@elastic/eui/src/components/table/types' {
	/**
	 * @internal
	 */
	export interface EuiTableSharedWidthProps {
	    width?: string | number;
	    minWidth?: string | number;
	    maxWidth?: string | number;
	}
	/**
	 * @internal
	 */
	export interface EuiTableStickyCellOptions {
	    /**
	     * The side the cell should stick to.
	     * In horizontal writing-mode, `start` equals the left side and `end`
	     * the right side.
	     */
	    side: 'start' | 'end';
	}

}
declare module '@elastic/eui/src/components/table/utils' {
	import type { CSSProperties } from 'react';
	import type { EuiTableSharedWidthProps } from '@elastic/eui/src/components/table/types';
	/**
	 * @internal
	 */
	export const WARNING_MESSAGE_WIDTH = "Two `width` properties were provided. Provide only one of `style.width` or `width` to avoid conflicts.";
	/**
	 * @internal
	 */
	export const WARNING_MESSAGE_MIN_WIDTH = "Two `minWidth` properties were provided. Provide only one of `style.minWidth` or `minWidth` to avoid conflicts.";
	/**
	 * @internal
	 */
	export const WARNING_MESSAGE_MAX_WIDTH = "Two `maxWidth` properties were provided. Provide only one of `style.maxWidth` or `maxWidth` to avoid conflicts.";
	/**
	 * @internal
	 */
	export const WARNING_MESSAGE_NOT_RECOMMENDED_UNIT = "Detected not recommended unit (%, vw, cqw, cqi) in cell width settings. Adjust the `width`, `minWidth` and `maxWidth` values to use absolute length units like `em` for text cells or `px` for static elements like icons or plots.";
	/**
	 * @internal
	 */
	export const resolveWidthPropsAsStyle: (style: CSSProperties | undefined, { width: rawWidth, minWidth: rawMinWidth, maxWidth: rawMaxWidth, }: EuiTableSharedWidthProps) => CSSProperties;

}
declare module '@elastic/eui/src/services/popover/types' {
	export type EuiPopoverPosition = 'top' | 'right' | 'bottom' | 'left';

}
declare module '@elastic/eui/src/services/popover/calculate_popover_position' {
	import { EuiPopoverPosition } from '@elastic/eui/src/services/popover/types';
	interface EuiPopoverBoundingBox {
	    top: number;
	    left: number;
	    width: number;
	    height: number;
	}
	interface EuiPopoverAnchorRect extends EuiPopoverBoundingBox {
	    right: number;
	    bottom: number;
	}
	interface EuiPopoverDimensions {
	    width: number;
	    height: number;
	}
	interface EuiPopoverPositionedBox extends EuiPopoverBoundingBox {
	    position: EuiPopoverPosition;
	}
	/**
	 * Determine the best position for a popover that avoids clipping by the window view port.
	 *
	 * @param {Object} anchorBounds - getBoundingClientRect() of the node the popover is tethered to (e.g. a button).
	 * @param {Object} popoverBounds - getBoundingClientRect() of the popover node (e.g. the tooltip).
	 * @param {string} requestedPosition - Position the user wants. One of ["top", "right", "bottom", "left"]
	 * @param {number} buffer - The space between the wrapper and the popover. Also the minimum space between the
	 * popover and the window.
	 * @param {Array} positions - List of acceptable positions. Defaults to ["top", "right", "bottom", "left"].
	 *
	 * @returns {Object} With properties position (one of ["top", "right", "bottom", "left"]), left, top, width, and height.
	 */
	export function calculatePopoverPosition(anchorBounds: EuiPopoverAnchorRect, popoverBounds: EuiPopoverDimensions, requestedPosition: EuiPopoverPosition, buffer?: number, positions?: EuiPopoverPosition[]): EuiPopoverPositionedBox;
	export {};

}
declare module '@elastic/eui/src/services/popover/popover_positioning' {
	import { EuiPopoverPosition } from '@elastic/eui/src/services/popover/types';
	export const POSITIONS: EuiPopoverPosition[];
	interface BoundingBox {
	    [position: string]: number;
	    top: number;
	    right: number;
	    bottom: number;
	    left: number;
	}
	export interface EuiClientRect extends BoundingBox {
	    height: number;
	    width: number;
	}
	interface FindPopoverPositionArgs {
	    anchor: HTMLElement;
	    popover: HTMLElement;
	    align?: EuiPopoverPosition;
	    position: EuiPopoverPosition;
	    forcePosition?: boolean;
	    buffer?: number | [number, number, number, number];
	    offset?: number;
	    allowCrossAxis?: boolean;
	    container?: HTMLElement;
	    arrowConfig?: {
	        arrowWidth: number;
	        arrowBuffer: number;
	    };
	    returnBoundingBox?: boolean;
	}
	interface FindPopoverPositionResult {
	    top: number;
	    left: number;
	    position: EuiPopoverPosition;
	    fit: number;
	    arrow?: Record<EuiPopoverPosition, number | string>;
	    anchorBoundingBox?: EuiClientRect;
	}
	/**
	 * Calculates the absolute positioning (relative to document.body) to place a popover element
	 *
	 * @param anchor {HTMLElement} Element to anchor the popover to
	 * @param popover {HTMLElement} Element containing the popover content
	 * @param position {string} Position the user wants. One of ["top", "right", "bottom", "left"]
	 * @param [forcePosition] {boolean} If true, use only the provided `position` value and don't try any other position
	 * @param [align] {string} Cross-axis alignment. One of ["top", "right", "bottom", "left"]
	 * @param [buffer=16] {number} Minimum distance between the popover and the bounding container
	 * @param [offset=0] {number} Distance between the popover and the anchor
	 * @param [allowCrossAxis=true] {boolean} Whether to allow the popover to be positioned on the cross-axis
	 * @param [container] {HTMLElement} Element the popover must be constrained to fit within
	 * @param [arrowConfig] {{arrowWidth: number, arrowBuffer: number}} If
	 *  present, describes the size & constraints for an arrow element, and the
	 *  function return value will include an `arrow` param with position details
	 *
	 * @returns {FindPopoverPositionResult} absolute page coordinates for the
	 * popover, and the placement's relation to the anchor or undefined
	 * there's no room.
	 */
	export function findPopoverPosition({ anchor, popover, align, position, forcePosition, buffer, offset, allowCrossAxis, container, arrowConfig, returnBoundingBox, }: FindPopoverPositionArgs): FindPopoverPositionResult;
	interface GetPopoverScreenCoordinatesArgs {
	    position: EuiPopoverPosition;
	    align?: EuiPopoverPosition;
	    anchorBoundingBox: EuiClientRect;
	    popoverBoundingBox: EuiClientRect;
	    windowBoundingBox: EuiClientRect;
	    containerBoundingBox: EuiClientRect;
	    arrowConfig?: {
	        arrowWidth: number;
	        arrowBuffer: number;
	    };
	    offset?: number;
	    buffer?: number | [number, number, number, number];
	}
	interface GetPopoverScreenCoordinatesResult {
	    top: number;
	    left: number;
	    fit: number;
	    arrow?: Record<EuiPopoverPosition, number | string>;
	}
	/**
	 * Given a target position and the popover's surrounding context, returns either an
	 * object with {top, left} screen coordinates or `null` if it's not possible to show
	 * content in the target position
	 * @param position {string} the target position, one of ["top", "right", "bottom", "left"]
	 * @param align {string} target alignment on the cross-axis, one of ["top", "right", "bottom", "left"]
	 * @param anchorBoundingBox {Object} bounding box of the anchor element
	 * @param popoverBoundingBox {Object} bounding box of the popover element
	 * @param windowBoundingBox {Object} bounding box of the window
	 * @param containerBoundingBox {Object} bounding box of the container
	 * @param [arrowConfig] {{arrowWidth: number, arrowBuffer: number}} If present, describes the size &
	 *  constraints for an arrow element, and the function return value will include an `arrow` param
	 *  with position details
	 * @param [offset=0] {number} Distance between the popover and the anchor
	 * @param [buffer=0] {number} Minimum distance between the popover's
	 *  placement and the container edge
	 *
	 * @returns {GetPopoverScreenCoordinatesResult}
	 *  object with top/left coordinates, the popover's relative position to the anchor, and how well the
	 *  popover fits in the location (0.0 -> 1.0) coordinates and the popover's relative position, if
	 *  there is no room in this placement then null
	 */
	export function getPopoverScreenCoordinates({ position, align, anchorBoundingBox, popoverBoundingBox, windowBoundingBox, containerBoundingBox, arrowConfig, offset, buffer, }: GetPopoverScreenCoordinatesArgs): GetPopoverScreenCoordinatesResult;
	/**
	 * Finds the client pixel coordinate of each edge for the element's bounding box,
	 * and the bounding box's width & height
	 *
	 * @param {HTMLElement} element
	 * @returns {{top: number, right: number, bottom: number, left: number, height: number, width: number}}
	 */
	export function getElementBoundingBox(element: HTMLElement): EuiClientRect;
	/**
	 * Calculates the available content space between anchor and container
	 *
	 * @param {Object} anchorBoundingBox Client bounding box of the anchor element
	 * @param {Object} containerBoundingBox Client bounding box of the container element
	 * @param {number} buffer Minimum distance between the popover and the bounding container
	 * @param {number} offset Distance between the popover and the anchor
	 * @param {string} offsetSide Side the offset needs to be applied to, one
	 *  of ["top", "right", "bottom", "left"]
	 * @returns {{top: number, right: number, bottom: number, left: number}}
	 */
	export function getAvailableSpace(anchorBoundingBox: BoundingBox, containerBoundingBox: BoundingBox, buffer: number | [number, number, number, number], offset: number, offsetSide: EuiPopoverPosition): BoundingBox;
	/**
	 * Computes the fit (overlap) of the content within the container, fit is in range 0.0 => 1.0
	 * @param contentBoundingBox bounding box of content to calculate fit for
	 * @param containerBoundingBox bounding box of container
	 * @returns {number}
	 */
	export function getVisibleFit(contentBoundingBox: BoundingBox, containerBoundingBox: BoundingBox): number;
	/**
	 * Calculates the intersection space between two bounding boxes
	 *
	 * @param firstBox
	 * @param secondBox
	 * @returns {EuiClientRect}
	 */
	export function intersectBoundingBoxes(firstBox: BoundingBox, secondBox: BoundingBox): EuiClientRect;
	/**
	 * Returns the top-most defined z-index in the element's ancestor hierarchy
	 * relative to the `target` element; if no z-index is defined, returns 0
	 * @param element {HTMLElement}
	 * @param cousin {HTMLElement}
	 * @returns {number}
	 */
	export function getElementZIndex(element: HTMLElement, cousin: HTMLElement): number;
	export {};

}
declare module '@elastic/eui/src/services/popover/popover_arrow.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Arrow clipping/transform/positioning CSS shared between EuiPopover and EuiToolTip
	 */
	export const _popoverArrowStyles: ({ euiTheme, colorMode, highContrastMode }: UseEuiTheme, arrowSize: string) => {
	    _arrowStyles: string;
	    positions: {
	        top: import("@emotion/react").SerializedStyles;
	        bottom: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/services/popover' {
	export { calculatePopoverPosition } from '@elastic/eui/src/services/popover/calculate_popover_position';
	export { findPopoverPosition, getElementZIndex } from '@elastic/eui/src/services/popover/popover_positioning';
	export { _popoverArrowStyles } from '@elastic/eui/src/services/popover/popover_arrow.styles';
	export type { EuiPopoverPosition } from '@elastic/eui/src/services/popover/types';

}
declare module '@elastic/eui/src/components/panel/panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPanelBorderStyles: (euiThemeContext: UseEuiTheme, options?: {
	    borderColor?: string;
	}) => string;
	export const euiPanelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPanel: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    hasShadow: import("@emotion/react").SerializedStyles;
	    hasBorder: import("@emotion/react").SerializedStyles;
	    radius: {
	        none: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	    isClickable: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiToolTipBackgroundColor: (euiTheme: UseEuiTheme["euiTheme"]) => string;
	export const euiToolTipBorderColor: (euiTheme: UseEuiTheme["euiTheme"]) => string;
	export const euiToolTipStyles: (euiThemeContext: UseEuiTheme) => {
	    euiToolTip: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    bottom: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    euiToolTip__arrow: import("@emotion/react").SerializedStyles;
	    arrowPositions: {
	        top: import("@emotion/react").SerializedStyles;
	        bottom: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    euiToolTip__title: import("@emotion/react").SerializedStyles;
	};
	export const euiToolTipAnchorStyles: () => {
	    euiToolTipAnchor: import("@emotion/react").SerializedStyles;
	    block: import("@emotion/react").SerializedStyles;
	    inlineBlock: import("@emotion/react").SerializedStyles;
	    flex: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip_popover' {
	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type ToolTipPositions = 'top' | 'right' | 'bottom' | 'left';
	type Props = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
	    positionToolTip: () => void;
	    children?: ReactNode;
	    title?: ReactNode;
	    popoverRef?: (ref: HTMLDivElement | null) => void;
	    calculatedPosition?: ToolTipPositions;
	};
	export const EuiToolTipPopover: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/services/popover/reposition_on_scroll' {
	type SupportedComponentDefaults = {
	    repositionOnScroll?: boolean;
	};
	type RepositionOnScrollArgs<T extends SupportedComponentDefaults> = {
	    /**
	     * The component's `repositionOnScroll` prop.
	     */
	    repositionOnScroll?: boolean;
	    /**
	     * The function to be called on scroll to reposition the component.
	     */
	    repositionFn: () => void;
	    /**
	     * The component's defaults context.
	     */
	    componentDefaults?: T;
	};
	/**
	 * Returns the value of the `repositionOnScroll` from the props, component's defaults context
	 * or default to `false`.
	 *
	 * @param args The arguments for `getRepositionOnScroll`. See {@link RepositionOnScrollArgs}.
	 * @returns The value of the `repositionOnScroll`.
	 */
	export const getRepositionOnScroll: <T extends SupportedComponentDefaults>(args: RepositionOnScrollArgs<T>) => boolean;
	export type CreateRepositionOnScrollReturnType = {
	    subscribe: () => void;
	    update: () => void;
	    cleanup: () => void;
	};
	/**
	 * Creates a manager for handling `repositionOnScroll` logic in overlay components.
	 * This utility abstracts the adding, updating, and removing of window scroll event listeners.
	 *
	 * @param getArgs A function that returns the arguments for `getRepositionOnScroll`. See {@link RepositionOnScrollArgs}.
	 * @returns An object with `subscribe`, `update`, and `cleanup` methods to manage the scroll listener.
	 */
	export const createRepositionOnScroll: <T extends SupportedComponentDefaults>(getArgs: () => RepositionOnScrollArgs<T>) => CreateRepositionOnScrollReturnType;
	export {};

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip_anchor' {
	import React, { HTMLAttributes, type FocusEvent as ReactFocusEvent } from 'react';
	import type { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip/tool_tip';
	export type EuiToolTipAnchorProps = Omit<HTMLAttributes<HTMLSpanElement>, 'onBlur' | 'onFocus' | 'children'> & Required<Pick<EuiToolTipProps, 'display' | 'children'>> & {
	    onBlur: () => void;
	    onFocus: (e: ReactFocusEvent) => void;
	    isVisible: boolean;
	};
	export const EuiToolTipAnchor: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "onFocus" | "onBlur"> & Required<Pick<EuiToolTipProps, "children" | "display">> & {
	    onBlur: () => void;
	    onFocus: (e: ReactFocusEvent) => void;
	    isVisible: boolean;
	} & React.RefAttributes<HTMLSpanElement>>;

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip_arrow' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { ToolTipPositions } from '@elastic/eui/src/components/tool_tip/tool_tip_popover';
	export const EuiToolTipArrow: FunctionComponent<{
	    position: ToolTipPositions;
	} & HTMLAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip_manager' {
	 class ToolTipManager {
	    toolTipsToHide: Set<Function>;
	    registerTooltip: (hideCallback: Function) => void;
	    deregisterToolTip: (hideCallback: Function) => void;
	}
	export const toolTipManager: ToolTipManager;
	export {};

}
declare module '@elastic/eui/src/components/tool_tip/tool_tip' {
	import React, { ReactElement, ReactNode, type MouseEvent as ReactMouseEvent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { ToolTipPositions } from '@elastic/eui/src/components/tool_tip/tool_tip_popover';
	export const POSITIONS: readonly ["top", "right", "bottom", "left"]; const DISPLAYS: readonly ["inlineBlock", "block", "flex"];
	export const DEFAULT_TOOLTIP_OFFSET = 16;
	export interface EuiToolTipProps extends CommonProps {
	    /**
	     * Passes onto the span wrapping the trigger.
	     */
	    anchorClassName?: string;
	    /**
	     * Passes onto the span wrapping the trigger.
	     */
	    anchorProps?: CommonProps & HTMLAttributes<HTMLSpanElement>;
	    /**
	     * The in-view trigger for your tooltip.
	     */
	    children: ReactElement;
	    /**
	     * Passes onto the tooltip itself, not the trigger.
	     */
	    className?: string;
	    /**
	     * The main content of your tooltip.
	     */
	    content?: ReactNode;
	    /**
	     * Common display alternatives for the anchor wrapper
	     */
	    display?: (typeof DISPLAYS)[number];
	    /**
	     * An optional title for your tooltip.
	     */
	    title?: ReactNode;
	    /**
	     * Unless you provide one, this will be randomly generated.
	     */
	    id?: string;
	    /**
	     * Suggested position. If there is not enough room for it this will be changed.
	     */
	    position?: ToolTipPositions;
	    /**
	     * When `true`, the tooltip's position is re-calculated when the user
	     * scrolls. This supports having fixed-position tooltip anchors.
	     *
	     * When nesting an `EuiTooltip` in a scrollable container, `repositionOnScroll` should be `true`
	     */
	    repositionOnScroll?: boolean;
	    /**
	     * Disables the tooltip content being read by screen readers when focusing the trigger element.
	     * Do not use when the trigger `aria-label` and tooltip `content` can be rephrased to be standalone
	     * information (action & additional information).
	     * Enable this prop only when the trigger has a descriptive label that either duplicates or includes
	     * the tooltip content and would result in repetitive output.
	     * @default false
	     */
	    disableScreenReaderOutput?: boolean;
	    /**
	     * If supplied, called when mouse movement causes the tool tip to be
	     * hidden.
	     */
	    onMouseOut?: (event: ReactMouseEvent<HTMLSpanElement, MouseEvent>) => void;
	    /**
	     * If supplied, called when the trigger loses focus.
	     */
	    onBlur?: () => void;
	    /**
	     * Offset in pixels from the anchor. Defaults to 16.
	     */
	    offset?: number;
	}
	export interface EuiToolTipRef {
	    showToolTip: () => void;
	    hideToolTip: () => void;
	    id: string;
	}
	export const EuiToolTip: React.ForwardRefExoticComponent<EuiToolTipProps & React.RefAttributes<EuiToolTipRef>>;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/accessibility' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_add_data' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/add_to_dashboard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_advanced_settings' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_fleet' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/aggregate' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_bottom' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_bottom_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_bottom_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_center_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_center_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_top' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_top_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/align_top_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/warning' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/analyze_event' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/annotation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_anomaly' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/anomaly_swim_lane' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_apm' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_waterfall' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_app_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/apps' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_single_down' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_single_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_single_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_single_up' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_limit_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_limit_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/article' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/asterisk' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/at' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/archive' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/axis_x' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/axis_y_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/axis_y_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_auditbeat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/background_task' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/flask' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bell' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bell_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/beta' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bolt' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/boxes_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/branch' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/briefcase' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/branch_user' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/broom' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/brush' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bug' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bulb' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/bullseye' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/calendar' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_canvas' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_cases' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_change_point' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_area' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_area_stack' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_bar_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_bar_horizontal_stack' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_bar_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_bar_vertical_stack' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_gauge' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_heatmap' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_line' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_pie' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_tag_cloud' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_threshold' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/check' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/check_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/check_circle_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/popper' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_classification_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/click_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/click_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/clock' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/clock_counter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/clock_control' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cloud' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cloud_drizzle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cloud_stormy' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cloud_sunny' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cluster' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/code' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_code' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/paint_bucket' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/command_line' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/comment' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/compare' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/processor' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_console' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/container' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/continuity_above' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/continuity_above_below' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/continuity_below' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/continuity_within' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/contrast' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/contrast_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/controls' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/copy' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cross_project_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_advanced_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_generic_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_geo_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_multi_metric_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_population_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_create_single_metric_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cross' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_cross_cluster_replication' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cross_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/crosshair' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/money' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/scissors' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_dashboard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/dashed_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_data_visualizer' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/database' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/display' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_devtools' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_discover' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/distribute_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/distribute_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/download' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/drag' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/drag_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/drag_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/document' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/document_edit' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/documentation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/documents' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/dot' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/dot_in_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_double_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chevron_double_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ellipsis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_align_center' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_align_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_align_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_bold' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/list_check' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_distribute_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_distribute_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_heading' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_italic' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_bottom' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_center' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_middle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_item_align_top' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/link' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/list_number' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_position_bottom_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_position_bottom_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_position_top_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_position_top_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/redo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_strike' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text_underline' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/undo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/list_bullet' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/mail' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/empty' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_ems' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/endpoint' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/query' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/eraser' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/error' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/error_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/esql_vis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/log_out' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/maximize' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/upload' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/external' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/eye' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/eye_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/face_happy' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/face_neutral' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/face_sad' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_info' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_filebeat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/filter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/filter_exclude' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/filter_ignore' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/filter_include' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/filter_in_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/flag' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_agent' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/fold' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/folder_close' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/folder_check' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/folder_exclamation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/folder_open' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/frame_next' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/frame_previous' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/full_screen' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/full_screen_exit' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/function' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/gear' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_gis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/read_only' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/globe' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/grab_omnidirectional' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/gradient' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_graph' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/grid' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_grok' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/heart' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_heartbeat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/help' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/home' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/hourglass' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/if' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/info' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/image' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_close' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_edit' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_index_management' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/mapping' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_open' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_index_pattern' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_index_rollup' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_runtime' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_settings' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_time' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/infinity' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/input_output' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/inspect' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ip' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/key' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/keyboard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/query_field' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kql_function' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/query_operand' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/query_selector' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/query_value' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kubernetes_node' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kubernetes_pod' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/rocket' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/layers' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_lens' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/text' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/line_break' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/line_break_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/line_dash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/line_dot' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/line_solid' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/link_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/plus_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/lock' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/lock_open' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pattern' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/log_rate_analysis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_aws' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_aws_mono' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_aerospike' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_apache' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_app_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_azure' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_azure_mono' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_beats' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_business_analytics' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_ceph' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_cloud' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_cloud_ece' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_code' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_codesandbox' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_couchbase' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_docker' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_dropwizard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_elastic' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_elastic_stack' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_elasticsearch' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_enterprise_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_etcd' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_gcp' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_gcp_mono' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_github' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_gmail' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_golang' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_google_g' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_haproxy' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_ibm' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_ibm_mono' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_kafka' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_kibana' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_kubernetes' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_logging' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_logstash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_maps' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_memcached' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_metrics' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_mongodb' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_mysql' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_nginx' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_observability' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_osquery' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_php' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_postgres' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_prometheus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_rabbitmq' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_redis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_security' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_site_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_sketch' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_slack' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_uptime' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_vector_db' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_vulnerability_management' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_webhook' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_windows' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logo_workplace_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_logs' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logstash_filter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logstash_input' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logstash_output' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/queue' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_ml' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnet' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_exclamation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_minus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_plus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_with_exclamation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_with_minus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/magnify_with_plus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_management' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/map' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/waypoint' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/megaphone' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/memory' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/menu' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/menu_down' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/menu_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/menu_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/menu_up' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/merge' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_metricbeat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_metrics' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/minimize' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/minus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/minus_circle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/minus_square' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/mobile' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_monitoring' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/moon' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/move' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/namespace' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/nested' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vector_triangle' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_notebook' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/number' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/wifi_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/wifi' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_outlier_detection_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/package' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_packetbeat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/page_select' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pages_select' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/palette' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/paper_clip' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/partial' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pause' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/payment' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pencil' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/percent' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pin' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pin_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_pipeline' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/pivot' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/play' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/play_filled' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/plugs' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/plus' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/plus_square' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/presentation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_agent' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_cloud_infra' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_dashboard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_discover' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_ml' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_streams_classic' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/product_streams_wired' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/send' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/question' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/quote' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/radar' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_recently_viewed' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/refresh' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/ml_regression_job' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/reporter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_reporting' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/return' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/save' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_saved_objects' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/scale' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_search_profiler' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/section' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_security_analytics' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_security' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/security_signal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/security_signal_detected' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/security_signal_resolved' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/server' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/session_viewer' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/shard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/share' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/significant_events' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/single_metric_viewer' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/snowflake' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_ascending' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_descending' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_down' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sort_up' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sortable' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/spaces' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_spaces' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sparkles' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_sql' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_empty_space' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_fill_space' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_minus_empty' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_minus_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_plus_empty' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_plus_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/stats' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/stop' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/stop_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/stop_slash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/storage' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/string' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/sun' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/swatch_input' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/symlink' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_density_high' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_density_low' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_of_contents' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/tag' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/tear' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/thermometer' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/thumb_down' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/thumb_up' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/timeline' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/timeline_with_arrow' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_timelion' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/refresh_time' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_bottom_in' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_bottom_out' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_left_in' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_left_out' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_top_in' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/transition_top_out' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/trash' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/unfold' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_upgrade_assistant' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_uptime' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/user' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/users' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_users_roles' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/unarchive' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vector_square' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/video_player' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_goal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/chart_metric' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_timelion' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_visual_builder' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_visualize' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_vulnerability_management' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/warning_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_watches' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/web' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/word_wrap' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/word_wrap_disabled' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_workflows' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/workflow' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/app_workplace_search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/wrench' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_alias' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_annotation' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_array' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_binary' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_boolean' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_class' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_completion_suggester' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_constant' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_date' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_dimension' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_element' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_enum' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_enum_member' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_event' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_exception' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_field' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_file' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_flattened' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_function' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_geo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_histogram' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_interface' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_ip' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_join' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_key' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_keyword' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_method' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_metric_counter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_metric_gauge' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_module' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_namespace' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_nested' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_null' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_number' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_object' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_operator' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_package' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_parameter' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_percolator' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_property' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_range' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_rank_feature' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_rank_features' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_repo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_search_type' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_semantic_text' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_shape' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_string' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_struct' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_symbol' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_tag' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_text' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_token_count' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_variable' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_vector_dense' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/token_vector_sparse' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/icon_map' {
	export const typeToPathMap: {
	    accessibility: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/accessibility")>;
	    addDataApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_add_data")>;
	    addToDashboard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/add_to_dashboard")>;
	    advancedSettingsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_advanced_settings")>;
	    agentApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_fleet")>;
	    aggregate: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/aggregate")>;
	    alignBottom: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_bottom")>;
	    alignBottomLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_bottom_left")>;
	    alignBottomRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_bottom_right")>;
	    alignCenterHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_center_horizontal")>;
	    alignCenterVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_center_vertical")>;
	    alignLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_left")>;
	    alignRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_right")>;
	    alignTop: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_top")>;
	    alignTopLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_top_left")>;
	    alignTopRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/align_top_right")>;
	    alert: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/warning")>;
	    analyzeEvent: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/analyze_event")>;
	    annotation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/annotation")>;
	    anomalyChart: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_anomaly")>;
	    chartAnomaly: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_anomaly")>;
	    anomalySwimLane: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/anomaly_swim_lane")>;
	    apmApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_apm")>;
	    apmTrace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_waterfall")>;
	    chartWaterfall: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_waterfall")>;
	    appSearchApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_app_search")>;
	    apps: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/apps")>;
	    arrowDown: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_down")>;
	    chevronSingleDown: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_down")>;
	    arrowLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_left")>;
	    chevronSingleLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_left")>;
	    arrowRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_right")>;
	    chevronSingleRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_right")>;
	    arrowUp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_up")>;
	    chevronSingleUp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_single_up")>;
	    arrowStart: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_limit_left")>;
	    chevronLimitLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_limit_left")>;
	    arrowEnd: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_limit_right")>;
	    chevronLimitRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_limit_right")>;
	    article: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/article")>;
	    asterisk: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/asterisk")>;
	    at: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/at")>;
	    archive: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/archive")>;
	    axisX: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/axis_x")>;
	    axisYLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/axis_y_left")>;
	    axisYRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/axis_y_right")>;
	    auditbeatApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_auditbeat")>;
	    backgroundTask: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/background_task")>;
	    beaker: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/flask")>;
	    bell: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bell")>;
	    bellSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bell_slash")>;
	    beta: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/beta")>;
	    bolt: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bolt")>;
	    boxesHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/boxes_vertical")>;
	    boxesVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/boxes_vertical")>;
	    branch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/branch")>;
	    briefcase: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/briefcase")>;
	    branchUser: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/branch_user")>;
	    broom: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/broom")>;
	    brush: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/brush")>;
	    bug: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bug")>;
	    bulb: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bulb")>;
	    bullseye: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/bullseye")>;
	    calendar: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/calendar")>;
	    canvasApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_canvas")>;
	    casesApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_cases")>;
	    changePointDetection: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_change_point")>;
	    chartChangePoint: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_change_point")>;
	    chartArea: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_area")>;
	    chartAreaStack: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_area_stack")>;
	    chartBarHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_horizontal")>;
	    chartBarHorizontalStack: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_horizontal_stack")>;
	    chartBarVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_vertical")>;
	    chartBarVerticalStack: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_vertical_stack")>;
	    chartGauge: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_gauge")>;
	    chartHeatmap: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_heatmap")>;
	    chartLine: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_line")>;
	    chartPie: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_pie")>;
	    chartTagCloud: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_tag_cloud")>;
	    chartThreshold: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_threshold")>;
	    check: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/check")>;
	    checkCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/check_circle")>;
	    checkInCircleFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/check_circle_fill")>;
	    checkCircleFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/check_circle_fill")>;
	    cheer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/popper")>;
	    popper: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/popper")>;
	    classificationJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_classification_job")>;
	    clickLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/click_left")>;
	    clickRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/click_right")>;
	    clock: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/clock")>;
	    clockCounter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/clock_counter")>;
	    clockControl: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/clock_control")>;
	    cloud: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cloud")>;
	    cloudDrizzle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cloud_drizzle")>;
	    cloudStormy: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cloud_stormy")>;
	    cloudSunny: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cloud_sunny")>;
	    cluster: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cluster")>;
	    code: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/code")>;
	    codeApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_code")>;
	    color: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/paint_bucket")>;
	    paintBucket: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/paint_bucket")>;
	    commandLine: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/command_line")>;
	    comment: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/comment")>;
	    compare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/compare")>;
	    compute: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/processor")>;
	    processor: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/processor")>;
	    console: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/command_line")>;
	    consoleApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_console")>;
	    container: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/container")>;
	    continuityAbove: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/continuity_above")>;
	    continuityAboveBelow: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/continuity_above_below")>;
	    continuityBelow: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/continuity_below")>;
	    continuityWithin: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/continuity_within")>;
	    contrast: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/contrast")>;
	    contrastHigh: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/contrast_fill")>;
	    contrastFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/contrast_fill")>;
	    controls: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/controls")>;
	    controlsHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/controls")>;
	    controlsVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/controls")>;
	    copy: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/copy")>;
	    copyClipboard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/copy")>;
	    crossProjectSearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cross_project_search")>;
	    createAdvancedJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_advanced_job")>;
	    createGenericJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_generic_job")>;
	    createGeoJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_geo_job")>;
	    createMultiMetricJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_multi_metric_job")>;
	    createPopulationJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_population_job")>;
	    createSingleMetricJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_create_single_metric_job")>;
	    cross: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cross")>;
	    crossClusterReplicationApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_cross_cluster_replication")>;
	    crossInCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cross_circle")>;
	    crossCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/cross_circle")>;
	    crosshair: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/crosshair")>;
	    crosshairs: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/crosshair")>;
	    currency: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/money")>;
	    money: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/money")>;
	    cut: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/scissors")>;
	    scissors: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/scissors")>;
	    dashboardApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_dashboard")>;
	    dashedCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/dashed_circle")>;
	    dataVisualizer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_data_visualizer")>;
	    database: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/database")>;
	    desktop: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/display")>;
	    display: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/display")>;
	    devToolsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_devtools")>;
	    diff: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/compare")>;
	    discoverApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_discover")>;
	    distributeHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/distribute_horizontal")>;
	    distributeVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/distribute_vertical")>;
	    download: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/download")>;
	    drag: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/drag")>;
	    dragHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/drag_horizontal")>;
	    dragVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/drag_vertical")>;
	    discuss: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/comment")>;
	    document: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/document")>;
	    documentEdit: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/document_edit")>;
	    documentation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/documentation")>;
	    documents: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/documents")>;
	    dot: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/dot")>;
	    dotInCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/dot_in_circle")>;
	    doubleArrowLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_double_left")>;
	    chevronDoubleLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_double_left")>;
	    doubleArrowRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_double_right")>;
	    chevronDoubleRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chevron_double_right")>;
	    ellipsis: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ellipsis")>;
	    editorAlignCenter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_center")>;
	    textAlignCenter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_center")>;
	    editorAlignLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_left")>;
	    textAlignLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_left")>;
	    editorAlignRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_right")>;
	    textAlignRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_align_right")>;
	    editorBold: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_bold")>;
	    textBold: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_bold")>;
	    editorChecklist: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_check")>;
	    listCheck: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_check")>;
	    editorCodeBlock: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/code")>;
	    editorComment: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/comment")>;
	    editorDistributeHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_distribute_horizontal")>;
	    editorDistributeVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_distribute_vertical")>;
	    editorHeading: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_heading")>;
	    textHeading: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_heading")>;
	    editorItalic: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_italic")>;
	    textItalic: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_italic")>;
	    editorItemAlignBottom: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_bottom")>;
	    editorItemAlignCenter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_center")>;
	    editorItemAlignLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_left")>;
	    editorItemAlignMiddle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_middle")>;
	    editorItemAlignRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_right")>;
	    editorItemAlignTop: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_item_align_top")>;
	    editorLink: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/link")>;
	    editorOrderedList: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_number")>;
	    listNumber: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_number")>;
	    editorPositionBottomLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_position_bottom_left")>;
	    editorPositionBottomRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_position_bottom_right")>;
	    editorPositionTopLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_position_top_left")>;
	    editorPositionTopRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/editor_position_top_right")>;
	    editorRedo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/redo")>;
	    redo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/redo")>;
	    editorStrike: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_strike")>;
	    textStrike: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_strike")>;
	    editorTable: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table")>;
	    table: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table")>;
	    editorUnderline: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_underline")>;
	    textUnderline: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text_underline")>;
	    editorUndo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/undo")>;
	    undo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/undo")>;
	    editorUnorderedList: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_bullet")>;
	    listBullet: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_bullet")>;
	    email: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/mail")>;
	    mail: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/mail")>;
	    empty: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/empty")>;
	    emsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_ems")>;
	    endpoint: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/endpoint")>;
	    eql: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query")>;
	    query: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query")>;
	    eraser: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/eraser")>;
	    error: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/error")>;
	    errorFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/error_fill")>;
	    errorFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/error_fill")>;
	    esqlVis: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/esql_vis")>;
	    exit: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/log_out")>;
	    logOut: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/log_out")>;
	    expand: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/maximize")>;
	    maximize: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/maximize")>;
	    expandMini: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/maximize")>;
	    export: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/upload")>;
	    exportAction: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/upload")>;
	    upload: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/upload")>;
	    external: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/external")>;
	    eye: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/eye")>;
	    eyeClosed: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/eye_slash")>;
	    eyeSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/eye_slash")>;
	    faceHappy: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/face_happy")>;
	    faceNeutral: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/face_neutral")>;
	    faceSad: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/face_sad")>;
	    fieldStatistics: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_info")>;
	    tableInfo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_info")>;
	    filebeatApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_filebeat")>;
	    filter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/filter")>;
	    filterExclude: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/filter_exclude")>;
	    filterIgnore: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/filter_ignore")>;
	    filterInclude: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/filter_include")>;
	    filterInCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/filter_in_circle")>;
	    flask: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/flask")>;
	    flag: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/flag")>;
	    fleetApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_agent")>;
	    fold: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/fold")>;
	    folder: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_close")>;
	    folderClosed: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_close")>;
	    folderClose: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_close")>;
	    folderCheck: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_check")>;
	    folderExclamation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_exclamation")>;
	    folderOpen: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_open")>;
	    folderOpened: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/folder_open")>;
	    frameNext: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/frame_next")>;
	    framePrevious: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/frame_previous")>;
	    fullScreen: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/full_screen")>;
	    fullScreenExit: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/full_screen_exit")>;
	    function: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/function")>;
	    gear: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/gear")>;
	    gisApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_gis")>;
	    glasses: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/read_only")>;
	    globe: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/globe")>;
	    grab: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/drag_vertical")>;
	    grabHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/drag_horizontal")>;
	    grabOmnidirectional: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/grab_omnidirectional")>;
	    gradient: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/gradient")>;
	    graphApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_graph")>;
	    grid: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/grid")>;
	    grokApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_grok")>;
	    heart: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/heart")>;
	    heartbeatApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_heartbeat")>;
	    heatmap: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_heatmap")>;
	    help: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/help")>;
	    home: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/home")>;
	    hourglass: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/hourglass")>;
	    if: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/if")>;
	    info: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/info")>;
	    image: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/image")>;
	    importAction: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/download")>;
	    index: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index")>;
	    indexClose: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index_close")>;
	    indexEdit: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index_edit")>;
	    indexFlush: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_threshold")>;
	    indexManagementApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_index_management")>;
	    indexMapping: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/mapping")>;
	    mapping: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/mapping")>;
	    indexOpen: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index_open")>;
	    indexPatternApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_index_pattern")>;
	    indexRollupApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_index_rollup")>;
	    indexRuntime: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index_runtime")>;
	    indexSettings: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/index_settings")>;
	    indexTemporary: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_time")>;
	    tableTime: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_time")>;
	    infinity: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/infinity")>;
	    inputOutput: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/input_output")>;
	    inspect: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/inspect")>;
	    invert: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/contrast")>;
	    ip: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ip")>;
	    key: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/key")>;
	    keyboard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/keyboard")>;
	    kqlField: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_field")>;
	    queryField: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_field")>;
	    kqlFunction: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/kql_function")>;
	    kqlOperand: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_operand")>;
	    queryOperand: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_operand")>;
	    kqlSelector: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_selector")>;
	    querySelector: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_selector")>;
	    kqlValue: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_value")>;
	    queryValue: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/query_value")>;
	    kubernetesNode: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/kubernetes_node")>;
	    kubernetesPod: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/kubernetes_pod")>;
	    launch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/rocket")>;
	    rocket: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/rocket")>;
	    layers: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/layers")>;
	    lensApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_lens")>;
	    lettering: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text")>;
	    text: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text")>;
	    lineBreak: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_break")>;
	    lineBreakSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_break_slash")>;
	    lineDash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_dash")>;
	    lineDashed: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_dash")>;
	    lineDot: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_dot")>;
	    lineDotted: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_dot")>;
	    lineSolid: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_solid")>;
	    link: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/link")>;
	    linkSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/link_slash")>;
	    list: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/list_bullet")>;
	    listAdd: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_circle")>;
	    lock: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/lock")>;
	    lockOpen: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/lock_open")>;
	    logPatternAnalysis: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pattern")>;
	    pattern: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pattern")>;
	    logRateAnalysis: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/log_rate_analysis")>;
	    logoAWS: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_aws")>;
	    logoAWSMono: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_aws_mono")>;
	    logoAerospike: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_aerospike")>;
	    logoApache: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_apache")>;
	    logoAppSearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_app_search")>;
	    logoAzure: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_azure")>;
	    logoAzureMono: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_azure_mono")>;
	    logoBeats: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_beats")>;
	    logoBusinessAnalytics: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_business_analytics")>;
	    logoCeph: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_ceph")>;
	    logoCloud: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_cloud")>;
	    logoCloudEnterprise: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_cloud_ece")>;
	    logoCode: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_code")>;
	    logoCodesandbox: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_codesandbox")>;
	    logoCouchbase: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_couchbase")>;
	    logoDocker: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_docker")>;
	    logoDropwizard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_dropwizard")>;
	    logoElastic: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_elastic")>;
	    logoElasticStack: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_elastic_stack")>;
	    logoElasticsearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_elasticsearch")>;
	    logoEnterpriseSearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_enterprise_search")>;
	    logoEtcd: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_etcd")>;
	    logoGCP: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_gcp")>;
	    logoGCPMono: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_gcp_mono")>;
	    logoGithub: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_github")>;
	    logoGmail: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_gmail")>;
	    logoGolang: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_golang")>;
	    logoGoogleG: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_google_g")>;
	    logoHAproxy: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_haproxy")>;
	    logoIBM: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_ibm")>;
	    logoIBMMono: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_ibm_mono")>;
	    logoKafka: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_kafka")>;
	    logoKibana: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_kibana")>;
	    logoKubernetes: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_kubernetes")>;
	    logoLogging: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_logging")>;
	    logoLogstash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_logstash")>;
	    logoMaps: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_maps")>;
	    logoMemcached: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_memcached")>;
	    logoMetrics: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_metrics")>;
	    logoMongodb: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_mongodb")>;
	    logoMySQL: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_mysql")>;
	    logoNginx: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_nginx")>;
	    logoObservability: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_observability")>;
	    logoOsquery: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_osquery")>;
	    logoPhp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_php")>;
	    logoPostgres: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_postgres")>;
	    logoPrometheus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_prometheus")>;
	    logoRabbitmq: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_rabbitmq")>;
	    logoRedis: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_redis")>;
	    logoSecurity: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_security")>;
	    logoSiteSearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_site_search")>;
	    logoSketch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_sketch")>;
	    logoSlack: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_slack")>;
	    logoUptime: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_uptime")>;
	    logoVectorDB: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_vector_db")>;
	    logoVulnerabilityManagement: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_vulnerability_management")>;
	    logoWebhook: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_webhook")>;
	    logoWindows: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_windows")>;
	    logoWorkplaceSearch: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logo_workplace_search")>;
	    logsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_logs")>;
	    logstashFilter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logstash_filter")>;
	    logstashIf: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/if")>;
	    logstashInput: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logstash_input")>;
	    logstashOutput: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/logstash_output")>;
	    logstashQueue: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/queue")>;
	    queue: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/queue")>;
	    machineLearningApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_ml")>;
	    magnet: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnet")>;
	    magnify: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify")>;
	    magnifyExclamation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_exclamation")>;
	    magnifyMinus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_minus")>;
	    magnifyPlus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_plus")>;
	    magnifyWithExclamation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_with_exclamation")>;
	    magnifyWithMinus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_with_minus")>;
	    magnifyWithPlus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify_with_plus")>;
	    managementApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_management")>;
	    map: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/map")>;
	    mapMarker: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/waypoint")>;
	    waypoint: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/waypoint")>;
	    megaphone: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/megaphone")>;
	    memory: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/memory")>;
	    menu: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/menu")>;
	    menuDown: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/menu_down")>;
	    menuLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/menu_left")>;
	    menuRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/menu_right")>;
	    menuUp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/menu_up")>;
	    merge: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/merge")>;
	    metricbeatApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_metricbeat")>;
	    metricsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_metrics")>;
	    minimize: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minimize")>;
	    minus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus")>;
	    minusCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus_circle")>;
	    minusInCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus_circle")>;
	    minusInCircleFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus_circle")>;
	    minusInSquare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus_square")>;
	    minusSquare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/minus_square")>;
	    mobile: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/mobile")>;
	    monitoringApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_monitoring")>;
	    moon: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/moon")>;
	    move: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/move")>;
	    namespace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/namespace")>;
	    nested: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/nested")>;
	    newChat: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_circle")>;
	    node: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vector_triangle")>;
	    vectorTriangle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vector_triangle")>;
	    notebookApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_notebook")>;
	    number: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/number")>;
	    offline: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/wifi_slash")>;
	    wifiSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/wifi_slash")>;
	    online: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/wifi")>;
	    wifi: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/wifi")>;
	    outlierDetectionJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_outlier_detection_job")>;
	    package: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/package")>;
	    packetbeatApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_packetbeat")>;
	    pageSelect: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/page_select")>;
	    pagesSelect: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pages_select")>;
	    palette: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/palette")>;
	    paperClip: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/paper_clip")>;
	    partial: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/partial")>;
	    pause: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pause")>;
	    payment: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/payment")>;
	    pencil: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pencil")>;
	    percent: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/percent")>;
	    pin: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pin")>;
	    pinFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pin_fill")>;
	    pinFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pin_fill")>;
	    pipeBreaks: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_break")>;
	    pipelineApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_pipeline")>;
	    pipeNoBreaks: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/line_break_slash")>;
	    pivot: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/pivot")>;
	    play: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/play")>;
	    playFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/play_filled")>;
	    plugs: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plugs")>;
	    plus: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus")>;
	    plusCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_circle")>;
	    plusInCircle: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_circle")>;
	    plusInCircleFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_circle")>;
	    plusInSquare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_square")>;
	    plusSquare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/plus_square")>;
	    popout: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/external")>;
	    presentation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/presentation")>;
	    productRobot: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_agent")>;
	    productAgent: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_agent")>;
	    productCloudInfra: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_cloud_infra")>;
	    productDashboard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_dashboard")>;
	    productDiscover: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_discover")>;
	    productML: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_ml")>;
	    productStreamsClassic: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_streams_classic")>;
	    productStreamsWired: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_streams_wired")>;
	    push: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/send")>;
	    send: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/send")>;
	    question: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/question")>;
	    quote: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/quote")>;
	    radar: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/radar")>;
	    readOnly: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/read_only")>;
	    recentlyViewedApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_recently_viewed")>;
	    refresh: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/refresh")>;
	    regressionJob: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/ml_regression_job")>;
	    reporter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/reporter")>;
	    reportingApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_reporting")>;
	    return: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/return")>;
	    returnKey: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/return")>;
	    save: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/save")>;
	    savedObjectsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_saved_objects")>;
	    scale: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/scale")>;
	    search: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/magnify")>;
	    searchProfilerApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_search_profiler")>;
	    section: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/section")>;
	    securityAnalyticsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_security_analytics")>;
	    securityApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_security")>;
	    securitySignal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/security_signal")>;
	    securitySignalDetected: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/security_signal_detected")>;
	    securitySignalResolved: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/security_signal_resolved")>;
	    server: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/server")>;
	    sessionViewer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/session_viewer")>;
	    shard: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/shard")>;
	    share: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/share")>;
	    significantEvents: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/significant_events")>;
	    singleMetricViewer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/single_metric_viewer")>;
	    snowflake: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/snowflake")>;
	    sortAscending: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_ascending")>;
	    sortDescending: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_descending")>;
	    sortDown: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_down")>;
	    sortLeft: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_left")>;
	    sortRight: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_right")>;
	    sortUp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sort_up")>;
	    sortable: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sortable")>;
	    spaces: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/spaces")>;
	    spacesApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_spaces")>;
	    sparkles: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sparkles")>;
	    sqlApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_sql")>;
	    star: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star")>;
	    starEmpty: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star")>;
	    starEmptySpace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_empty_space")>;
	    starFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_fill")>;
	    starFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_fill")>;
	    starFillSpace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_fill_space")>;
	    starFilledSpace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_fill_space")>;
	    starMinusEmpty: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_minus_empty")>;
	    starMinusFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_minus_fill")>;
	    starMinusFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_minus_fill")>;
	    starPlusEmpty: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_plus_empty")>;
	    starPlusFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_plus_fill")>;
	    starPlusFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/star_plus_fill")>;
	    stats: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/stats")>;
	    stop: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/stop")>;
	    stopFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/stop_fill")>;
	    stopFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/stop_fill")>;
	    stopSlash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/stop_slash")>;
	    storage: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/storage")>;
	    streamsClassic: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_streams_classic")>;
	    streamsWired: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/product_streams_wired")>;
	    string: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/string")>;
	    submodule: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/merge")>;
	    sun: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/sun")>;
	    swatchInput: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/swatch_input")>;
	    symlink: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/symlink")>;
	    tableDensityCompact: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_density_high")>;
	    tableDensityHigh: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_density_high")>;
	    tableDensityExpanded: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_density_low")>;
	    tableDensityLow: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_density_low")>;
	    tableDensityNormal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table")>;
	    tableOfContents: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table_of_contents")>;
	    tag: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/tag")>;
	    tear: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/tear")>;
	    temperature: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/thermometer")>;
	    thermometer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/thermometer")>;
	    thumbDown: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/thumb_down")>;
	    thumbUp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/thumb_up")>;
	    timeline: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/timeline")>;
	    timelineWithArrow: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/timeline_with_arrow")>;
	    timelionApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_timelion")>;
	    timeRefresh: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/refresh_time")>;
	    refreshTime: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/refresh_time")>;
	    timeslider: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/clock_control")>;
	    training: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/presentation")>;
	    transitionBottomIn: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_bottom_in")>;
	    transitionBottomOut: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_bottom_out")>;
	    transitionLeftIn: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_left_in")>;
	    transitionLeftOut: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_left_out")>;
	    transitionTopIn: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_top_in")>;
	    transitionTopOut: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/transition_top_out")>;
	    trash: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/trash")>;
	    unfold: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/unfold")>;
	    unlink: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/link_slash")>;
	    upgradeAssistantApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_upgrade_assistant")>;
	    uptimeApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_uptime")>;
	    user: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/user")>;
	    userAvatar: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/user")>;
	    users: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/users")>;
	    usersRolesApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_users_roles")>;
	    unarchive: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/unarchive")>;
	    vector: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vector_square")>;
	    vectorSquare: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vector_square")>;
	    videoPlayer: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/video_player")>;
	    visArea: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_area")>;
	    visAreaStacked: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_area_stack")>;
	    visBarHorizontal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_horizontal")>;
	    visBarHorizontalStacked: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_horizontal_stack")>;
	    visBarVertical: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_vertical")>;
	    visBarVerticalStacked: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_bar_vertical_stack")>;
	    visGauge: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_gauge")>;
	    visGoal: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vis_goal")>;
	    visLine: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_line")>;
	    visMapCoordinate: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/waypoint")>;
	    visMapRegion: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/map")>;
	    visMetric: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_metric")>;
	    chartMetric: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_metric")>;
	    visPie: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_pie")>;
	    visTable: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/table")>;
	    visTagCloud: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/chart_tag_cloud")>;
	    visText: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/text")>;
	    visTimelion: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vis_timelion")>;
	    visVega: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/code")>;
	    visVisualBuilder: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/vis_visual_builder")>;
	    visualizeApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_visualize")>;
	    vulnerabilityManagementApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_vulnerability_management")>;
	    warning: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/warning")>;
	    warningFilled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/warning_fill")>;
	    warningFill: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/warning_fill")>;
	    watchesApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_watches")>;
	    web: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/web")>;
	    wordWrap: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/word_wrap")>;
	    wordWrapDisabled: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/word_wrap_disabled")>;
	    workflowsApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_workflows")>;
	    workflow: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/workflow")>;
	    workplaceSearchApp: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/app_workplace_search")>;
	    wrench: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/wrench")>;
	    tokenAlias: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_alias")>;
	    tokenAnnotation: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_annotation")>;
	    tokenArray: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_array")>;
	    tokenBinary: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_binary")>;
	    tokenBoolean: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_boolean")>;
	    tokenClass: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_class")>;
	    tokenCompletionSuggester: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_completion_suggester")>;
	    tokenConstant: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_constant")>;
	    tokenDate: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_date")>;
	    tokenDimension: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_dimension")>;
	    tokenElement: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_element")>;
	    tokenEnum: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_enum")>;
	    tokenEnumMember: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_enum_member")>;
	    tokenEvent: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_event")>;
	    tokenException: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_exception")>;
	    tokenField: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_field")>;
	    tokenFile: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_file")>;
	    tokenFlattened: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_flattened")>;
	    tokenFunction: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_function")>;
	    tokenGeo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_geo")>;
	    tokenHistogram: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_histogram")>;
	    tokenInterface: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_interface")>;
	    tokenIP: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_ip")>;
	    tokenJoin: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_join")>;
	    tokenKey: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_key")>;
	    tokenKeyword: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_keyword")>;
	    tokenMethod: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_method")>;
	    tokenMetricCounter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_metric_counter")>;
	    tokenMetricGauge: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_metric_gauge")>;
	    tokenModule: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_module")>;
	    tokenNamespace: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_namespace")>;
	    tokenNested: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_nested")>;
	    tokenNull: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_null")>;
	    tokenNumber: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_number")>;
	    tokenObject: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_object")>;
	    tokenOperator: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_operator")>;
	    tokenPackage: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_package")>;
	    tokenParameter: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_parameter")>;
	    tokenPercolator: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_percolator")>;
	    tokenProperty: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_property")>;
	    tokenRange: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_range")>;
	    tokenRankFeature: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_rank_feature")>;
	    tokenRankFeatures: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_rank_features")>;
	    tokenRepo: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_repo")>;
	    tokenSearchType: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_search_type")>;
	    tokenSemanticText: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_semantic_text")>;
	    tokenShape: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_shape")>;
	    tokenString: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_string")>;
	    tokenStruct: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_struct")>;
	    tokenSymbol: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_symbol")>;
	    tokenTag: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_tag")>;
	    tokenText: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_text")>;
	    tokenTokenCount: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_token_count")>;
	    tokenVariable: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_variable")>;
	    tokenVectorDense: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_vector_dense")>;
	    tokenDenseVector: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_vector_dense")>;
	    tokenVectorSparse: () => Promise<typeof import ("@elastic/eui/src/components/icon/assets/token_vector_sparse")>;
	};

}
declare module '@elastic/eui/src/services/react' {
	export function enqueueStateChange(fn: Function): void;

}
declare module '@elastic/eui/src/components/icon/named_colors' {
	export const COLORS: readonly ["default", "primary", "neutral", "success", "accent", "accentSecondary", "warning", "risk", "danger", "text", "subdued", "ghost", "inherit"];
	export type NamedColor = (typeof COLORS)[number];
	export function isNamedColor(name: string): boolean;

}
declare module '@elastic/eui/src/components/icon/icon.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const iconLoadingOpacity = 0.05;
	export const euiIconStyles: ({ euiTheme, colorMode }: UseEuiTheme) => {
	    euiIcon: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    accentSecondary: import("@emotion/react").SerializedStyles;
	    ghost: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	    neutral: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    risk: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    inherit: import("@emotion/react").SerializedStyles;
	    default: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	    logoElasticOutline: import("@emotion/react").SerializedStyles;
	    original: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    xxl: import("@emotion/react").SerializedStyles;
	    app: import("@emotion/react").SerializedStyles;
	    logo: import("@emotion/react").SerializedStyles;
	    isLoading: import("@emotion/react").SerializedStyles;
	    isLoaded: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/icon/icon' {
	import React, { PureComponent, ComponentType, SVGAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { typeToPathMap } from '@elastic/eui/src/components/icon/icon_map';
	import { WithEuiStylesMemoizerProps } from '@elastic/eui/src/services';
	export { COLORS } from '@elastic/eui/src/components/icon/named_colors';
	import { NamedColor } from '@elastic/eui/src/components/icon/named_colors';
	export const TYPES: ("string" | "number" | "function" | "article" | "code" | "link" | "map" | "menu" | "search" | "section" | "table" | "filter" | "image" | "pattern" | "stop" | "text" | "at" | "key" | "error" | "warning" | "textHeading" | "scale" | "color" | "refresh" | "push" | "copy" | "cut" | "drag" | "pause" | "play" | "offline" | "online" | "storage" | "temperature" | "display" | "lineBreak" | "wordWrap" | "grid" | "empty" | "invert" | "ellipsis" | "crosshair" | "grab" | "help" | "move" | "spaces" | "dot" | "alert" | "document" | "list" | "presentation" | "email" | "annotation" | "mapping" | "container" | "logoElastic" | "logoVectorDB" | "accessibility" | "addDataApp" | "addToDashboard" | "advancedSettingsApp" | "agentApp" | "aggregate" | "alignBottom" | "alignBottomLeft" | "alignBottomRight" | "alignCenterHorizontal" | "alignCenterVertical" | "alignLeft" | "alignRight" | "alignTop" | "alignTopLeft" | "alignTopRight" | "analyzeEvent" | "anomalyChart" | "chartAnomaly" | "anomalySwimLane" | "apmApp" | "apmTrace" | "chartWaterfall" | "appSearchApp" | "apps" | "arrowDown" | "chevronSingleDown" | "arrowLeft" | "chevronSingleLeft" | "arrowRight" | "chevronSingleRight" | "arrowUp" | "chevronSingleUp" | "arrowStart" | "chevronLimitLeft" | "arrowEnd" | "chevronLimitRight" | "asterisk" | "archive" | "axisX" | "axisYLeft" | "axisYRight" | "auditbeatApp" | "backgroundTask" | "beaker" | "bell" | "bellSlash" | "beta" | "bolt" | "boxesHorizontal" | "boxesVertical" | "branch" | "briefcase" | "branchUser" | "broom" | "brush" | "bug" | "bulb" | "bullseye" | "calendar" | "canvasApp" | "casesApp" | "changePointDetection" | "chartChangePoint" | "chartArea" | "chartAreaStack" | "chartBarHorizontal" | "chartBarHorizontalStack" | "chartBarVertical" | "chartBarVerticalStack" | "chartGauge" | "chartHeatmap" | "chartLine" | "chartPie" | "chartTagCloud" | "chartThreshold" | "check" | "checkCircle" | "checkInCircleFilled" | "checkCircleFill" | "cheer" | "popper" | "classificationJob" | "clickLeft" | "clickRight" | "clock" | "clockCounter" | "clockControl" | "cloud" | "cloudDrizzle" | "cloudStormy" | "cloudSunny" | "cluster" | "codeApp" | "paintBucket" | "commandLine" | "comment" | "compare" | "compute" | "processor" | "console" | "consoleApp" | "continuityAbove" | "continuityAboveBelow" | "continuityBelow" | "continuityWithin" | "contrast" | "contrastHigh" | "contrastFill" | "controls" | "controlsHorizontal" | "controlsVertical" | "copyClipboard" | "crossProjectSearch" | "createAdvancedJob" | "createGenericJob" | "createGeoJob" | "createMultiMetricJob" | "createPopulationJob" | "createSingleMetricJob" | "cross" | "crossClusterReplicationApp" | "crossInCircle" | "crossCircle" | "crosshairs" | "currency" | "money" | "scissors" | "dashboardApp" | "dashedCircle" | "dataVisualizer" | "database" | "desktop" | "devToolsApp" | "diff" | "discoverApp" | "distributeHorizontal" | "distributeVertical" | "download" | "dragHorizontal" | "dragVertical" | "discuss" | "documentEdit" | "documentation" | "documents" | "dotInCircle" | "doubleArrowLeft" | "chevronDoubleLeft" | "doubleArrowRight" | "chevronDoubleRight" | "editorAlignCenter" | "textAlignCenter" | "editorAlignLeft" | "textAlignLeft" | "editorAlignRight" | "textAlignRight" | "editorBold" | "textBold" | "editorChecklist" | "listCheck" | "editorCodeBlock" | "editorComment" | "editorDistributeHorizontal" | "editorDistributeVertical" | "editorHeading" | "editorItalic" | "textItalic" | "editorItemAlignBottom" | "editorItemAlignCenter" | "editorItemAlignLeft" | "editorItemAlignMiddle" | "editorItemAlignRight" | "editorItemAlignTop" | "editorLink" | "editorOrderedList" | "listNumber" | "editorPositionBottomLeft" | "editorPositionBottomRight" | "editorPositionTopLeft" | "editorPositionTopRight" | "editorRedo" | "redo" | "editorStrike" | "textStrike" | "editorTable" | "editorUnderline" | "textUnderline" | "editorUndo" | "undo" | "editorUnorderedList" | "listBullet" | "mail" | "emsApp" | "endpoint" | "eql" | "query" | "eraser" | "errorFilled" | "errorFill" | "esqlVis" | "exit" | "logOut" | "expand" | "maximize" | "expandMini" | "export" | "exportAction" | "upload" | "external" | "eye" | "eyeClosed" | "eyeSlash" | "faceHappy" | "faceNeutral" | "faceSad" | "fieldStatistics" | "tableInfo" | "filebeatApp" | "filterExclude" | "filterIgnore" | "filterInclude" | "filterInCircle" | "flask" | "flag" | "fleetApp" | "fold" | "folder" | "folderClosed" | "folderClose" | "folderCheck" | "folderExclamation" | "folderOpen" | "folderOpened" | "frameNext" | "framePrevious" | "fullScreen" | "fullScreenExit" | "gear" | "gisApp" | "glasses" | "globe" | "grabHorizontal" | "grabOmnidirectional" | "gradient" | "graphApp" | "grokApp" | "heart" | "heartbeatApp" | "heatmap" | "home" | "hourglass" | "if" | "info" | "importAction" | "index" | "indexClose" | "indexEdit" | "indexFlush" | "indexManagementApp" | "indexMapping" | "indexOpen" | "indexPatternApp" | "indexRollupApp" | "indexRuntime" | "indexSettings" | "indexTemporary" | "tableTime" | "infinity" | "inputOutput" | "inspect" | "ip" | "keyboard" | "kqlField" | "queryField" | "kqlFunction" | "kqlOperand" | "queryOperand" | "kqlSelector" | "querySelector" | "kqlValue" | "queryValue" | "kubernetesNode" | "kubernetesPod" | "launch" | "rocket" | "layers" | "lensApp" | "lettering" | "lineBreakSlash" | "lineDash" | "lineDashed" | "lineDot" | "lineDotted" | "lineSolid" | "linkSlash" | "listAdd" | "lock" | "lockOpen" | "logPatternAnalysis" | "logRateAnalysis" | "logoAWS" | "logoAWSMono" | "logoAerospike" | "logoApache" | "logoAppSearch" | "logoAzure" | "logoAzureMono" | "logoBeats" | "logoBusinessAnalytics" | "logoCeph" | "logoCloud" | "logoCloudEnterprise" | "logoCode" | "logoCodesandbox" | "logoCouchbase" | "logoDocker" | "logoDropwizard" | "logoElasticStack" | "logoElasticsearch" | "logoEnterpriseSearch" | "logoEtcd" | "logoGCP" | "logoGCPMono" | "logoGithub" | "logoGmail" | "logoGolang" | "logoGoogleG" | "logoHAproxy" | "logoIBM" | "logoIBMMono" | "logoKafka" | "logoKibana" | "logoKubernetes" | "logoLogging" | "logoLogstash" | "logoMaps" | "logoMemcached" | "logoMetrics" | "logoMongodb" | "logoMySQL" | "logoNginx" | "logoObservability" | "logoOsquery" | "logoPhp" | "logoPostgres" | "logoPrometheus" | "logoRabbitmq" | "logoRedis" | "logoSecurity" | "logoSiteSearch" | "logoSketch" | "logoSlack" | "logoUptime" | "logoVulnerabilityManagement" | "logoWebhook" | "logoWindows" | "logoWorkplaceSearch" | "logsApp" | "logstashFilter" | "logstashIf" | "logstashInput" | "logstashOutput" | "logstashQueue" | "queue" | "machineLearningApp" | "magnet" | "magnify" | "magnifyExclamation" | "magnifyMinus" | "magnifyPlus" | "magnifyWithExclamation" | "magnifyWithMinus" | "magnifyWithPlus" | "managementApp" | "mapMarker" | "waypoint" | "megaphone" | "memory" | "menuDown" | "menuLeft" | "menuRight" | "menuUp" | "merge" | "metricbeatApp" | "metricsApp" | "minimize" | "minus" | "minusCircle" | "minusInCircle" | "minusInCircleFilled" | "minusInSquare" | "minusSquare" | "mobile" | "monitoringApp" | "moon" | "namespace" | "nested" | "newChat" | "node" | "vectorTriangle" | "notebookApp" | "wifiSlash" | "wifi" | "outlierDetectionJob" | "package" | "packetbeatApp" | "pageSelect" | "pagesSelect" | "palette" | "paperClip" | "partial" | "payment" | "pencil" | "percent" | "pin" | "pinFill" | "pinFilled" | "pipeBreaks" | "pipelineApp" | "pipeNoBreaks" | "pivot" | "playFilled" | "plugs" | "plus" | "plusCircle" | "plusInCircle" | "plusInCircleFilled" | "plusInSquare" | "plusSquare" | "popout" | "productRobot" | "productAgent" | "productCloudInfra" | "productDashboard" | "productDiscover" | "productML" | "productStreamsClassic" | "productStreamsWired" | "send" | "question" | "quote" | "radar" | "readOnly" | "recentlyViewedApp" | "regressionJob" | "reporter" | "reportingApp" | "return" | "returnKey" | "save" | "savedObjectsApp" | "searchProfilerApp" | "securityAnalyticsApp" | "securityApp" | "securitySignal" | "securitySignalDetected" | "securitySignalResolved" | "server" | "sessionViewer" | "shard" | "share" | "significantEvents" | "singleMetricViewer" | "snowflake" | "sortAscending" | "sortDescending" | "sortDown" | "sortLeft" | "sortRight" | "sortUp" | "sortable" | "spacesApp" | "sparkles" | "sqlApp" | "star" | "starEmpty" | "starEmptySpace" | "starFill" | "starFilled" | "starFillSpace" | "starFilledSpace" | "starMinusEmpty" | "starMinusFill" | "starMinusFilled" | "starPlusEmpty" | "starPlusFill" | "starPlusFilled" | "stats" | "stopFill" | "stopFilled" | "stopSlash" | "streamsClassic" | "streamsWired" | "submodule" | "sun" | "swatchInput" | "symlink" | "tableDensityCompact" | "tableDensityHigh" | "tableDensityExpanded" | "tableDensityLow" | "tableDensityNormal" | "tableOfContents" | "tag" | "tear" | "thermometer" | "thumbDown" | "thumbUp" | "timeline" | "timelineWithArrow" | "timelionApp" | "timeRefresh" | "refreshTime" | "timeslider" | "training" | "transitionBottomIn" | "transitionBottomOut" | "transitionLeftIn" | "transitionLeftOut" | "transitionTopIn" | "transitionTopOut" | "trash" | "unfold" | "unlink" | "upgradeAssistantApp" | "uptimeApp" | "user" | "userAvatar" | "users" | "usersRolesApp" | "unarchive" | "vector" | "vectorSquare" | "videoPlayer" | "visArea" | "visAreaStacked" | "visBarHorizontal" | "visBarHorizontalStacked" | "visBarVertical" | "visBarVerticalStacked" | "visGauge" | "visGoal" | "visLine" | "visMapCoordinate" | "visMapRegion" | "visMetric" | "chartMetric" | "visPie" | "visTable" | "visTagCloud" | "visText" | "visTimelion" | "visVega" | "visVisualBuilder" | "visualizeApp" | "vulnerabilityManagementApp" | "warningFilled" | "warningFill" | "watchesApp" | "web" | "wordWrapDisabled" | "workflowsApp" | "workflow" | "workplaceSearchApp" | "wrench" | "tokenAlias" | "tokenAnnotation" | "tokenArray" | "tokenBinary" | "tokenBoolean" | "tokenClass" | "tokenCompletionSuggester" | "tokenConstant" | "tokenDate" | "tokenDimension" | "tokenElement" | "tokenEnum" | "tokenEnumMember" | "tokenEvent" | "tokenException" | "tokenField" | "tokenFile" | "tokenFlattened" | "tokenFunction" | "tokenGeo" | "tokenHistogram" | "tokenInterface" | "tokenIP" | "tokenJoin" | "tokenKey" | "tokenKeyword" | "tokenMethod" | "tokenMetricCounter" | "tokenMetricGauge" | "tokenModule" | "tokenNamespace" | "tokenNested" | "tokenNull" | "tokenNumber" | "tokenObject" | "tokenOperator" | "tokenPackage" | "tokenParameter" | "tokenPercolator" | "tokenProperty" | "tokenRange" | "tokenRankFeature" | "tokenRankFeatures" | "tokenRepo" | "tokenSearchType" | "tokenSemanticText" | "tokenShape" | "tokenString" | "tokenStruct" | "tokenSymbol" | "tokenTag" | "tokenText" | "tokenTokenCount" | "tokenVariable" | "tokenVectorDense" | "tokenDenseVector" | "tokenVectorSparse")[];
	export type EuiIconType = keyof typeof typeToPathMap;
	export type IconType = EuiIconType | string | ComponentType;
	export type IconColor = string | NamedColor;
	export const SIZES: readonly ["original", "s", "m", "l", "xl", "xxl"];
	export type IconSize = (typeof SIZES)[number];
	export type EuiIconProps = CommonProps & Omit<SVGAttributes<SVGElement>, 'type' | 'color' | 'size'> & {
	    /**
	     * `Enum` is any of the named icons listed in the docs, `string` is usually a URL to an SVG file, and `elementType` is any React SVG component
	     */
	    type: IconType;
	    /**
	     * One of EUI's color palette or a valid CSS color value https://developer.mozilla.org/en-US/docs/Web/CSS/color_value.
	     * Note that coloring only works if your SVG is removed of fill attributes.
	     */
	    color?: IconColor;
	    /**
	     * Note that every size other than `original` assumes the provided SVG sits on a square viewbox.
	     */
	    size?: IconSize;
	    /**
	     * Descriptive title for naming the icon based on its use
	     */
	    title?: string;
	    /**
	     * A unique identifier for the title element
	     */
	    titleId?: string;
	    /**
	     * Its value should be one or more element IDs
	     */
	    'aria-labelledby'?: string;
	    /**
	     * Callback when the icon has been loaded & rendered
	     */
	    onIconLoad?: () => void;
	};
	interface State {
	    icon: undefined | ComponentType | string;
	    iconTitle: undefined | string;
	    isLoading: boolean;
	    neededLoading: boolean;
	}
	export const clearIconComponentCache: (iconType?: EuiIconType) => void;
	export const appendIconComponentCache: (iconTypeToIconComponentMap: {
	    [iconType: string]: ComponentType;
	}) => void;
	export class EuiIconClass extends PureComponent<EuiIconProps & WithEuiStylesMemoizerProps, State> {
	    isMounted: boolean;
	    constructor(props: EuiIconProps & WithEuiStylesMemoizerProps);
	    componentDidMount(): void;
	    componentDidUpdate(prevProps: EuiIconProps): void;
	    componentWillUnmount(): void;
	    loadIconComponent: (iconType: EuiIconType) => void;
	    onIconLoad: () => void;
	    render(): React.JSX.Element;
	}
	export const EuiIcon: React.ForwardRefExoticComponent<Omit<EuiIconProps, "stylesMemoizer"> & React.RefAttributes<Omit<EuiIconProps, "stylesMemoizer">>>;

}
declare module '@elastic/eui/src/components/icon' {
	export type { EuiIconProps, IconColor, IconSize, IconType } from '@elastic/eui/src/components/icon/icon';
	export { EuiIcon, TYPES as ICON_TYPES, SIZES as ICON_SIZES, COLORS as ICON_COLORS, } from '@elastic/eui/src/components/icon/icon';

}
declare module '@elastic/eui/src/components/tool_tip/icon_tip' {
	import { FunctionComponent } from 'react';
	import { PropsOf } from '@elastic/eui/src/components/common';
	import { EuiIcon, IconSize, IconType } from '@elastic/eui/src/components/icon';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip/tool_tip';
	export type EuiIconTipProps = Omit<EuiToolTipProps, 'children' | 'position'> & {
	    /**
	     * Children are not allowed as they are built using the icon props
	     */
	    children?: never;
	    /**
	     * The icon color.
	     */
	    color?: string;
	    /**
	     * The icon type.
	     */
	    type?: IconType;
	    /**
	     * The icon size.
	     */
	    size?: IconSize;
	    /**
	     * Explain what this icon means for screen readers.
	     */
	    'aria-label'?: string;
	    /**
	     * Pass certain props down to `EuiIcon`
	     */
	    iconProps?: Omit<PropsOf<typeof EuiIcon>, 'type'> & {
	        type?: never;
	    };
	    position?: EuiToolTipProps['position'];
	};
	export const EuiIconTip: FunctionComponent<EuiIconTipProps>;

}
declare module '@elastic/eui/src/components/tool_tip' {
	export type { ToolTipPositions } from '@elastic/eui/src/components/tool_tip/tool_tip_popover';
	export type { EuiToolTipProps, EuiToolTipRef } from '@elastic/eui/src/components/tool_tip/tool_tip';
	export { EuiToolTip } from '@elastic/eui/src/components/tool_tip/tool_tip';
	export type { EuiIconTipProps } from '@elastic/eui/src/components/tool_tip/icon_tip';
	export { EuiIconTip } from '@elastic/eui/src/components/tool_tip/icon_tip';

}
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) => string;
	    truncateEnd: (truncationOffset?: number) => string;
	    truncateStartEndAtPosition: (truncationPosition: number) => string;
	    truncateStartEndAtMiddle: () => string;
	    truncateMiddle: () => string;
	}
	export {};

}
declare module '@elastic/eui/src/components/text_truncate/text_truncate.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTextTruncateStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTextTruncate: import("@emotion/react").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/react").SerializedStyles;
	    euiTextTruncate__fullText: import("@emotion/react").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;
	    /**
	     * 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 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> & {
	    /**
	     * Number of lines of text to truncate to
	     */
	    lines: number;
	    /**
	     * 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.
	     */
	    cloneElement?: boolean;
	};
	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/table_row_cell.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTableRowCellStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTableRowCell: import("@emotion/react").SerializedStyles;
	    rowHeader: import("@emotion/react").SerializedStyles;
	    isExpander: import("@emotion/react").SerializedStyles;
	    hasActions: import("@emotion/react").SerializedStyles;
	    middle: import("@emotion/react").SerializedStyles;
	    baseline: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    bottom: import("@emotion/react").SerializedStyles;
	    desktop: {
	        desktop: import("@emotion/react").SerializedStyles;
	        actions: import("@emotion/react").SerializedStyles;
	    };
	    mobile: {
	        mobile: import("@emotion/react").SerializedStyles;
	        enlarge: import("@emotion/react").SerializedStyles;
	        rightColumnContent: string;
	        readonly actions: import("@emotion/react").SerializedStyles;
	        readonly expander: import("@emotion/react").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/react").SerializedStyles;
	    };
	    euiTableRowCell__mobileHeader: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/table/table_cells_shared.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { EuiTableStickyCellOptions } from '@elastic/eui/src/components/table/types';
	export const euiTableHeaderFooterCellStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTableHeaderCell: import("@emotion/react").SerializedStyles;
	    euiTableHeaderCell__content: import("@emotion/react").SerializedStyles;
	    euiTableHeaderCell__button: import("@emotion/react").SerializedStyles;
	    euiTableFooterCell: {
	        euiTableFooterCell: import("@emotion/react").SerializedStyles;
	        hasBackground: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiTableCellCheckboxStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTableHeaderCellCheckbox: import("@emotion/react").SerializedStyles;
	    euiTableRowCellCheckbox: import("@emotion/react").SerializedStyles;
	    desktop: import("@emotion/react").SerializedStyles;
	    mobile: import("@emotion/react").SerializedStyles;
	};
	/**
	 * @internal
	 */
	export const _useEuiTableStickyCellStyles: (options?: EuiTableStickyCellOptions) => import("@emotion/react").SerializedStyles[] | undefined;

}
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';
	import type { EuiTableStickyCellOptions, EuiTableSharedWidthProps } from '@elastic/eui/src/components/table/types';
	interface EuiTableRowCellSharedPropsShape extends EuiTableSharedWidthProps {
	    /**
	     * 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;
	    };
	}
	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 {@link EuiTableRowCellMobileOptionsShape}
	     */
	    mobileOptions?: EuiTableRowCellMobileOptionsShape;
	    /**
	     * Content rendered outside the visible cell content wrapper. Useful for, e.g. screen reader text.
	     *
	     * Used by EuiBasicTable to render hidden copy markers
	     */
	    append?: ReactNode;
	    /**
	     * Whether the cell should stick to a side of the table.
	     *
	     * This option is not applied in the responsive cards layout - see
	     * {@link EuiTableProps#responsiveBreakpoint|`responsiveBreakpoint`}.
	     *
	     * Currently, it can only be used when the cell is in the first or the last
	     * column of a table.
	     *
	     * When set to `true` and `hasBackground: false` is set on the table,
	     * `--euiTableCellStickyBackgroundColor` CSS variable should be set to match
	     * the background color of the element containing the table.
	     * Otherwise, the sticky cell will use the default `backgroundBasePlain`
	     * background color.
	     * @internal
	     * @beta
	     * @default false
	     */
	    sticky?: EuiTableStickyCellOptions;
	}
	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/react").SerializedStyles;
	    left: null;
	    right: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	    truncateText: import("@emotion/react").SerializedStyles;
	    wrapText: import("@emotion/react").SerializedStyles;
	    hasActions: {
	        actions: import("@emotion/react").SerializedStyles;
	        custom: import("@emotion/react").SerializedStyles;
	        desktop: import("@emotion/react").SerializedStyles;
	        mobile: import("@emotion/react").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_footer_cell' {
	import { FunctionComponent, TdHTMLAttributes } from 'react';
	import { HorizontalAlignment } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTableSharedWidthProps, EuiTableStickyCellOptions } from '@elastic/eui/src/components/table/types';
	export type EuiTableFooterCellProps = CommonProps & Omit<TdHTMLAttributes<HTMLTableCellElement>, 'width'> & EuiTableSharedWidthProps & {
	    align?: HorizontalAlignment;
	    /**
	     * Whether the cell should stick to a side of the table.
	     *
	     * This option is not applied in the responsive cards layout - see
	     * {@link EuiTableProps#responsiveBreakpoint|`responsiveBreakpoint`}.
	     *
	     * Currently, it can only be used when the cell is in the first or the last
	     * column of a table.
	     *
	     * When set to `true` and `hasBackground: false` is set on the table,
	     * `--euiTableCellStickyBackgroundColor` CSS variable should be set to match
	     * the background color of the element containing the table.
	     * Otherwise, the sticky cell will use the default `backgroundBasePlain`
	     * background color.
	     * @internal
	     * @beta
	     * @default false
	     */
	    sticky?: EuiTableStickyCellOptions;
	};
	export const EuiTableFooterCell: FunctionComponent<EuiTableFooterCellProps>;

}
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/services/security/href_validator' {
	export function validateHref(href: string): boolean;

}
declare module '@elastic/eui/src/components/button/button_display/_button_display.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonBaseCSS: () => string;
	export const euiButtonDisplayStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonDisplay: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    defaultMinWidth: {
	        defaultMinWidth: import("@emotion/react").SerializedStyles;
	        xs: string;
	        s: string;
	        m: string;
	    };
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/loading/_loading_strings' {
	export const useLoadingAriaLabel: () => string;

}
declare module '@elastic/eui/src/components/loading/loading_elastic.styles' {
	export const euiLoadingElasticStyles: {
	    euiLoadingElastic: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/loading/loading_elastic' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["m", "l", "xl", "xxl"];
	export type EuiLoadingElasticSize = (typeof SIZES)[number];
	export interface EuiLoadingElasticProps {
	    size?: EuiLoadingElasticSize;
	}
	export const EuiLoadingElastic: FunctionComponent<CommonProps & HTMLAttributes<HTMLDivElement> & EuiLoadingElasticProps>;

}
declare module '@elastic/eui/src/components/loading/loading_chart.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiLoadingChartStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiLoadingChart: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};
	export const BARS_COUNT = 4;
	export const euiLoadingChartBarStyles: (euiThemeContext: UseEuiTheme) => {
	    euiLoadingChart__bar: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/loading/loading_chart' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["m", "l", "xl"];
	export type EuiLoadingChartSize = (typeof SIZES)[number];
	export type EuiLoadingChartProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    size?: EuiLoadingChartSize;
	};
	export const EuiLoadingChart: FunctionComponent<EuiLoadingChartProps>;

}
declare module '@elastic/eui/src/components/loading/loading_spinner.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { EuiLoadingSpinnerColor } from '@elastic/eui/src/components/loading/loading_spinner';
	export const euiSpinnerBorderColorsCSS: ({ euiTheme, highContrastMode }: UseEuiTheme, colors?: EuiLoadingSpinnerColor) => string;
	export const euiLoadingSpinnerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiLoadingSpinner: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    xxl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/loading/loading_spinner' {
	import { HTMLAttributes, FunctionComponent, CSSProperties } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["s", "m", "l", "xl", "xxl"];
	export type EuiLoadingSpinnerSize = (typeof SIZES)[number];
	export type EuiLoadingSpinnerColor = {
	    border?: CSSProperties['color'];
	    highlight?: CSSProperties['color'];
	};
	export type EuiLoadingSpinnerProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'color'> & {
	    size?: EuiLoadingSpinnerSize;
	    /**
	     * Sets the color of the border and highlight.
	     * Each key accepts any valid CSS color value as a `string`
	     * See {@link EuiLoadingSpinnerColor}
	     */
	    color?: EuiLoadingSpinnerColor;
	};
	export const EuiLoadingSpinner: FunctionComponent<EuiLoadingSpinnerProps>;

}
declare module '@elastic/eui/src/components/loading/loading_logo.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiLoadingLogoStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiLoadingLogo: import("@emotion/react").SerializedStyles;
	    euiLoadingLogo__icon: import("@emotion/react").SerializedStyles;
	    /**
	     * 1. Requires pixel math for animation
	     * 2. Add a half the amount of animation distance padding to the top to give it more room
	     */
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/loading/loading_logo' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	export const SIZES: readonly ["m", "l", "xl"];
	export type EuiLoadingLogoSize = (typeof SIZES)[number];
	export type EuiLoadingLogoProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    size?: EuiLoadingLogoSize;
	    /**
	     * While this component should be restricted to using logo icons, it works with any IconType
	     */
	    logo?: IconType;
	};
	export const EuiLoadingLogo: FunctionComponent<EuiLoadingLogoProps>;

}
declare module '@elastic/eui/src/components/loading' {
	export type { EuiLoadingElasticProps } from '@elastic/eui/src/components/loading/loading_elastic';
	export { EuiLoadingElastic } from '@elastic/eui/src/components/loading/loading_elastic';
	export type { EuiLoadingChartProps } from '@elastic/eui/src/components/loading/loading_chart';
	export { EuiLoadingChart } from '@elastic/eui/src/components/loading/loading_chart';
	export type { EuiLoadingSpinnerProps } from '@elastic/eui/src/components/loading/loading_spinner';
	export { EuiLoadingSpinner } from '@elastic/eui/src/components/loading/loading_spinner';
	export type { EuiLoadingLogoProps } from '@elastic/eui/src/components/loading/loading_logo';
	export { EuiLoadingLogo } from '@elastic/eui/src/components/loading/loading_logo';

}
declare module '@elastic/eui/src/components/button/button_display/_button_display_content.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonDisplayContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonDisplayContent: import("@emotion/react").SerializedStyles;
	    content: {
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/button/button_display/_button_display_content' {
	import { HTMLAttributes, FunctionComponent, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiButtonDisplaySizes } from '@elastic/eui/src/components/button/button_display/_button_display';
	export const ICON_SIZES: readonly ["s", "m"];
	export type ButtonContentIconSize = (typeof ICON_SIZES)[number];
	export const ICON_SIDES: readonly ["left", "right"];
	export type ButtonContentIconSide = (typeof ICON_SIDES)[number] | undefined;
	export type EuiButtonDisplayContentType = HTMLAttributes<HTMLSpanElement>;
	/**
	 * *INTERNAL ONLY*
	 * This component is simply a helper component for reuse within other button components.
	 */
	export interface EuiButtonDisplayContentProps extends CommonProps {
	    size?: EuiButtonDisplaySizes;
	    /**
	     * Any `type` accepted by EuiIcon
	     */
	    iconType?: IconType;
	    /**
	     * Can only be one side `left` or `right`
	     */
	    iconSide?: ButtonContentIconSide;
	    isLoading?: boolean;
	    /**
	     * Object of props passed to the `<span>` wrapping the content's text/children only (not icon)
	     *
	     * This span wrapper can be removed by passing `textProps={false}`.
	     */
	    textProps?: (HTMLAttributes<HTMLSpanElement> & CommonProps & {
	        ref?: Ref<HTMLSpanElement>;
	        'data-text'?: string;
	    }) | false;
	    iconSize?: ButtonContentIconSize;
	    isDisabled?: boolean;
	}
	export const EuiButtonDisplayContent: FunctionComponent<EuiButtonDisplayContentType & EuiButtonDisplayContentProps>;

}
declare module '@elastic/eui/src/components/button/button_display/_button_display' {
	import React, { CSSProperties, ReactNode, Ref, ButtonHTMLAttributes } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { CommonProps, ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { EuiButtonDisplayContentProps, EuiButtonDisplayContentType } from '@elastic/eui/src/components/button/button_display/_button_display_content'; const SIZES: readonly ["xs", "s", "m"];
	export type EuiButtonDisplaySizes = (typeof SIZES)[number];
	/**
	 * Extends EuiButtonDisplayContentProps which provides
	 * `iconType`, `iconSide`, and `textProps`
	 */
	export interface EuiButtonDisplayCommonProps extends Omit<EuiButtonDisplayContentProps, 'disabled'>, EuiDisabledProps, CommonProps {
	    element?: 'a' | 'button' | 'span';
	    children?: ReactNode;
	    size?: EuiButtonDisplaySizes;
	    /**
	     * Applies the boolean state as the `aria-pressed` property to create a toggle button.
	     * *Only use when the readable text does not change between states.*
	     */
	    isSelected?: boolean;
	    /**
	     * Extends the button to 100% width
	     */
	    fullWidth?: boolean;
	    /**
	     * Override the default minimum width
	     */
	    minWidth?: CSSProperties['minWidth'] | false;
	    /**
	     * Force disables the button and changes the icon to a loading spinner
	     */
	    isLoading?: boolean;
	    /**
	     * Object of props passed to the <span/> wrapping the button's content
	     */
	    contentProps?: CommonProps & EuiButtonDisplayContentType;
	    style?: CSSProperties;
	    type?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
	}
	export type EuiButtonDisplayPropsForAnchor = PropsForAnchor<EuiButtonDisplayCommonProps, {
	    buttonRef?: Ref<HTMLAnchorElement>;
	}>;
	export type EuiButtonDisplayPropsForButton = PropsForButton<EuiButtonDisplayCommonProps, {
	    buttonRef?: Ref<HTMLButtonElement>;
	}>;
	export type EuiButtonDisplayProps = ExclusiveUnion<EuiButtonDisplayPropsForAnchor, EuiButtonDisplayPropsForButton>;
	export function isButtonDisabled({ href, isDisabled, isLoading, }: {
	    href?: string;
	    isDisabled?: boolean;
	    isLoading?: boolean;
	}): boolean;
	/**
	 * EuiButtonDisplay is an internal-only component used for displaying
	 * any element as a button.
	 */
	export const EuiButtonDisplay: React.ForwardRefExoticComponent<((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiButtonDisplayPropsForAnchor, EuiButtonDisplayPropsForButton> & EuiButtonDisplayCommonProps & {
	    onClick?: React.MouseEventHandler<HTMLButtonElement>;
	} & React.ButtonHTMLAttributes<HTMLButtonElement> & {
	    buttonRef?: Ref<HTMLButtonElement>;
	}) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiButtonDisplayPropsForButton, EuiButtonDisplayPropsForAnchor> & EuiButtonDisplayCommonProps & {
	    href?: string;
	    onClick?: React.MouseEventHandler<HTMLAnchorElement>;
	} & React.AnchorHTMLAttributes<HTMLAnchorElement> & {
	    buttonRef?: Ref<HTMLAnchorElement>;
	})) & React.RefAttributes<HTMLElement>>;
	export {};

}
declare module '@elastic/eui/src/components/button/button' {
	import { FunctionComponent, Ref, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { _EuiExtendedButtonColor } from '@elastic/eui/src/global_styling/mixins/_button';
	import { EuiButtonDisplayCommonProps } from '@elastic/eui/src/components/button/button_display/_button_display';
	export const COLORS: readonly ["text", "accent", "accentSecondary", "primary", "success", "warning", "danger"];
	export type EuiButtonColor = _EuiExtendedButtonColor;
	export const SIZES: readonly ["s", "m"];
	export type EuiButtonSize = (typeof SIZES)[number];
	interface BaseProps extends EuiDisabledProps {
	    children?: ReactNode;
	    /**
	     * Make button a solid color for prominence
	     */
	    fill?: boolean;
	    /**
	     * Any of the named color palette options.
	     *
	     * Do not use the following colors for standalone buttons directly,
	     * they exist to serve other components:
	     *  - accent
	     *  - warning
	     *  - neutral
	     *  - risk
	     */
	    color?: EuiButtonColor;
	    /**
	     * Use size `s` in confined spaces
	     */
	    size?: EuiButtonSize;
	}
	export interface EuiButtonProps extends BaseProps, Omit<EuiButtonDisplayCommonProps, 'size'>, CommonProps {
	}
	export type EuiButtonPropsForAnchor = PropsForAnchor<EuiButtonProps, {
	    buttonRef?: Ref<HTMLAnchorElement>;
	}>;
	export type EuiButtonPropsForButton = EuiButtonDisplayCommonProps & PropsForButton<EuiButtonProps, {
	    buttonRef?: Ref<HTMLButtonElement>;
	}>;
	export type Props = ExclusiveUnion<EuiButtonPropsForAnchor, EuiButtonPropsForButton>;
	/**
	 * EuiButton is largely responsible for providing relevant props
	 * and the logic for element-specific attributes
	 */
	export const EuiButton: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/button/button_empty/button_empty.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonEmptyStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonEmpty: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: (string | import("@emotion/react").SerializedStyles)[];
	    flush: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    both: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/button/button_empty/button_empty' {
	import { FunctionComponent, Ref, ButtonHTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { _EuiExtendedButtonColor } from '@elastic/eui/src/global_styling/mixins/_button';
	import { EuiButtonDisplayContentProps, EuiButtonDisplayContentType } from '@elastic/eui/src/components/button/button_display/_button_display_content';
	export const SIZES: readonly ["xs", "s", "m"];
	export type EuiButtonEmptySizes = (typeof SIZES)[number];
	export const FLUSH_TYPES: readonly ["left", "right", "both"];
	export type EuiButtonEmptyFlush = (typeof FLUSH_TYPES)[number];
	/**
	 * Extends EuiButtonContentProps which provides
	 * `iconType`, `iconSide`, and `textProps`
	 */
	export interface CommonEuiButtonEmptyProps extends EuiButtonDisplayContentProps, EuiDisabledProps, CommonProps {
	    /**
	     * Any of the named color palette options.
	     *
	     * Do not use the following colors for standalone buttons directly,
	     * they exist to serve other components:
	     *  - accent
	     *  - warning
	     *  - neutral
	     *  - risk
	     */
	    color?: _EuiExtendedButtonColor;
	    size?: EuiButtonEmptySizes;
	    /**
	     * Ensure the text of the button sits flush to the left, right, or both sides of its container
	     */
	    flush?: EuiButtonEmptyFlush;
	    /**
	     * Force disables the button and changes the icon to a loading spinner
	     */
	    isLoading?: boolean;
	    /**
	     * Applies the boolean state as the `aria-pressed` property to create a toggle button.
	     * *Only use when the readable text does not change between states.*
	     */
	    isSelected?: boolean;
	    href?: string;
	    target?: string;
	    rel?: string;
	    type?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
	    buttonRef?: Ref<HTMLButtonElement | HTMLAnchorElement>;
	    /**
	     * Object of props passed to the `<span>` wrapping the button's content
	     */
	    contentProps?: CommonProps & EuiButtonDisplayContentType;
	}
	export type EuiButtonEmptyPropsForAnchor = PropsForAnchor<CommonEuiButtonEmptyProps>;
	export type EuiButtonEmptyPropsForButton = PropsForButton<CommonEuiButtonEmptyProps>;
	export type EuiButtonEmptyProps = ExclusiveUnion<EuiButtonEmptyPropsForAnchor, EuiButtonEmptyPropsForButton>;
	export const EuiButtonEmpty: FunctionComponent<EuiButtonEmptyProps>;

}
declare module '@elastic/eui/src/components/button/button_empty' {
	export type { EuiButtonEmptyProps, EuiButtonEmptySizes } from '@elastic/eui/src/components/button/button_empty/button_empty';
	export { EuiButtonEmpty } from '@elastic/eui/src/components/button/button_empty/button_empty';

}
declare module '@elastic/eui/src/components/button/button_icon/button_icon.styles' {
	import { type SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonIconStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonIcon: SerializedStyles;
	    isDisabled: SerializedStyles;
	    xs: SerializedStyles;
	    s: SerializedStyles;
	    m: SerializedStyles;
	};
	export const _emptyHoverStyles: (euiThemeContext: UseEuiTheme) => Record<"text" | "primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "neutral" | "risk", SerializedStyles>;

}
declare module '@elastic/eui/src/components/button/button_icon/button_icon' {
	import { AnchorHTMLAttributes, ButtonHTMLAttributes, FunctionComponent, Ref } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { CommonProps, ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { IconType, IconSize } from '@elastic/eui/src/components/icon';
	import { _EuiExtendedButtonColor } from '@elastic/eui/src/global_styling/mixins/_button';
	export const SIZES: readonly ["xs", "s", "m"];
	export type EuiButtonIconSizes = (typeof SIZES)[number];
	export const DISPLAYS: readonly ["base", "empty", "fill"];
	type EuiButtonIconDisplay = (typeof DISPLAYS)[number];
	export interface EuiButtonIconProps extends CommonProps, EuiDisabledProps {
	    iconType: IconType;
	    /**
	     * Any of the named color palette options.
	     *
	     * Do not use the following colors for standalone buttons directly,
	     * they exist to serve other components:
	     *  - accent
	     *  - warning
	     *  - neutral
	     *  - risk
	     */
	    color?: _EuiExtendedButtonColor;
	    'aria-label'?: string;
	    'aria-labelledby'?: string;
	    /**
	     * Overall size of button.
	     * Matches the sizes of other EuiButtons
	     */
	    size?: EuiButtonIconSizes;
	    /**
	     * Size of the icon only.
	     * This will not affect the overall size of the button
	     */
	    iconSize?: IconSize;
	    /**
	     * Applies the boolean state as the `aria-pressed` property to create a toggle button.
	     * *Only use when the readable text does not change between states.*
	     */
	    isSelected?: boolean;
	    /**
	     * Sets the display style for matching other EuiButton types.
	     * `base` is equivalent to a typical EuiButton
	     * `fill` is equivalent to a filled EuiButton
	     * `empty` (default) is equivalent to an EuiButtonEmpty
	     */
	    display?: EuiButtonIconDisplay;
	    /**
	     * Disables the button and changes the icon to a loading spinner
	     */
	    isLoading?: boolean;
	}
	export type EuiButtonIconPropsForAnchor = {
	    type?: AnchorHTMLAttributes<HTMLAnchorElement>['type'];
	} & PropsForAnchor<EuiButtonIconProps, {
	    buttonRef?: Ref<HTMLAnchorElement>;
	}>;
	export type EuiButtonIconPropsForButton = {
	    type?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
	} & PropsForButton<EuiButtonIconProps, {
	    buttonRef?: Ref<HTMLButtonElement>;
	}>;
	export type Props = ExclusiveUnion<EuiButtonIconPropsForAnchor, EuiButtonIconPropsForButton>;
	export const EuiButtonIcon: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/button/button_icon' {
	export type { EuiButtonIconProps, EuiButtonIconPropsForButton, EuiButtonIconPropsForAnchor, } from '@elastic/eui/src/components/button/button_icon/button_icon';
	export { EuiButtonIcon } from '@elastic/eui/src/components/button/button_icon/button_icon';

}
declare module '@elastic/eui/src/components/button/button_group/button_group_button.styles' {
	import { type SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonGroupButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonGroupButton: SerializedStyles;
	    iconOnly: {
	        iconOnly: SerializedStyles;
	        s: string;
	        m: string;
	        compressed: string;
	    };
	    uncompressed: {
	        uncompressed: SerializedStyles;
	        readonly borders: string;
	        readonly s: SerializedStyles;
	        readonly m: SerializedStyles;
	        hasToolTip: SerializedStyles;
	    };
	    compressed: SerializedStyles;
	    disabledAndSelected: SerializedStyles;
	    hasBorder: string;
	    tooltipWrapper: SerializedStyles;
	    content: {
	        euiButtonGroupButton__content: SerializedStyles;
	        compressed: SerializedStyles;
	    };
	    text: {
	        euiButtonGroupButton__text: SerializedStyles;
	        euiButtonGroupButton__iconOnly: SerializedStyles;
	    };
	};
	export const _compressedButtonFocusColors: (euiThemeContext: UseEuiTheme) => Record<"text" | "primary" | "accent" | "accentSecondary" | "success" | "warning" | "danger" | "disabled", SerializedStyles>;

}
declare module '@elastic/eui/src/components/button/button_group/button_group_button' {
	import { FunctionComponent, MouseEventHandler } from 'react';
	import { EuiButtonDisplayCommonProps } from '@elastic/eui/src/components/button/button_display/_button_display';
	import { EuiButtonGroupOptionProps, EuiButtonGroupProps } from '@elastic/eui/src/components/button/button_group/button_group';
	type Props = EuiButtonGroupOptionProps & {
	    /**
	     * Styles the selected button to look selected (usually with `fill`)
	     */
	    isSelected?: boolean;
	    /**
	     * Inherit from EuiButtonGroup
	     */
	    color: EuiButtonGroupProps['color'];
	    /**
	     * Inherit from EuiButtonGroup
	     */
	    size: NonNullable<EuiButtonGroupProps['buttonSize']>;
	    /**
	     * Inherit from EuiButtonGroup
	     */
	    isIconOnly: EuiButtonGroupProps['isIconOnly'];
	    /**
	     * Inherit from EuiButtonGroup
	     */
	    onClick: MouseEventHandler<HTMLButtonElement>;
	    contentProps?: EuiButtonDisplayCommonProps['contentProps'];
	};
	export const EuiButtonGroupButton: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/form/form.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormMaxWidth: ({ euiTheme }: UseEuiTheme) => string;
	export const euiFormPlaceholderStyles: (euiThemeContext: UseEuiTheme, color?: string) => string;
	export const euiFormVariables: (euiThemeContext: UseEuiTheme) => {
	    animationTiming: string;
	    controlLayoutGroupInputHeight: string;
	    controlLayoutGroupInputCompressedHeight: string;
	    controlLayoutGroupInputCompressedBorderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    controlLayoutBorderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    controlLayoutInnerBorderRadius: string;
	    controlIconSize: {
	        s: string;
	        m: string;
	        l: string;
	        xl: string;
	        xxl: string;
	    };
	    textColor: string;
	    textColorDisabled: string;
	    backgroundColor: string;
	    backgroundDisabledColor: string;
	    backgroundReadOnlyColor: string;
	    backgroundAutoFilled: string;
	    borderColor: string;
	    borderHovered: string;
	    borderFocused: string;
	    borderInvalid: string;
	    borderInvalidHovered: string;
	    borderAutofilled: string;
	    borderAutofilledHovered: string;
	    controlDisabledColor: string;
	    controlBoxShadow: string;
	    controlPlaceholderText: string;
	    appendPrependBackground: string;
	    labelColor: string;
	    maxWidth: string;
	    controlHeight: string;
	    controlCompressedHeight: string;
	    controlPadding: string;
	    controlCompressedPadding: string;
	    controlBorderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    controlCompressedBorderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    iconAffordance: string;
	    iconCompressedAffordance: string;
	    stateUnderlineHeight: string | number | undefined;
	};
	export const euiFormControlStyles: (euiThemeContext: UseEuiTheme) => {
	    shared: string;
	    uncompressed: string;
	    compressed: string;
	    inGroup: string;
	    formWidth: string;
	    fullWidth: string;
	    invalid: string;
	    focus: string;
	    disabled: string;
	    readOnly: string;
	    autoFill: string;
	};
	export const euiFormControlText: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlDefaultShadow: (euiThemeContext: UseEuiTheme, { withBorder, withBackground, withBackgroundColor, }?: {
	    withBorder?: boolean;
	    withBackground?: boolean;
	    withBackgroundColor?: boolean;
	}) => string;
	export const disableFormControlHoverStyles: () => string;
	export const euiFormControlHoverStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlHighlightBorderStyles = "\n  position: relative;\n  z-index: 1;\n  box-shadow: none;\n  outline: var(--euiFormControlStateWidth) solid var(--euiFormControlStateColor);\n  outline-offset: calc(-1 * var(--euiFormControlStateWidth));\n";
	export const euiFormControlFocusStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlInvalidStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlDisabledStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlReadOnlyStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlAutoFillStyles: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormControlAutofillUnsetStyles = "\n\n";
	export const euiFormControlShowBackgroundLine: (euiThemeContext: UseEuiTheme, color: string) => string;
	/**
	 * Selection custom controls - checkboxes, radios, and switches
	 */
	export const euiFormCustomControlVariables: (euiThemeContext: UseEuiTheme) => {
	    sizes: {
	        control: string;
	        lineHeight: string;
	        labelGap: string;
	    };
	    colors: {
	        unselected: string;
	        unselectedBorder: string;
	        selected: string;
	        selectedBorder: string;
	        selectedIcon: string;
	        disabled: string;
	        disabledBorder: string;
	        disabledIcon: string;
	        disabledLabel: string;
	    };
	    animation: {
	        speed: import("csstype").Property.AnimationDuration<string & {}> | undefined;
	        easing: string;
	    };
	};
	export const euiFormCustomControlStyles: (euiThemeContext: UseEuiTheme) => {
	    wrapper: string;
	    input: {
	        fauxInput: string;
	        focusVisible: string;
	        hasLabel: string;
	        enabled: {
	            selected: string;
	            unselected: string;
	        };
	        disabled: {
	            readonly shared: string;
	            readonly selected: string;
	            readonly unselected: string;
	        };
	        icon: string;
	        hiddenInput: string;
	    };
	    label: {
	        label: string;
	        enabled: string;
	        disabled: string;
	    };
	};

}
declare module '@elastic/eui/src/components/button/button_group/button_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiButtonGroupStyles: {
	    euiButtonGroup: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	};
	export const euiButtonGroupButtonsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiButtonGroup__buttons: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/button/button_group/button_group' {
	import { FunctionComponent, HTMLAttributes, ButtonHTMLAttributes, ReactNode } from 'react';
	import { type EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiButtonColor } from '@elastic/eui/src/global_styling/mixins';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	import { EuiButtonDisplayContentProps } from '@elastic/eui/src/components/button/button_display/_button_display_content';
	export interface EuiButtonGroupOptionProps extends Omit<EuiButtonDisplayContentProps, 'size'>, CommonProps, EuiDisabledProps {
	    /**
	     * Each option must have a unique `id` for maintaining selection
	     */
	    id: string;
	    /**
	     * Each option must have a `label` even for icons which will be applied as the `aria-label`
	     */
	    label: ReactNode;
	    /**
	     * The value of the radio input.
	     */
	    value?: any;
	    /**
	     * The type of the underlying HTML button
	     */
	    type?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
	    /**
	     * By default, will use the button text for the native browser title.
	     *
	     * This can be either customized or unset via `title: ''` if necessary.
	     */
	    title?: ButtonHTMLAttributes<HTMLButtonElement>['title'];
	    /**
	     * Optional custom tooltip content for the button
	     */
	    toolTipContent?: EuiToolTipProps['content'];
	    /**
	     * Optional props to pass to the underlying **[EuiToolTip](/#/display/tooltip)**
	     */
	    toolTipProps?: Partial<Omit<EuiToolTipProps, 'content' | 'children'>>;
	}
	export type EuiButtonGroupProps = CommonProps & EuiDisabledProps & {
	    /**
	     * Typical sizing is `s`. Medium `m` size should be reserved for major features.
	     * `compressed` is meant to be used alongside and within compressed forms.
	     */
	    buttonSize?: 's' | 'm' | 'compressed';
	    /**
	     * Expands the whole group to the full width of the container.
	     * Each button gets equal widths no matter the content
	     */
	    isFullWidth?: boolean;
	    /**
	     * Hides the label to only show the `iconType` provided by the `option`
	     */
	    isIconOnly?: boolean;
	    /**
	     * A hidden group title (required for accessibility)
	     */
	    legend: string;
	    /**
	     * Any of the named color palette options.
	     *
	     * Do not use the following colors for standalone buttons directly,
	     * they exist to serve other components:
	     *  - accent
	     *  - warning
	     */
	    color?: _EuiButtonColor;
	    /**
	     * Actual type is `'single' | 'multi'`.
	     * Determines how the selection of the group should be handled.
	     * With `'single'` only one option can be selected at a time (similar to radio group).
	     * With `'multi'` multiple options selected (similar to checkbox group).
	     */
	    type?: 'single' | 'multi';
	    /**
	     * An array of {@link EuiButtonGroupOptionProps}
	     */
	    options: EuiButtonGroupOptionProps[];
	} & ({
	    /**
	     * Default for `type` is single so it can also be excluded
	     */
	    type?: 'single';
	    /**
	     * @deprecated No longer needed. You can safely remove this prop entirely
	     */
	    name?: string;
	    /**
	     * Styles the selected option to look selected (usually with `fill`)
	     * Required by and only used in `type='single'`.
	     */
	    idSelected: string;
	    /**
	     * Single: Returns the `id` of the clicked option and the `value`
	     */
	    onChange: (id: string, value?: any) => void;
	    idToSelectedMap?: never;
	} | {
	    type: 'multi';
	    /**
	     * A map of `id`s as keys with the selected boolean values.
	     * Required by and only used in `type='multi'`.
	     */
	    idToSelectedMap?: {
	        [id: string]: boolean;
	    };
	    /**
	     * Multi: Returns the `id` of the clicked option
	     */
	    onChange: (id: string) => void;
	    idSelected?: never;
	    /**
	     * @deprecated
	     */
	    name?: never;
	});
	type Props = Omit<HTMLAttributes<HTMLFieldSetElement>, 'onChange' | 'color'> & EuiButtonGroupProps;
	export const EuiButtonGroup: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/button/button_group' {
	export type { EuiButtonGroupOptionProps, EuiButtonGroupProps, } from '@elastic/eui/src/components/button/button_group/button_group';
	export { EuiButtonGroup } from '@elastic/eui/src/components/button/button_group/button_group';

}
declare module '@elastic/eui/src/components/button/split_button/split_button_context' {
	import { EuiDisabledProps } from '@elastic/eui/src/services';
	import { Props as EuiButtonProps } from '@elastic/eui/src/components/button/button';
	export const EuiSplitButtonContext: import("react").Context<EuiDisabledProps & {
	    size: NonNullable<EuiButtonProps["size"]>;
	    color: NonNullable<EuiButtonProps["color"]>;
	    fill: EuiButtonProps["fill"];
	    isLoading?: EuiButtonProps["isLoading"];
	}>;

}
declare module '@elastic/eui/src/components/button/split_button/split_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSplitButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSplitButton: import("@emotion/react").SerializedStyles;
	    fill: import("@emotion/react").SerializedStyles;
	};
	export const euiSplitButtonActionStyles: {
	    euiSplitButtonActionPrimary: import("@emotion/react").SerializedStyles;
	    euiSplitButtonActionSecondary: import("@emotion/react").SerializedStyles;
	};
	export const euiSplitButtonDividerStyles: (euiThemeContext: UseEuiTheme, color: string) => {
	    divider: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/button/split_button/split_button_actions' {
	import { FunctionComponent } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services';
	import { EuiPopover } from '@elastic/eui/src/components/popover';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	import { Props as EuiButtonProps } from '@elastic/eui/src/components/button/button';
	import { type Props as EuiButtonIconProps } from '@elastic/eui/src/components/button/button_icon/button_icon';
	type EuiSplitButtonAction<T> = T & {
	    /**
	     * Enables rendering an `EuiToolTip` with the passed props.
	     */
	    tooltipProps?: Partial<Omit<EuiToolTipProps, 'children'>>;
	};
	export type EuiSplitButtonActionPrimaryProps = EuiDisabledProps & EuiSplitButtonAction<EuiButtonProps | EuiButtonIconProps> & {
	    /**
	     * Toggles the render as `EuiButtonIcon`.
	     */
	    isIconOnly?: boolean;
	};
	export type EuiSplitButtonActionSecondaryProps = EuiDisabledProps & EuiSplitButtonAction<EuiButtonIconProps> & {
	    /**
	     * Enables rendering an `EuiPopover` with the passed props.
	     * When passed the secondary action icon will be fixed to `arrowDown`.
	     */
	    popoverProps?: Omit<EuiPopover['props'], 'button'>;
	};
	export const EuiSplitButtonActionPrimary: FunctionComponent<EuiSplitButtonActionPrimaryProps>;
	export const EuiSplitButtonActionSecondary: FunctionComponent<EuiSplitButtonActionSecondaryProps>;
	export {};

}
declare module '@elastic/eui/src/components/button/split_button/split_button' {
	import React, { FunctionComponent, ReactElement } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiButtonProps } from '@elastic/eui/src/components/button/button';
	import { EuiSplitButtonActionPrimary, EuiSplitButtonActionPrimaryProps, EuiSplitButtonActionSecondary, EuiSplitButtonActionSecondaryProps } from '@elastic/eui/src/components/button/split_button/split_button_actions';
	type EuiSplitButtonCommonProps = EuiDisabledProps & {
	    size?: EuiButtonProps['size'];
	    color?: EuiButtonProps['color'];
	    fill?: EuiButtonProps['fill'];
	    isLoading?: EuiButtonProps['isLoading'];
	};
	export type EuiSplitButtonProps = CommonProps & EuiSplitButtonCommonProps & {
	    children: [
	        ReactElement<EuiSplitButtonActionPrimaryProps, typeof EuiSplitButtonActionPrimary>,
	        ReactElement<EuiSplitButtonActionSecondaryProps, typeof EuiSplitButtonActionSecondary>
	    ];
	};
	export const _EuiSplitButton: FunctionComponent<EuiSplitButtonProps>;
	export const EuiSplitButton: React.FunctionComponent<EuiSplitButtonProps> & {
	    ActionPrimary: React.FunctionComponent<EuiSplitButtonActionPrimaryProps>;
	    ActionSecondary: React.FunctionComponent<EuiSplitButtonActionSecondaryProps>;
	};
	export {};

}
declare module '@elastic/eui/src/components/button/split_button' {
	export type { EuiSplitButtonProps } from '@elastic/eui/src/components/button/split_button/split_button';
	export { EuiSplitButton } from '@elastic/eui/src/components/button/split_button/split_button';
	export type { EuiSplitButtonActionPrimaryProps, EuiSplitButtonActionSecondaryProps, } from '@elastic/eui/src/components/button/split_button/split_button_actions';
	export { EuiSplitButtonActionPrimary, EuiSplitButtonActionSecondary, } from '@elastic/eui/src/components/button/split_button/split_button_actions';

}
declare module '@elastic/eui/src/components/button' {
	export type { EuiButtonColor, EuiButtonSize, EuiButtonProps } from '@elastic/eui/src/components/button/button';
	export { COLORS, EuiButton } from '@elastic/eui/src/components/button/button';
	export type { EuiButtonEmptyProps, EuiButtonEmptySizes } from '@elastic/eui/src/components/button/button_empty';
	export { EuiButtonEmpty } from '@elastic/eui/src/components/button/button_empty';
	export type { EuiButtonIconProps, EuiButtonIconPropsForButton, } from '@elastic/eui/src/components/button/button_icon';
	export { EuiButtonIcon } from '@elastic/eui/src/components/button/button_icon';
	export type { EuiButtonGroupOptionProps, EuiButtonGroupProps, } from '@elastic/eui/src/components/button/button_group';
	export { EuiButtonGroup } from '@elastic/eui/src/components/button/button_group';
	export type { EuiSplitButtonProps, EuiSplitButtonActionPrimaryProps, EuiSplitButtonActionSecondaryProps, } from '@elastic/eui/src/components/button/split_button';
	export { EuiSplitButton } from '@elastic/eui/src/components/button/split_button';

}
declare module '@elastic/eui/src/components/horizontal_rule/horizontal_rule.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHorizontalRuleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHorizontalRule: import("@emotion/react").SerializedStyles;
	    full: import("@emotion/react").SerializedStyles;
	    half: import("@emotion/react").SerializedStyles;
	    quarter: import("@emotion/react").SerializedStyles;
	    none: string;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    xxl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/horizontal_rule/horizontal_rule' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["full", "half", "quarter"];
	export const MARGINS: readonly ["none", "xs", "s", "m", "l", "xl", "xxl"];
	export type EuiHorizontalRuleSize = (typeof SIZES)[number];
	export type EuiHorizontalRuleMargin = (typeof MARGINS)[number];
	export interface EuiHorizontalRuleProps extends CommonProps, HTMLAttributes<HTMLHRElement> {
	    /**
	     * Defines the width of the HR.
	     */
	    size?: EuiHorizontalRuleSize;
	    margin?: EuiHorizontalRuleMargin;
	}
	export const EuiHorizontalRule: FunctionComponent<EuiHorizontalRuleProps>;

}
declare module '@elastic/eui/src/components/horizontal_rule' {
	export type { EuiHorizontalRuleProps } from '@elastic/eui/src/components/horizontal_rule/horizontal_rule';
	export { EuiHorizontalRule } from '@elastic/eui/src/components/horizontal_rule/horizontal_rule';

}
declare module '@elastic/eui/src/components/context_menu/context_menu_item.styles' {
	import { css } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { _EuiExtendedButtonColor } from '@elastic/eui/src/global_styling';
	export const euiContextMenuItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiContextMenuItem: import("@emotion/react").SerializedStyles;
	    layoutAlign: {
	        center: import("@emotion/react").SerializedStyles;
	        top: import("@emotion/react").SerializedStyles;
	        bottom: import("@emotion/react").SerializedStyles;
	    };
	    euiContextMenu__icon: import("@emotion/react").SerializedStyles;
	    text: {
	        euiContextMenuItem__text: import("@emotion/react").SerializedStyles;
	    };
	    euiContextMenuItem__arrow: import("@emotion/react").SerializedStyles;
	    colors: Record<_EuiExtendedButtonColor, ReturnType<typeof css>>;
	};

}
declare module '@elastic/eui/src/components/list_item_layout/_list_item_layout.styles' {
	import { UseEuiTheme } from '@elastic/eui-theme-common';
	export const euiListItemVariables: ({ euiTheme }: UseEuiTheme) => {
	    spacing: {
	        horizontal: string;
	        vertical: string;
	    };
	    textPadding: {
	        horizontal: string;
	        vertical: string;
	    };
	};
	export const euiListItemLayoutStyles: (euiThemeContext: UseEuiTheme) => {
	    euiListItemLayout: import("@emotion/react").SerializedStyles;
	    euiListItemLayout__action: import("@emotion/react").SerializedStyles;
	    euiListItemLayout__content: import("@emotion/react").SerializedStyles;
	    euiListItemLayout__text: import("@emotion/react").SerializedStyles;
	    textWrap: {
	        truncate: import("@emotion/react").SerializedStyles;
	        wrap: import("@emotion/react").SerializedStyles;
	    };
	    euiListItemLayout__prepend: import("@emotion/react").SerializedStyles;
	    euiListItemLayout__append: import("@emotion/react").SerializedStyles;
	    euiListItemLayout__icon: import("@emotion/react").SerializedStyles;
	    isInteractive: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	    buttonIsDisabled: import("@emotion/react").SerializedStyles;
	    isFocused: import("@emotion/react").SerializedStyles;
	    isSelected: import("@emotion/react").SerializedStyles;
	    isSelectedFocused: import("@emotion/react").SerializedStyles;
	    tooltip: {
	        isDisabled: import("@emotion/react").SerializedStyles;
	    };
	    externalIcon: import("@emotion/react").SerializedStyles;
	};
	export const euiListItemLayoutWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiListItemLayout__wrapper: import("@emotion/react").SerializedStyles;
	    hasExtraAction: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox_control.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCheckboxControlStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCheckboxControl: import("@emotion/react").SerializedStyles;
	    enabled: {
	        selected: import("@emotion/react").SerializedStyles;
	        unselected: import("@emotion/react").SerializedStyles;
	        excluded: import("@emotion/react").SerializedStyles;
	    };
	    disabled: {
	        selected: import("@emotion/react").SerializedStyles;
	        unselected: import("@emotion/react").SerializedStyles;
	    };
	    icon: {
	        euiCheckbox__icon: import("@emotion/react").SerializedStyles;
	        check: import("@emotion/react").SerializedStyles;
	        indeterminate: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox_control' {
	import { FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiCheckboxControlProps extends CommonProps {
	    /**
	     * Renders a checked variant.
	     * @default false
	     */
	    checked?: boolean;
	    /**
	     * Renders an indeterminate variant.
	     * This overrides any other variant.
	     * @default false
	     */
	    indeterminate?: boolean;
	    /**
	     * Renders an excluded variant.
	     * This overrides the checked variant.
	     * @default false
	     */
	    excluded?: boolean;
	    /**
	     * Renders a disabled variant.
	     * @default false
	     */
	    disabled?: boolean;
	}
	/**
	 * Presentation-only checkbox control element. Renders a checkbox square and state icon only without functionality.
	 */
	export const EuiCheckboxControl: FunctionComponent<EuiCheckboxControlProps>;

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCheckboxStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCheckbox: import("@emotion/react").SerializedStyles;
	    input: {
	        euiCheckbox__square: import("@emotion/react").SerializedStyles;
	        hasLabel: string;
	        readOnly: import("@emotion/react").SerializedStyles;
	        euiCheckbox__input: import("@emotion/react").SerializedStyles;
	    };
	    label: {
	        euiCheckbox__label: import("@emotion/react").SerializedStyles;
	        enabled: string;
	        disabled: import("@emotion/react").SerializedStyles;
	        readOnly: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox' {
	import { FunctionComponent, ChangeEventHandler, ReactNode, InputHTMLAttributes, LabelHTMLAttributes, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiCheckboxProps extends CommonProps, InputHTMLAttributes<HTMLInputElement> {
	    id: string;
	    checked?: boolean;
	    onChange: ChangeEventHandler<HTMLInputElement>;
	    inputRef?: Ref<HTMLInputElement> | ((element: HTMLInputElement) => void);
	    label?: ReactNode;
	    disabled?: boolean;
	    indeterminate?: boolean;
	    /**
	     * Object of props passed to the `label` element
	     */
	    labelProps?: CommonProps & LabelHTMLAttributes<HTMLLabelElement>;
	}
	export const EuiCheckbox: FunctionComponent<EuiCheckboxProps>;

}
declare module '@elastic/eui/src/components/form/form_label/form_label.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormLabel: (euiThemeContext: UseEuiTheme) => string;
	export const euiFormLabelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormLabel: import("@emotion/react").SerializedStyles;
	    notDisabled: string;
	    invalid: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_fieldset/form_legend.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormLegendStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormLegend: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_fieldset/form_legend' {
	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFormLegendProps = HTMLAttributes<HTMLLegendElement> & CommonProps & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * For a hidden legend that is still visible to the screen reader, set to 'hidden'
	     */
	    display?: 'hidden' | 'visible';
	    compressed?: boolean;
	};
	export const EuiFormLegend: FunctionComponent<EuiFormLegendProps>;

}
declare module '@elastic/eui/src/components/form/form_fieldset/form_fieldset' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormLegendProps } from '@elastic/eui/src/components/form/form_fieldset/form_legend';
	export interface EuiFormFieldsetProps extends CommonProps, HTMLAttributes<HTMLFieldSetElement> {
	    /**
	     * Adds an EuiFormLegend element as the first child
	     */
	    legend?: EuiFormLegendProps;
	}
	export const EuiFormFieldset: FunctionComponent<EuiFormFieldsetProps>;

}
declare module '@elastic/eui/src/components/form/form_fieldset' {
	export type { EuiFormFieldsetProps } from '@elastic/eui/src/components/form/form_fieldset/form_fieldset';
	export { EuiFormFieldset } from '@elastic/eui/src/components/form/form_fieldset/form_fieldset';
	export type { EuiFormLegendProps } from '@elastic/eui/src/components/form/form_fieldset/form_legend';
	export { EuiFormLegend } from '@elastic/eui/src/components/form/form_fieldset/form_legend';

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCheckboxGroupStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCheckboxGroup: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/checkbox/checkbox_group' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiFormFieldsetProps, EuiFormLegendProps } from '@elastic/eui/src/components/form/form_fieldset';
	import { EuiCheckboxProps } from '@elastic/eui/src/components/form/checkbox/checkbox';
	export interface EuiCheckboxGroupOption extends Omit<EuiCheckboxProps, 'checked' | 'onChange'> {
	    id: string;
	}
	export interface EuiCheckboxGroupIdToSelectedMap {
	    [id: string]: boolean;
	}
	type AsDivProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>;
	type WithLegendProps = Omit<EuiFormFieldsetProps, 'onChange'> & {
	    /**
	     * If the individual labels for each radio do not provide a sufficient description, add a legend.
	     * Wraps the group in a `EuiFormFieldset` which adds an `EuiLegend` for titling the whole group.
	     * Accepts an `EuiFormLegendProps` shape.
	     */
	    legend?: EuiFormLegendProps;
	};
	export type EuiCheckboxGroupProps = CommonProps & {
	    options: EuiCheckboxGroupOption[];
	    idToSelectedMap: EuiCheckboxGroupIdToSelectedMap;
	    onChange: (optionId: string) => void;
	    /**
	     * Tightens up the spacing between checkbox rows
	     */
	    compressed?: boolean;
	    /**
	     * Passed down to all child `EuiCheckbox`es
	     */
	    disabled?: boolean;
	} & ExclusiveUnion<AsDivProps, WithLegendProps>;
	export const EuiCheckboxGroup: FunctionComponent<EuiCheckboxGroupProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/checkbox' {
	export type { EuiCheckboxProps } from '@elastic/eui/src/components/form/checkbox/checkbox';
	export { EuiCheckbox } from '@elastic/eui/src/components/form/checkbox/checkbox';
	export type { EuiCheckboxControlProps } from '@elastic/eui/src/components/form/checkbox/checkbox_control';
	export { EuiCheckboxControl } from '@elastic/eui/src/components/form/checkbox/checkbox_control';
	export type { EuiCheckboxGroupProps, EuiCheckboxGroupOption, } from '@elastic/eui/src/components/form/checkbox/checkbox_group';
	export { EuiCheckboxGroup } from '@elastic/eui/src/components/form/checkbox/checkbox_group';

}
declare module '@elastic/eui/src/components/title' {
	export type { EuiTitleProps, EuiTitleSize } from '@elastic/eui/src/components/title/title';
	export { EuiTitle } from '@elastic/eui/src/components/title/title';

}
declare module '@elastic/eui/src/components/flex/flex_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlexGroupStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlexGroup: import("@emotion/react").SerializedStyles;
	    responsive: import("@emotion/react").SerializedStyles;
	    wrap: import("@emotion/react").SerializedStyles;
	    gutterSizes: {
	        none: import("@emotion/react").SerializedStyles;
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	    justifyContent: {
	        flexStart: import("@emotion/react").SerializedStyles;
	        flexEnd: import("@emotion/react").SerializedStyles;
	        spaceEvenly: import("@emotion/react").SerializedStyles;
	        spaceBetween: import("@emotion/react").SerializedStyles;
	        spaceAround: import("@emotion/react").SerializedStyles;
	        center: import("@emotion/react").SerializedStyles;
	    };
	    alignItems: {
	        stretch: import("@emotion/react").SerializedStyles;
	        flexStart: import("@emotion/react").SerializedStyles;
	        flexEnd: import("@emotion/react").SerializedStyles;
	        center: import("@emotion/react").SerializedStyles;
	        baseline: import("@emotion/react").SerializedStyles;
	    };
	    direction: {
	        row: import("@emotion/react").SerializedStyles;
	        rowReverse: import("@emotion/react").SerializedStyles;
	        column: import("@emotion/react").SerializedStyles;
	        columnReverse: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flex/flex_group' {
	import { ComponentPropsWithoutRef, ElementType, PropsWithChildren, ReactElement, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const GUTTER_SIZES: readonly ["none", "xs", "s", "m", "l", "xl"];
	export type EuiFlexGroupGutterSize = (typeof GUTTER_SIZES)[number];
	export const ALIGN_ITEMS: readonly ["stretch", "flexStart", "flexEnd", "center", "baseline"];
	export type FlexGroupAlignItems = (typeof ALIGN_ITEMS)[number];
	export const JUSTIFY_CONTENTS: readonly ["flexStart", "flexEnd", "center", "spaceBetween", "spaceAround", "spaceEvenly"];
	type FlexGroupJustifyContent = (typeof JUSTIFY_CONTENTS)[number];
	export const DIRECTIONS: readonly ["row", "rowReverse", "column", "columnReverse"];
	type FlexGroupDirection = (typeof DIRECTIONS)[number];
	export type EuiFlexGroupProps<TComponent extends ElementType = 'div'> = PropsWithChildren & CommonProps & ComponentPropsWithoutRef<TComponent> & {
	    alignItems?: FlexGroupAlignItems;
	    /**
	     * Customize the component type that is rendered.
	     *
	     * It can be any valid React component type like a tag name string
	     * such as `'div'` or `'span'`, a React component (a function, a class,
	     * or an exotic component like `memo()`).
	     *
	     * `EuiFlexGroup` accepts and forwards all extra props to the custom
	     * component.
	     *
	     * @default "div"
	     */
	    component?: TComponent;
	    direction?: FlexGroupDirection;
	    gutterSize?: EuiFlexGroupGutterSize;
	    justifyContent?: FlexGroupJustifyContent;
	    responsive?: boolean;
	    wrap?: boolean;
	};
	export const EuiFlexGroup: (<TComponent extends ElementType = "div", TComponentRef = ReactElement<any, TComponent>>(props: EuiFlexGroupProps<TComponent> & {
	    ref?: Ref<TComponentRef>;
	}) => ReactElement) & {
	    displayName?: string;
	};
	export {};

}
declare module '@elastic/eui/src/components/flex/flex_grid.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlexGridStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlexGrid: import("@emotion/react").SerializedStyles;
	    responsive: import("@emotion/react").SerializedStyles;
	    direction: {
	        row: import("@emotion/react").SerializedStyles;
	        column: import("@emotion/react").SerializedStyles;
	    };
	    columnCount: {
	        '1': import("@emotion/react").SerializedStyles;
	        '2': import("@emotion/react").SerializedStyles;
	        '3': import("@emotion/react").SerializedStyles;
	        '4': import("@emotion/react").SerializedStyles;
	    };
	    gutterSizes: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	    alignItems: {
	        stretch: import("@emotion/react").SerializedStyles;
	        start: import("@emotion/react").SerializedStyles;
	        end: import("@emotion/react").SerializedStyles;
	        center: import("@emotion/react").SerializedStyles;
	        baseline: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flex/flex_grid' {
	import { HTMLAttributes, ReactNode, FunctionComponent, ElementType } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const DIRECTIONS: readonly ["row", "column"];
	export type FlexGridDirection = (typeof DIRECTIONS)[number];
	export const ALIGN_ITEMS: readonly ["stretch", "start", "end", "center", "baseline"];
	export type FlexGridAlignItems = (typeof ALIGN_ITEMS)[number];
	export const GUTTER_SIZES: readonly ["none", "s", "m", "l", "xl"];
	export type FlexGridGutterSize = (typeof GUTTER_SIZES)[number];
	export interface EuiFlexGridProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Number of columns. Accepts `1-4`
	     */
	    columns?: 1 | 2 | 3 | 4;
	    /**
	     * Flex layouts default to left-right then top-down (`row`).
	     * Change this prop to `column` to create a top-down then left-right display.
	     */
	    direction?: FlexGridDirection;
	    /**
	     * Aligns grid items vertically
	     */
	    alignItems?: FlexGridAlignItems;
	    /**
	     * Space between flex items
	     */
	    gutterSize?: FlexGridGutterSize;
	    /**
	     * Will display each item at full-width on smaller screens
	     */
	    responsive?: boolean;
	    /**
	     * The tag to render
	     * @default div
	     */
	    component?: ElementType;
	}
	export const EuiFlexGrid: FunctionComponent<CommonProps & HTMLAttributes<HTMLDivElement> & EuiFlexGridProps>;

}
declare module '@elastic/eui/src/components/flex/flex_item.styles' {
	export const euiFlexItemStyles: {
	    euiFlexItem: import("@emotion/react").SerializedStyles;
	    growZero: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    growSizes: {
	        '1': import("@emotion/react").SerializedStyles;
	        '2': import("@emotion/react").SerializedStyles;
	        '3': import("@emotion/react").SerializedStyles;
	        '4': import("@emotion/react").SerializedStyles;
	        '5': import("@emotion/react").SerializedStyles;
	        '6': import("@emotion/react").SerializedStyles;
	        '7': import("@emotion/react").SerializedStyles;
	        '8': import("@emotion/react").SerializedStyles;
	        '9': import("@emotion/react").SerializedStyles;
	        '10': import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flex/flex_item' {
	import { ElementType, ComponentPropsWithoutRef, PropsWithChildren, Ref, ReactElement } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFlexItemProps<TComponent extends ElementType = 'div'> = PropsWithChildren & CommonProps & ComponentPropsWithoutRef<TComponent> & {
	    grow?: boolean | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | null;
	    /**
	     * Customize the component type that is rendered.
	     *
	     * It can be any valid React component type like a tag name string
	     * such as `'div'` or `'span'`, a React component (a function, a class,
	     * or an exotic component like `memo()`).
	     *
	     * `<EuiFlexItem>` accepts and forwards all extra props to the custom
	     * component.
	     *
	     * @example
	     * // Renders a <button> element
	     * <EuiFlexItem component="button">
	     *   Submit form
	     * </EuiFlexItem>
	     * @default "div"
	     */
	    component?: TComponent;
	};
	export const EuiFlexItem: (<TComponent extends ElementType, TComponentRef = ReactElement<any, TComponent>>(props: EuiFlexItemProps<TComponent> & {
	    ref?: Ref<TComponentRef>;
	}) => ReactElement) & {
	    displayName?: string;
	};

}
declare module '@elastic/eui/src/components/flex' {
	export type { EuiFlexGroupProps, EuiFlexGroupGutterSize } from '@elastic/eui/src/components/flex/flex_group';
	export { EuiFlexGroup } from '@elastic/eui/src/components/flex/flex_group';
	export type { EuiFlexGridProps } from '@elastic/eui/src/components/flex/flex_grid';
	export { EuiFlexGrid } from '@elastic/eui/src/components/flex/flex_grid';
	export type { EuiFlexItemProps } from '@elastic/eui/src/components/flex/flex_item';
	export { EuiFlexItem } from '@elastic/eui/src/components/flex/flex_item';

}
declare module '@elastic/eui/src/components/form/eui_form_context' {
	import React from 'react';
	export interface FormContextValue {
	    defaultFullWidth: boolean;
	}
	export const FormContext: React.Context<FormContextValue>;
	export function useFormContext(): FormContextValue;

}
declare module '@elastic/eui/src/components/form/described_form_group/described_form_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDescribedFormGroupStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDescribedFormGroup: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    euiDescribedFormGroup__descriptionColumn: import("@emotion/react").SerializedStyles;
	    euiDescribedFormGroup__description: import("@emotion/react").SerializedStyles;
	    euiDescribedFormGroup__fields: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/described_form_group/described_form_group' {
	import { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
	import { CommonProps, PropsOf } from '@elastic/eui/src/components/common';
	import { EuiTitleSize, EuiTitleProps } from '@elastic/eui/src/components/title';
	import { EuiFlexItem, EuiFlexGroupGutterSize } from '@elastic/eui/src/components/flex';
	export type EuiDescribedFormGroupProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
	    /**
	     * One or more `EuiFormRow`s.
	     */
	    children?: ReactNode;
	    /**
	     * Passed to `EuiFlexGroup`.
	     * @default l
	     */
	    gutterSize?: EuiFlexGroupGutterSize;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * Default max-width is 800px.
	     * @default false
	     */
	    fullWidth?: boolean;
	    /**
	     * Width ratio of description column compared to field column.
	     * Can be used in conjunction with `fullWidth` and
	     * may require `fullWidth` to be applied to child elements.
	     * @default half
	     */
	    ratio?: 'half' | 'third' | 'quarter';
	    /**
	     * For better accessibility, it's recommended to use an HTML heading.
	     */
	    title: EuiTitleProps['children'];
	    /**
	     * Adjust the visual `size` of the EuiTitle that wraps `title`.
	     * @default xs
	     */
	    titleSize?: EuiTitleSize;
	    /**
	     * Added as a child of `EuiText`.
	     */
	    description?: ReactNode;
	    /**
	     * For customizing the description container. Extended from `EuiFlexItem`.
	     */
	    descriptionFlexItemProps?: PropsOf<typeof EuiFlexItem>;
	    /**
	     * For customizing the field container. Extended from `EuiFlexItem`.
	     */
	    fieldFlexItemProps?: PropsOf<typeof EuiFlexItem>;
	};
	export const EuiDescribedFormGroup: FunctionComponent<EuiDescribedFormGroupProps>;

}
declare module '@elastic/eui/src/components/form/described_form_group' {
	export type { EuiDescribedFormGroupProps } from '@elastic/eui/src/components/form/described_form_group/described_form_group';
	export { EuiDescribedFormGroup } from '@elastic/eui/src/components/form/described_form_group/described_form_group';

}
declare module '@elastic/eui/src/components/form/validatable_control/validatable_control' {
	import { ReactElement, Ref, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface HTMLConstraintValidityElement extends Element {
	    setCustomValidity: (error: string) => void;
	}
	export interface ReactElementWithRef extends ReactElement {
	    ref?: Ref<HTMLConstraintValidityElement>;
	}
	/**
	 * The `EuiValidatableControl` component should be used in scenarios where
	 * we can render the validated `<input>` as its direct child.
	 */
	export interface EuiValidatableControlProps {
	    isInvalid?: boolean;
	    children: ReactElementWithRef;
	}
	export const EuiValidatableControl: FunctionComponent<CommonProps & EuiValidatableControlProps>;
	/**
	 * The `UseEuiValidatableControl` hook should be used in scenarios where
	 * we *cannot* control where the validated `<input>` is rendered (e.g., ReactDatePicker)
	 * and instead need to access the input via a ref and pass the element in directly
	 */
	export interface UseEuiValidatableControlProps {
	    isInvalid?: boolean;
	    controlEl: HTMLInputElement | HTMLConstraintValidityElement | null;
	}
	export const useEuiValidatableControl: ({ isInvalid, controlEl, }: UseEuiValidatableControlProps) => void;

}
declare module '@elastic/eui/src/components/form/validatable_control' {
	export type { EuiValidatableControlProps, UseEuiValidatableControlProps, } from '@elastic/eui/src/components/form/validatable_control/validatable_control';
	export { EuiValidatableControl, useEuiValidatableControl, } from '@elastic/eui/src/components/form/validatable_control/validatable_control';

}
declare module '@elastic/eui/src/components/form/form_label/form_label' {
	import { FunctionComponent, LabelHTMLAttributes, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	interface EuiFormLabelCommonProps {
	    isFocused?: boolean;
	    isInvalid?: boolean;
	    /**
	     * Changes `cursor` to `default`.
	     */
	    isDisabled?: boolean;
	    /**
	     * Default type is a `label` but can be changed to a `legend`
	     * if using inside a `fieldset`.
	     */
	    type?: 'label' | 'legend' | 'span';
	}
	export type _EuiFormLabelProps = {
	    type?: 'label';
	} & EuiFormLabelCommonProps & CommonProps & LabelHTMLAttributes<HTMLLabelElement>;
	export type _EuiFormLegendProps = {
	    type: 'legend';
	} & EuiFormLabelCommonProps & CommonProps & HTMLAttributes<HTMLLegendElement>;
	export type _EuiFormLabelSpanProps = {
	    type: 'span';
	} & EuiFormLabelCommonProps & CommonProps & HTMLAttributes<HTMLSpanElement>;
	export type EuiFormLabelProps = ExclusiveUnion<ExclusiveUnion<_EuiFormLabelProps, _EuiFormLegendProps>, _EuiFormLabelSpanProps>;
	export const EuiFormLabel: FunctionComponent<EuiFormLabelProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/form_label' {
	export type { EuiFormLabelProps } from '@elastic/eui/src/components/form/form_label/form_label';
	export { EuiFormLabel } from '@elastic/eui/src/components/form/form_label/form_label';

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_clear_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const EuiFormControlLayoutClearButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormControlLayoutClearButton: import("@emotion/react").SerializedStyles;
	    size: {
	        s: string;
	        m: string;
	    };
	    icon: {
	        euiFormControlLayoutClearButton__icon: import("@emotion/react").SerializedStyles;
	        size: {
	            s: import("@emotion/react").SerializedStyles;
	            m: import("@emotion/react").SerializedStyles;
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_clear_button' {
	import { FunctionComponent, ButtonHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFormControlLayoutClearButtonProps = CommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
	    size?: 's' | 'm';
	};
	export const EuiFormControlLayoutClearButton: FunctionComponent<EuiFormControlLayoutClearButtonProps>;

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_custom_icon' {
	import { ButtonHTMLAttributes, FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiIconProps, IconType } from '@elastic/eui/src/components/icon';
	export type EuiFormControlLayoutCustomIconProps = CommonProps & ExclusiveUnion<Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type'>, HTMLAttributes<HTMLSpanElement>> & {
	    type: IconType;
	    size?: EuiIconProps['size'];
	    iconRef?: string | ((el: HTMLButtonElement | HTMLSpanElement | null) => void);
	};
	export const EuiFormControlLayoutCustomIcon: FunctionComponent<EuiFormControlLayoutCustomIconProps>;

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormControlLayoutIconsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormControlLayoutIcons: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    position: {
	        absolute: {
	            absolute: import("@emotion/react").SerializedStyles;
	            uncompressed: {
	                left: import("@emotion/react").SerializedStyles;
	                right: import("@emotion/react").SerializedStyles;
	            };
	            compressed: {
	                left: import("@emotion/react").SerializedStyles;
	                right: import("@emotion/react").SerializedStyles;
	            };
	        };
	        static: {
	            static: import("@emotion/react").SerializedStyles;
	            uncompressed: string;
	            compressed: string;
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons' {
	import React from 'react';
	import { DistributiveOmit } from '@elastic/eui/src/components/common';
	import { IconColor, IconType } from '@elastic/eui/src/components/icon';
	import { EuiFormControlLayoutClearButtonProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_clear_button';
	import { EuiFormControlLayoutCustomIconProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_custom_icon';
	export const ICON_SIDES: readonly ["left", "right"];
	export type IconShape = DistributiveOmit<EuiFormControlLayoutCustomIconProps, 'type' | 'iconRef'> & {
	    type: IconType;
	    side?: (typeof ICON_SIDES)[number];
	    color?: IconColor;
	    ref?: EuiFormControlLayoutCustomIconProps['iconRef'];
	};
	export const isIconShape: (icon: EuiFormControlLayoutIconsProps["icon"]) => icon is IconShape;
	export interface EuiFormControlLayoutIconsProps {
	    icon?: IconType | IconShape;
	    side?: (typeof ICON_SIDES)[number];
	    iconsPosition?: 'absolute' | 'static';
	    clear?: EuiFormControlLayoutClearButtonProps;
	    isLoading?: boolean;
	    isInvalid?: boolean;
	    isDropdown?: boolean;
	    compressed?: boolean;
	    isDisabled?: boolean;
	}
	export const EuiFormControlLayoutIcons: ({ side, iconsPosition, compressed, isDisabled, icon, clear, isLoading, isInvalid, isDropdown, }: EuiFormControlLayoutIconsProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/form/form_control_layout/_num_icons' {
	import { type EuiFormControlLayoutIconsProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons';
	export const isRightSideIcon: (icon?: EuiFormControlLayoutIconsProps["icon"]) => boolean;
	export const getIconAffordanceStyles: ({ icon, clear, isLoading, isInvalid, isDropdown, }: {
	    icon?: EuiFormControlLayoutIconsProps["icon"];
	    clear?: EuiFormControlLayoutIconsProps["clear"] | boolean;
	    isLoading?: boolean;
	    isInvalid?: boolean;
	    isDropdown?: boolean;
	}) => {
	    [k: string]: number;
	} | undefined;

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const buttonSelector = "*:is(.euiButton, .euiButtonEmpty, .euiButtonIcon, .euiFormAppend, .euiFormPrepend)";
	export const textSelector = "*:is(.euiFormLabel, .euiText)";
	export const appendPrependSelector = "*:is(.euiFormAppend, .euiFormPrepend)";
	export const euiFormControlLayoutStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormControlLayout: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    group: {
	        group: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compressed: string;
	    };
	    children: {
	        euiFormControlLayout__childrenWrapper: import("@emotion/react").SerializedStyles;
	        inGroup: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiFormControlLayoutSideNodeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormControlLayout__side: import("@emotion/react").SerializedStyles;
	    uncompressed: {
	        uncompressed: string;
	        append: string;
	        prepend: string;
	    };
	    compressed: {
	        compressed: import("@emotion/react").SerializedStyles;
	        append: string;
	        prepend: string;
	    };
	    disabled: import("@emotion/react").SerializedStyles;
	    readOnly: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_control_layout/append_prepend/form_append_prepend.styles' {
	import { UseEuiTheme } from '@elastic/eui-theme-common';
	export const euiFormAppendPrependStyles: (euiThemeContext: UseEuiTheme) => {
	    side: import("@emotion/react").SerializedStyles;
	    uncompressed: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	    wrapper: import("@emotion/react").SerializedStyles;
	    isInteractive: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_context' {
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout';
	type FormControlLayoutContext = Pick<EuiFormControlLayoutProps, 'compressed' | 'inputId' | 'isDisabled' | 'isInvalid' | 'readOnly' | 'isLoading'>;
	/**
	 * Context to share props between `EuiFormControlLayout` and passed children like e.g. EuiFormAppend/Prepend
	 */
	export const EuiFormControlLayoutContext: import("react").Context<FormControlLayoutContext>;
	export const EuiFormControlLayoutContextProvider: import("react").Provider<FormControlLayoutContext>;
	export {};

}
declare module '@elastic/eui/src/components/form/form_control_layout/append_prepend/form_append_prepend' {
	import React, { ButtonHTMLAttributes, FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	export type EuiFormAppendProps = EuiFormAppendPrependBaseProps;
	export const EuiFormAppend: ({ className, ...rest }: EuiFormAppendProps) => React.JSX.Element;
	export type EuiFormPrependProps = EuiFormAppendPrependBaseProps;
	export const EuiFormPrepend: ({ className, ...rest }: EuiFormPrependProps) => React.JSX.Element;
	export type EuiFormAppendPrependCommonProps = CommonProps & {
	    /**
	     * Main content label
	     */
	    label?: ReactNode;
	    /**
	     * Left side icon
	     */
	    iconLeft?: IconType;
	    /**
	     * Right side icon
	     */
	    iconRight?: IconType;
	    /**
	     * Optional content that will be appended to `label` and icons
	     */
	    children?: ReactNode;
	    /**
	     * id of the input element that the form label is linked to via `htmlFor` attribute
	     */
	    inputId?: string;
	    /**
	     * Renders the element with smaller height and padding
	     */
	    compressed?: boolean;
	};
	export type EuiFormAppendPrependButtonProps = EuiFormAppendPrependCommonProps & {
	    /**
	     * Defines the rendered HTML element
	     */
	    element?: 'button';
	    isDisabled?: boolean;
	} & ButtonHTMLAttributes<HTMLButtonElement>;
	export type EuiFormAppendPrependDivProps = EuiFormAppendPrependCommonProps & {
	    /**
	     * Defines the rendered HTML element
	     */
	    element?: 'div';
	} & HTMLAttributes<HTMLDivElement>;
	export type EuiFormAppendPrependBaseProps = ExclusiveUnion<EuiFormAppendPrependButtonProps, EuiFormAppendPrependDivProps>;
	export type EuiFormAppendPrependProps = {
	    side: 'append' | 'prepend';
	} & EuiFormAppendPrependBaseProps;
	export const EuiFormAppendPrepend: FunctionComponent<EuiFormAppendPrependProps>;

}
declare module '@elastic/eui/src/components/form/form_control_layout/append_prepend' {
	export { EuiFormAppend, EuiFormPrepend, type EuiFormAppendProps, type EuiFormPrependProps, type EuiFormAppendPrependButtonProps, type EuiFormAppendPrependDivProps, } from '@elastic/eui/src/components/form/form_control_layout/append_prepend/form_append_prepend';

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout' {
	import { FunctionComponent, HTMLAttributes, ReactElement, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutIconsProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons';
	type StringOrReactElement = string | ReactElement;
	type PrependAppendType = StringOrReactElement | StringOrReactElement[];
	export type EuiFormControlLayoutProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * Creates an input group with element(s) coming before children.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: PrependAppendType;
	    /**
	     * Creates an input group with element(s) coming after children.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: PrependAppendType;
	    children?: ReactNode;
	    icon?: EuiFormControlLayoutIconsProps['icon'];
	    /**
	     * Determines whether icons are absolutely or statically rendered. For single inputs,
	     * absolute rendering is typically preferred.
	     * @default absolute
	     */
	    iconsPosition?: EuiFormControlLayoutIconsProps['iconsPosition'];
	    clear?: EuiFormControlLayoutIconsProps['clear'];
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isLoading?: boolean;
	    isDisabled?: boolean;
	    className?: string;
	    compressed?: boolean;
	    readOnly?: boolean;
	    isInvalid?: boolean;
	    /**
	     * Controls the adding of and visibility of a down arrow icon
	     */
	    isDropdown?: boolean;
	    /**
	     * Connects the prepend and append labels to the input
	     */
	    inputId?: string;
	    /**
	     * Allows passing optional additional props to `.euiFormControlLayout__childrenWrapper`
	     */
	    wrapperProps?: CommonProps & HTMLAttributes<HTMLDivElement>;
	};
	export const EuiFormControlLayout: FunctionComponent<EuiFormControlLayoutProps & {
	    isDelimited?: boolean;
	}>;
	export {};

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_delimited.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormControlLayoutDelimitedStyles: (euiThemeContext: UseEuiTheme) => {
	    delimited: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    readOnly: import("@emotion/react").SerializedStyles;
	    childrenWrapper: {
	        delimited: import("@emotion/react").SerializedStyles;
	        invalid: import("@emotion/react").SerializedStyles;
	        readOnly: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiFormControlLayoutDelimited__delimiter: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;
	export const euiFormControlLayoutDelimited__input: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/form/form_control_layout/form_control_layout_delimited' {
	import { FunctionComponent, ReactElement, ReactNode } from 'react';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout';
	export type EuiFormControlLayoutDelimitedProps = Partial<EuiFormControlLayoutProps> & {
	    /**
	     * Left side control
	     */
	    startControl?: ReactElement;
	    /**
	     * Right side control
	     */
	    endControl?: ReactElement;
	    /**
	     * The center content. Accepts a string to be wrapped in a subdued EuiText
	     * or a single ReactElement
	     */
	    delimiter?: ReactNode;
	    className?: string;
	};
	export const EuiFormControlLayoutDelimited: FunctionComponent<EuiFormControlLayoutDelimitedProps>;

}
declare module '@elastic/eui/src/components/form/form_control_layout' {
	export type { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout';
	export { EuiFormControlLayout } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout';
	export type { EuiFormControlLayoutDelimitedProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_delimited';
	export { EuiFormControlLayoutDelimited } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_delimited';
	export { EuiFormControlLayoutIcons, type EuiFormControlLayoutIconsProps, } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons';
	export * from '@elastic/eui/src/components/form/form_control_layout/append_prepend';

}
declare module '@elastic/eui/src/components/form/field_number/field_number.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFieldNumberStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFieldNumber: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	    controlOnly: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/field_number/field_number' {
	import { InputHTMLAttributes, Ref, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	export type EuiFieldNumberProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'min' | 'max' | 'readOnly' | 'step'> & CommonProps & {
	    icon?: EuiFormControlLayoutProps['icon'];
	    isInvalid?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    /**
	     * @default false
	     */
	    isLoading?: boolean;
	    readOnly?: boolean;
	    min?: number;
	    max?: number;
	    /**
	     * Specifies the granularity that the value must adhere to.
	     * Accepts a `number`, e.g. `1` for integers, or `0.5` for decimal steps.
	     * Defaults to `"any"` for no stepping, which allows any decimal value(s).
	     * @default "any"
	     */
	    step?: number | 'any';
	    inputRef?: Ref<HTMLInputElement>;
	    /**
	     * Creates an input group with element(s) coming before input.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * Completely removes form control layout wrapper and ignores
	     * icon, prepend, and append. Best used inside EuiFormControlLayoutDelimited.
	     */
	    controlOnly?: boolean;
	    /**
	     * when `true` creates a shorter height input
	     * @default false
	     */
	    compressed?: boolean;
	};
	export const EuiFieldNumber: FunctionComponent<EuiFieldNumberProps>;

}
declare module '@elastic/eui/src/components/form/field_number' {
	export type { EuiFieldNumberProps } from '@elastic/eui/src/components/form/field_number/field_number';
	export { EuiFieldNumber } from '@elastic/eui/src/components/form/field_number/field_number';

}
declare module '@elastic/eui/src/components/form/field_password/field_password.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFieldPasswordStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFieldPassword: import("@emotion/react").SerializedStyles;
	    withToggle: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/field_password/field_password' {
	import { InputHTMLAttributes, FunctionComponent, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	export type EuiFieldPasswordProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'value'> & CommonProps & {
	    isInvalid?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isLoading?: boolean;
	    compressed?: boolean;
	    inputRef?: Ref<HTMLInputElement>;
	    /**
	     * Creates an input group with element(s) coming before input.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    value?: string | number;
	    /**
	     * Change the `type` of input for manually handling obfuscation.
	     * The `dual` option adds the ability to toggle the obfuscation of the input by
	     * adding an icon button as the first `append` element
	     * @default password
	     */
	    type?: 'password' | 'text' | 'dual';
	    /**
	     * Additional props to apply to the dual toggle. Extends EuiButtonIcon
	     */
	    dualToggleProps?: Partial<EuiButtonIconPropsForButton>;
	};
	export const EuiFieldPassword: FunctionComponent<EuiFieldPasswordProps>;

}
declare module '@elastic/eui/src/components/form/field_password' {
	export type { EuiFieldPasswordProps } from '@elastic/eui/src/components/form/field_password/field_password';
	export { EuiFieldPassword } from '@elastic/eui/src/components/form/field_password/field_password';

}
declare module '@elastic/eui/src/services/browser/browser' {
	interface IBrowser {
	    isEventSupported: (name: string, element: EventTarget) => boolean;
	}
	export const Browser: Readonly<IBrowser>;
	export {};

}
declare module '@elastic/eui/src/services/browser' {
	export { Browser } from '@elastic/eui/src/services/browser/browser';

}
declare module '@elastic/eui/src/components/form/field_search/field_search.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFieldSearchStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFieldSearch: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/field_search/field_search' {
	import React, { Component, InputHTMLAttributes, KeyboardEvent } from 'react';
	import { WithEuiStylesMemoizerProps } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	import { FormContextValue } from '@elastic/eui/src/components/form/eui_form_context';
	export interface EuiFieldSearchProps extends CommonProps, InputHTMLAttributes<HTMLInputElement> {
	    name?: string;
	    id?: string;
	    placeholder?: string;
	    value?: string;
	    isInvalid?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isLoading?: boolean;
	    /**
	     * Called when the user presses [Enter] OR on change if the incremental prop is `true`.
	     * If you don't need the on[Enter] functionality, prefer using onChange
	     */
	    onSearch?: (value: string) => void;
	    /**
	     * When `true` the search will be executed (that is, the `onSearch` will be called) as the
	     * user types.
	     */
	    incremental?: boolean;
	    /**
	     * when `true` creates a shorter height input
	     */
	    compressed?: boolean;
	    inputRef?: (node: HTMLInputElement | null) => void;
	    /**
	     * Shows a button that quickly clears any input
	     */
	    isClearable?: boolean;
	    /**
	     * Creates an input group with element(s) coming before input
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	}
	interface EuiFieldSearchState {
	    value: string;
	}
	export class EuiFieldSearchClass extends Component<EuiFieldSearchProps & WithEuiStylesMemoizerProps, EuiFieldSearchState> {
	    static contextType: React.Context<FormContextValue>;
	    static defaultProps: {
	        isLoading: boolean;
	        incremental: boolean;
	        compressed: boolean;
	        isClearable: boolean;
	    };
	    state: {
	        value: string;
	    };
	    inputElement: HTMLInputElement | null;
	    cleanups: Array<() => void>;
	    componentDidMount(): void;
	    onClear: () => void;
	    componentWillUnmount(): void;
	    setRef: (inputElement: HTMLInputElement | null) => void;
	    onKeyUp: (event: KeyboardEvent<HTMLInputElement>, incremental?: boolean, onSearch?: (value: string) => void) => void;
	    render(): React.JSX.Element;
	}
	export const EuiFieldSearch: React.ForwardRefExoticComponent<Omit<EuiFieldSearchProps, "stylesMemoizer"> & React.RefAttributes<Omit<EuiFieldSearchProps, "stylesMemoizer">>>;
	export {};

}
declare module '@elastic/eui/src/components/form/field_search' {
	export type { EuiFieldSearchProps } from '@elastic/eui/src/components/form/field_search/field_search';
	export { EuiFieldSearch } from '@elastic/eui/src/components/form/field_search/field_search';

}
declare module '@elastic/eui/src/components/form/field_text/field_text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFieldTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFieldText: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	    controlOnly: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/field_text/field_text' {
	import { InputHTMLAttributes, Ref, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	export type EuiFieldTextProps = InputHTMLAttributes<HTMLInputElement> & CommonProps & {
	    icon?: EuiFormControlLayoutProps['icon'];
	    isInvalid?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isLoading?: boolean;
	    /**
	     * Prevents user from changing input.
	     *
	     * Defaults to the value of `disabled` unless explicity defined otherwise.
	     */
	    readOnly?: boolean;
	    inputRef?: Ref<HTMLInputElement>;
	    /**
	     * Creates an input group with element(s) coming before input.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * Completely removes form control layout wrapper and ignores
	     * icon, prepend, and append. Best used inside EuiFormControlLayoutDelimited.
	     */
	    controlOnly?: boolean;
	    /**
	     * when `true` creates a shorter height input
	     */
	    compressed?: boolean;
	};
	export const EuiFieldText: FunctionComponent<EuiFieldTextProps>;

}
declare module '@elastic/eui/src/components/form/field_text' {
	export type { EuiFieldTextProps } from '@elastic/eui/src/components/form/field_text/field_text';
	export { EuiFieldText } from '@elastic/eui/src/components/form/field_text/field_text';

}
declare module '@elastic/eui/src/components/progress/progress.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Emotion styles
	 */
	export const euiProgressStyles: (euiThemeContext: UseEuiTheme, isNative: boolean) => {
	    euiProgress: import("@emotion/react").SerializedStyles;
	    native: import("@emotion/react").SerializedStyles;
	    indeterminate: import("@emotion/react").SerializedStyles;
	    _sharedSizeCSS: (size: string) => string;
	    readonly xs: import("@emotion/react").SerializedStyles;
	    readonly s: import("@emotion/react").SerializedStyles;
	    readonly m: import("@emotion/react").SerializedStyles;
	    readonly l: import("@emotion/react").SerializedStyles;
	    fixed: import("@emotion/react").SerializedStyles;
	    absolute: import("@emotion/react").SerializedStyles;
	    static: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    accentSecondary: import("@emotion/react").SerializedStyles;
	    vis0: import("@emotion/react").SerializedStyles;
	    vis1: import("@emotion/react").SerializedStyles;
	    vis2: import("@emotion/react").SerializedStyles;
	    vis3: import("@emotion/react").SerializedStyles;
	    vis4: import("@emotion/react").SerializedStyles;
	    vis5: import("@emotion/react").SerializedStyles;
	    vis6: import("@emotion/react").SerializedStyles;
	    vis7: import("@emotion/react").SerializedStyles;
	    vis8: import("@emotion/react").SerializedStyles;
	    vis9: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	};
	/**
	 * Data styles
	 */
	export const euiProgressDataStyles: (euiThemeContext: UseEuiTheme) => {
	    euiProgress__data: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	};
	export const euiProgressLabelStyles: {
	    euiProgress__label: import("@emotion/react").SerializedStyles;
	};
	export const euiProgressValueTextStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiProgress__valueText: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    accentSecondary: import("@emotion/react").SerializedStyles;
	    vis0: import("@emotion/react").SerializedStyles;
	    vis1: import("@emotion/react").SerializedStyles;
	    vis2: import("@emotion/react").SerializedStyles;
	    vis3: import("@emotion/react").SerializedStyles;
	    vis4: import("@emotion/react").SerializedStyles;
	    vis5: import("@emotion/react").SerializedStyles;
	    vis6: import("@emotion/react").SerializedStyles;
	    vis7: import("@emotion/react").SerializedStyles;
	    vis8: import("@emotion/react").SerializedStyles;
	    vis9: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/progress/progress' {
	import { FunctionComponent, HTMLAttributes, ProgressHTMLAttributes, ReactNode, CSSProperties } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["xs", "s", "m", "l"];
	export type EuiProgressSize = (typeof SIZES)[number];
	export const COLORS: readonly ["primary", "success", "warning", "danger", "subdued", "accent", "accentSecondary", "vis0", "vis1", "vis2", "vis3", "vis4", "vis5", "vis6", "vis7", "vis8", "vis9"];
	export type EuiProgressColor = (typeof COLORS)[number];
	export const POSITIONS: readonly ["fixed", "absolute", "static"];
	export type EuiProgressPosition = (typeof POSITIONS)[number];
	export type EuiProgressProps = CommonProps & {
	    size?: EuiProgressSize;
	    /**
	     * One of EUI's color palette, vis colors or a valid CSS color value https://developer.mozilla.org/en-US/docs/Web/CSS/color_value
	     */
	    color?: EuiProgressColor | CSSProperties['color'];
	    position?: EuiProgressPosition;
	};
	type Indeterminate = EuiProgressProps & HTMLAttributes<HTMLDivElement>;
	type Determinate = EuiProgressProps & Omit<ProgressHTMLAttributes<HTMLProgressElement>, 'max'> & {
	    /**
	     * When set, creates determinate progress with a value/max ratio
	     */
	    max?: number;
	    /**
	     * Displays custom text or percentage
	     * Pass `true` to display the percentage value
	     * Pass a ReactNode for custom text
	     * @default false
	     */
	    valueText?: boolean | ReactNode;
	    label?: ReactNode;
	    /**
	     * Object of props passed to the <span/> wrapping the determinate progress's label
	     */
	    labelProps?: CommonProps & HTMLAttributes<HTMLSpanElement>;
	};
	export const EuiProgress: FunctionComponent<ExclusiveUnion<Determinate, Indeterminate>>;
	export {};

}
declare module '@elastic/eui/src/components/progress' {
	export type { EuiProgressProps } from '@elastic/eui/src/components/progress/progress';
	export { EuiProgress } from '@elastic/eui/src/components/progress/progress';

}
declare module '@elastic/eui/src/components/form/file_picker/file_picker.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFilePickerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFilePicker: import("@emotion/react").SerializedStyles;
	    isDroppingFile: import("@emotion/react").SerializedStyles;
	    invalid: import("@emotion/react").SerializedStyles;
	    hasFiles: import("@emotion/react").SerializedStyles;
	    loading: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    input: {
	        euiFilePicker__input: import("@emotion/react").SerializedStyles;
	        largeInteractive: import("@emotion/react").SerializedStyles;
	    };
	    euiFilePicker__prompt: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    large: {
	        large: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    icon: {
	        euiFilePicker__icon: import("@emotion/react").SerializedStyles;
	        normal: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compresssed: import("@emotion/react").SerializedStyles;
	        large: import("@emotion/react").SerializedStyles;
	    };
	    rightIcon: {
	        euiFilePicker__rightIcon: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    euiFilePicker__clearButton: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/file_picker/file_picker' {
	import React, { Component, InputHTMLAttributes, ReactNode } from 'react';
	import { WithEuiStylesMemoizerProps } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { FormContextValue } from '@elastic/eui/src/components/form/eui_form_context';
	export interface EuiFilePickerProps extends CommonProps, Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
	    id?: string;
	    name?: string;
	    className?: string;
	    /**
	     * The content that appears in the dropzone if no file is attached
	     * @default 'Select or drag and drop a file'
	     */
	    initialPromptText?: ReactNode;
	    /**
	     * Use as a callback to access the HTML FileList API
	     */
	    onChange?: (files: FileList | null) => void;
	    /**
	     * Optionally pass a `File[]` array to maintain the file picker's displayed
	     * state between re-renders. Useful for multi-step forms where the component
	     * may unmount and remount while the file data is still stored in context.
	     *
	     * Note: Due to browser security restrictions, the actual file input
	     * cannot be programmatically set with files. This prop only controls
	     * the displayed state (file names in the prompt). The actual file data
	     * should be stored and managed separately in your application state.
	     */
	    files?: File[] | null;
	    /**
	     * Reduces the size to a typical (compressed) input
	     * @default false
	     */
	    compressed?: boolean;
	    /**
	     * Size or type of display;
	     * `default` for normal height, similar to other controls;
	     * `large` for taller size
	     * @default large
	     */
	    display?: 'default' | 'large';
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isInvalid?: boolean;
	    isLoading?: boolean;
	    disabled?: boolean;
	}
	export class EuiFilePickerClass extends Component<EuiFilePickerProps & WithEuiStylesMemoizerProps> {
	    static contextType: React.Context<FormContextValue>;
	    static defaultProps: Partial<EuiFilePickerProps>;
	    fileInput: HTMLInputElement | null;
	    generatedId: string;
	    getPromptTextFromFileList: (files: File[] | null) => React.ReactNode | null;
	    state: {
	        promptText: React.ReactNode | null;
	        isHoveringDrop: boolean;
	    };
	    componentDidUpdate(prevProps: EuiFilePickerProps & WithEuiStylesMemoizerProps): void;
	    handleChange: () => void;
	    removeFiles: (e?: React.MouseEvent<HTMLButtonElement>) => void;
	    showDrop: () => void;
	    hideDrop: () => void;
	    render(): React.JSX.Element;
	}
	export const EuiFilePicker: React.ForwardRefExoticComponent<Omit<EuiFilePickerProps, "stylesMemoizer"> & React.RefAttributes<Omit<EuiFilePickerProps, "stylesMemoizer">>>;

}
declare module '@elastic/eui/src/components/form/file_picker' {
	export type { EuiFilePickerProps } from '@elastic/eui/src/components/form/file_picker/file_picker';
	export { EuiFilePicker } from '@elastic/eui/src/components/form/file_picker/file_picker';

}
declare module '@elastic/eui/src/components/panel/panel' {
	import { ButtonHTMLAttributes, FunctionComponent, HTMLAttributes, Ref } from 'react';
	import { _EuiBackgroundColor, EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["none", "xs", "s", "m", "l", "xl"]; const _SIZES: ("s" | "xs" | "m" | "l" | "xl" | "none")[];
	export type PanelPaddingSize = (typeof _SIZES)[number];
	export const BORDER_RADII: readonly ["none", "m"];
	export type PanelBorderRadius = (typeof BORDER_RADII)[number];
	export const COLORS: readonly ["transparent", "plain", "subdued", "highlighted", "accent", "accentSecondary", "primary", "success", "warning", "danger", "neutral", "risk"];
	export type PanelColor = _EuiBackgroundColor | 'highlighted';
	export interface _EuiPanelProps extends CommonProps {
	    /**
	     * Adds a medium shadow to the panel;
	     * Only works when `color="plain"`
	     */
	    hasShadow?: boolean;
	    /**
	     * Adds a slight 1px border on all edges.
	     * Only works when `color="plain | transparent"`
	     */
	    hasBorder?: boolean;
	    /**
	     * Padding for all four sides
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Corner border radius
	     */
	    borderRadius?: PanelBorderRadius;
	    /**
	     * When true the panel will grow in height to match `EuiFlexItem`
	     */
	    grow?: boolean;
	    panelRef?: Ref<HTMLDivElement>;
	    /**
	     * Background color of the panel;
	     * Usually a lightened form of the brand colors
	     */
	    color?: PanelColor;
	}
	export interface _EuiPanelDivlike extends _EuiPanelProps, Omit<HTMLAttributes<HTMLDivElement>, 'color'> {
	    element?: 'div';
	}
	export interface _EuiPanelButtonlike extends _EuiPanelProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color'> {
	    element?: 'button';
	}
	export type EuiPanelProps = ExclusiveUnion<_EuiPanelButtonlike, _EuiPanelDivlike>;
	export const EuiPanel: FunctionComponent<EuiPanelProps>;
	export const _canRenderHighContrastBorder: ({ color, hasBorder, }: Pick<_EuiPanelProps, "color" | "hasBorder">) => boolean;
	export {};

}
declare module '@elastic/eui/src/components/panel/split_panel/split_panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSplitPanelOuterStyles: {
	    euiSplitPanelOuter: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	};
	export const euiSplitPanelInnerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSplitPanelInner: import("@emotion/react").SerializedStyles;
	    highContrastBorders: {
	        _renderBorder: (direction: "right" | "bottom") => string;
	        readonly column: string;
	        readonly row: string;
	    };
	};

}
declare module '@elastic/eui/src/components/panel/split_panel/split_panel' {
	import React, { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
	import { EuiBreakpointSize } from '@elastic/eui/src/services/breakpoint';
	import { _EuiPanelProps } from '@elastic/eui/src/components/panel/panel';
	export type _EuiSplitPanelInnerProps = HTMLAttributes<HTMLDivElement> & Omit<_EuiPanelProps, 'hasShadow' | 'hasBorder' | 'borderRadius'>;
	/**
	 * Consumed via `EuiSplitPanel.Inner`.
	 * Extends most `EuiPanelProps`.
	 */
	export const _EuiSplitPanelInner: FunctionComponent<_EuiSplitPanelInnerProps>;
	export type _EuiSplitPanelOuterProps = HTMLAttributes<HTMLDivElement> & {
	    /**
	     * Any number of _EuiSplitPanelInner components
	     */
	    children?: ReactNode;
	    /**
	     * Changes the flex-direction
	     */
	    direction?: 'column' | 'row';
	    /**
	     * Stacks row display on small screens.
	     * Remove completely with `false` or provide your own list of breakpoint sizes to stack on.
	     */
	    responsive?: false | EuiBreakpointSize[];
	} & Omit<_EuiPanelProps, 'paddingSize'>;
	/**
	 * Consumed via `EuiSplitPanel.Outer`.
	 * Extends most `EuiPanelProps`.
	 */
	export const _EuiSplitPanelOuter: FunctionComponent<_EuiSplitPanelOuterProps>;
	export const EuiSplitPanel: {
	    Outer: React.FunctionComponent<_EuiSplitPanelOuterProps>;
	    Inner: React.FunctionComponent<_EuiSplitPanelInnerProps>;
	};

}
declare module '@elastic/eui/src/components/panel/split_panel' {
	export type { _EuiSplitPanelInnerProps, _EuiSplitPanelOuterProps, } from '@elastic/eui/src/components/panel/split_panel/split_panel';
	export { EuiSplitPanel } from '@elastic/eui/src/components/panel/split_panel/split_panel';

}
declare module '@elastic/eui/src/components/panel' {
	export type { EuiPanelProps, PanelPaddingSize } from '@elastic/eui/src/components/panel/panel';
	export { EuiPanel, SIZES } from '@elastic/eui/src/components/panel/panel';
	export { EuiSplitPanel } from '@elastic/eui/src/components/panel/split_panel';

}
declare module '@elastic/eui/src/components/accessibility/live_announcer/live_announcer' {
	import { FunctionComponent } from 'react';
	import { EuiScreenReaderLiveProps } from '@elastic/eui/src/components/accessibility/screen_reader_live';
	export type EuiLiveAnnouncerProps = Omit<EuiScreenReaderLiveProps, 'focusRegionOnTextChange'> & {
	    /**
	     * Sets a delay in ms before the live region is cleared.
	     * The message will still be read by screen readers even if it's cleared in between.
	     *
	     * @default 2000
	     */
	    clearAfterMs?: number | false;
	};
	export const EuiLiveAnnouncer: FunctionComponent<EuiLiveAnnouncerProps>;

}
declare module '@elastic/eui/src/components/accessibility/live_announcer' {
	export * from '@elastic/eui/src/components/accessibility/live_announcer/live_announcer';

}
declare module '@elastic/eui/src/components/call_out/call_out.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCallOutStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCallOut: import("@emotion/react").SerializedStyles;
	    hasDismissButton: {
	        hasDimissButton: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	    dismissButton: {
	        euiCallOut__dismissButton: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiCallOutHeaderStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCallOutHeader: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    euiCallOut__icon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/call_out/call_out' {
	import React, { HTMLAttributes, ReactNode } from 'react';
	import { CommonProps, DataAttributeProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { type EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button/button_icon/button_icon';
	export const COLORS: readonly ["primary", "success", "warning", "danger", "accent"];
	export type Color = (typeof COLORS)[number];
	export const HEADINGS: readonly ["h1", "h2", "h3", "h4", "h5", "h6", "p"];
	export type Heading = (typeof HEADINGS)[number];
	export const SIZES: readonly ["s", "m"];
	export type Size = (typeof SIZES)[number];
	export type EuiCallOutProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'color'> & {
	    title?: ReactNode;
	    iconType?: IconType;
	    color?: Color;
	    size?: Size;
	    heading?: Heading;
	    /**
	     * Passing an `onDismiss` callback will render a cross in the top right hand corner
	     * of the callout.
	     *
	     * This callback fires when users click this button, which allows conditionally
	     * removing the callout or other actions.
	     */
	    onDismiss?: () => void;
	    /**
	     * Useful for passing additional props to the dismiss button e.g. data attributes
	     */
	    dismissButtonProps?: Partial<EuiButtonIconPropsForButton> & DataAttributeProps;
	    /**
	     * Enables the content to be read by screen readers on mount.
	     * Use this for callouts that are shown based on a user action.
	     *
	     * @default false
	     */
	    announceOnMount?: boolean;
	};
	export const EuiCallOut: React.ForwardRefExoticComponent<CommonProps & Omit<React.HTMLAttributes<HTMLDivElement>, "title" | "color"> & {
	    title?: ReactNode;
	    iconType?: IconType;
	    color?: Color;
	    size?: Size;
	    heading?: Heading;
	    /**
	     * Passing an `onDismiss` callback will render a cross in the top right hand corner
	     * of the callout.
	     *
	     * This callback fires when users click this button, which allows conditionally
	     * removing the callout or other actions.
	     */
	    onDismiss?: () => void;
	    /**
	     * Useful for passing additional props to the dismiss button e.g. data attributes
	     */
	    dismissButtonProps?: Partial<EuiButtonIconPropsForButton> & DataAttributeProps;
	    /**
	     * Enables the content to be read by screen readers on mount.
	     * Use this for callouts that are shown based on a user action.
	     *
	     * @default false
	     */
	    announceOnMount?: boolean;
	} & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/call_out' {
	export type { EuiCallOutProps } from '@elastic/eui/src/components/call_out/call_out';
	export { EuiCallOut } from '@elastic/eui/src/components/call_out/call_out';

}
declare module '@elastic/eui/src/components/form/form' {
	import React, { ReactNode, HTMLAttributes, FormHTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export type EuiFormProps = CommonProps & ExclusiveUnion<{
	    component: 'form';
	} & FormHTMLAttributes<HTMLFormElement>, {
	    component?: 'div';
	} & HTMLAttributes<HTMLDivElement>> & {
	    isInvalid?: boolean;
	    /**
	     * Which HTML element to render `div` or `form`
	     */
	    component?: 'form' | 'div';
	    error?: ReactNode | ReactNode[];
	    /**
	     * Where to display the callout with the list of errors
	     */
	    invalidCallout?: 'above' | 'none';
	    /**
	     * When set to `true`, all the rows/controls in this form will
	     * default to taking up 100% of the width of their continer. You
	     * can specify `fullWidth={false}` on individual rows/controls to
	     * disable this behavior for specific components.
	     * @default false
	     */
	    fullWidth?: boolean;
	};
	export const EuiForm: React.ForwardRefExoticComponent<EuiFormProps & React.RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/form/form_control_button/form_control_button.styles' {
	import { UseEuiTheme } from '@elastic/eui-theme-common';
	export const euiFormControlButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormControlButton: import("@emotion/react").SerializedStyles;
	    isInvalid: import("@emotion/react").SerializedStyles;
	    readOnly: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	    isLoading: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    euiFormControlButton__content: import("@emotion/react").SerializedStyles;
	    alignEnd: import("@emotion/react").SerializedStyles;
	    textContent: import("@emotion/react").SerializedStyles;
	    placeholder: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_control_button/form_control_button' {
	import { FunctionComponent, ReactNode } from 'react';
	import { type EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	import { EuiFieldTextProps } from '@elastic/eui/src/components/form/field_text';
	export type EuiFormControlButtonInputProps = {
	    /**
	     * Placeholder value to be shown when no `value` is passed
	     */
	    placeholder?: EuiFieldTextProps['placeholder'];
	    /**
	     * When `true`, it renders a shorter height element
	     */
	    compressed?: EuiFieldTextProps['compressed'];
	    /**
	     * Defines invalid state styling
	     */
	    isInvalid?: EuiFieldTextProps['isInvalid'];
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default true
	     */
	    fullWidth?: boolean;
	};
	export type EuiFormControlButtonProps = EuiFormControlButtonInputProps & Omit<EuiButtonEmptyProps, 'value' | 'color' | 'size' | 'flush' | 'isSelected'> & {
	    /**
	     * Defines the button label when used like an input in combination with `placeholder`
	     */
	    value?: ReactNode;
	};
	export const EuiFormControlButton: FunctionComponent<EuiFormControlButtonProps>;

}
declare module '@elastic/eui/src/components/form/form_control_button' {
	export { EuiFormControlButton, type EuiFormControlButtonInputProps, type EuiFormControlButtonProps, } from '@elastic/eui/src/components/form/form_control_button/form_control_button';

}
declare module '@elastic/eui/src/components/form/form_error_text/form_error_text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormErrorTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormErrorText: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_error_text/form_error_text' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFormErrorTextProps = CommonProps & HTMLAttributes<HTMLDivElement>;
	export const EuiFormErrorText: FunctionComponent<EuiFormErrorTextProps>;

}
declare module '@elastic/eui/src/components/form/form_error_text' {
	export type { EuiFormErrorTextProps } from '@elastic/eui/src/components/form/form_error_text/form_error_text';
	export { EuiFormErrorText } from '@elastic/eui/src/components/form/form_error_text/form_error_text';

}
declare module '@elastic/eui/src/components/form/form_help_text/form_help_text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormHelpTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormHelpText: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_help_text/form_help_text' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFormHelpTextProps = CommonProps & HTMLAttributes<HTMLDivElement>;
	export const EuiFormHelpText: FunctionComponent<EuiFormHelpTextProps>;

}
declare module '@elastic/eui/src/components/form/form_help_text' {
	export type { EuiFormHelpTextProps } from '@elastic/eui/src/components/form/form_help_text/form_help_text';
	export { EuiFormHelpText } from '@elastic/eui/src/components/form/form_help_text/form_help_text';

}
declare module '@elastic/eui/src/components/form/form_row/form_row.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFormRowStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFormRow: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    row: string;
	    readonly rowCompressed: string;
	    columnCompressed: import("@emotion/react").SerializedStyles;
	    centerDisplayCss: (compressed: boolean) => string;
	    readonly center: import("@emotion/react").SerializedStyles;
	    readonly centerCompressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/form_row/form_row' {
	import { FunctionComponent, HTMLAttributes, ReactElement, ReactNode } from 'react';
	import { ExclusiveUnion, CommonProps } from '@elastic/eui/src/components/common';
	export const DISPLAYS: readonly ["row", "columnCompressed", "center", "centerCompressed", "rowCompressed"];
	export type EuiFormRowDisplayKeys = (typeof DISPLAYS)[number];
	type EuiFormRowCommonProps = CommonProps & {
	    /**
	     * - `columnCompressed` creates a compressed and horizontal layout
	     * - `center`/`centerCompressed` helps align non-input content better with inline form layouts
	     * - `rowCompressed` - **deprecated**, does not currently affect styling
	     */
	    display?: EuiFormRowDisplayKeys;
	    /**
	     * Useful for inline form layouts, primarily for content that
	     * needs to be aligned with inputs but does not need a label
	     */
	    hasEmptyLabelSpace?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    /**
	     * IDs of additional elements that should be part of children's `aria-describedby`
	     */
	    describedByIds?: string[];
	    /**
	     * Escape hatch to not render duplicate labels if the child also renders a label
	     */
	    hasChildLabel?: boolean;
	    /**
	     * ReactElement to render as this component's content
	     */
	    children: ReactElement;
	    label?: ReactNode;
	    /**
	     * Adds an extra node to the right of the form label without
	     * being contained inside the form label. Good for things
	     * like documentation links.
	     */
	    labelAppend?: any;
	    id?: string;
	    isInvalid?: boolean;
	    error?: ReactNode | ReactNode[];
	    /**
	     *  Adds a single node/string or an array of nodes/strings below the input
	     */
	    helpText?: ReactNode | ReactNode[];
	    /**
	     *  Passed along to the label element; and to the child field element when `disabled` doesn't already exist on the child field element.
	     */
	    isDisabled?: boolean;
	};
	type LabelProps = {
	    labelType?: 'label';
	} & EuiFormRowCommonProps & HTMLAttributes<HTMLDivElement>;
	type LegendProps = {
	    /**
	     * Defaults to rendering a `<label>` but if passed `'legend'` for labelType,
	     * will render both a `<legend>` and the surrounding container as a `<fieldset>`
	     */
	    labelType?: 'legend';
	} & EuiFormRowCommonProps & Omit<HTMLAttributes<HTMLFieldSetElement>, 'disabled'>;
	export type EuiFormRowProps = ExclusiveUnion<LabelProps, LegendProps>;
	export const EuiFormRow: FunctionComponent<EuiFormRowProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/form_row' {
	export type { EuiFormRowProps } from '@elastic/eui/src/components/form/form_row/form_row';
	export { EuiFormRow } from '@elastic/eui/src/components/form/form_row/form_row';

}
declare module '@elastic/eui/src/components/form/radio/radio.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRadioStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRadio: import("@emotion/react").SerializedStyles;
	    input: {
	        euiRadio__circle: import("@emotion/react").SerializedStyles;
	        hasLabel: string;
	        enabled: {
	            selected: import("@emotion/react").SerializedStyles;
	            unselected: import("@emotion/react").SerializedStyles;
	        };
	        disabled: {
	            selected: import("@emotion/react").SerializedStyles;
	            unselected: import("@emotion/react").SerializedStyles;
	        };
	        euiRadio__icon: import("@emotion/react").SerializedStyles;
	        euiRadio__input: import("@emotion/react").SerializedStyles;
	    };
	    label: {
	        euiRadio__label: import("@emotion/react").SerializedStyles;
	        enabled: string;
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/form/radio/radio' {
	import { FunctionComponent, ChangeEventHandler, HTMLAttributes, LabelHTMLAttributes, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export interface RadioProps {
	    autoFocus?: boolean;
	    name?: string;
	    value?: string;
	    checked?: boolean;
	    disabled?: boolean;
	    onChange: ChangeEventHandler<HTMLInputElement>;
	    /**
	     * Object of props passed to the `label` element
	     */
	    labelProps?: CommonProps & LabelHTMLAttributes<HTMLLabelElement>;
	}
	interface idWithLabel extends RadioProps {
	    label: ReactNode;
	    id: string;
	}
	interface withId extends RadioProps {
	    id: string;
	}
	export type EuiRadioProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'id'> & ExclusiveUnion<ExclusiveUnion<RadioProps, idWithLabel>, withId>;
	export const EuiRadio: FunctionComponent<EuiRadioProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/radio/radio_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRadioGroupStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiRadioGroup: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/radio/radio_group' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiFormFieldsetProps, EuiFormLegendProps } from '@elastic/eui/src/components/form/form_fieldset';
	import { EuiRadioProps } from '@elastic/eui/src/components/form/radio/radio';
	export interface EuiRadioGroupOption extends Omit<EuiRadioProps, 'checked' | 'onChange'> {
	    id: string;
	}
	export type EuiRadioGroupChangeCallback = (id: string, value?: string) => void;
	type AsDivProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>;
	type WithLegendProps = Omit<EuiFormFieldsetProps, 'onChange'> & {
	    /**
	     * If the individual labels for each radio do not provide a sufficient description, add a legend.
	     * Wraps the group in a `EuiFormFieldset` which adds an `EuiLegend` for titling the whole group.
	     * Accepts an `EuiFormLegendProps` shape.
	     */
	    legend?: EuiFormLegendProps;
	};
	export type EuiRadioGroupProps = CommonProps & {
	    /**
	     * Passed down to all child `EuiCheckbox`es
	     */
	    disabled?: boolean;
	    /**
	     * Tightens up the spacing between radio rows
	     */
	    compressed?: boolean;
	    name?: string;
	    options: EuiRadioGroupOption[];
	    idSelected?: string;
	    onChange: EuiRadioGroupChangeCallback;
	} & ExclusiveUnion<AsDivProps, WithLegendProps>;
	export const EuiRadioGroup: FunctionComponent<EuiRadioGroupProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/radio' {
	export type { EuiRadioProps } from '@elastic/eui/src/components/form/radio/radio';
	export { EuiRadio } from '@elastic/eui/src/components/form/radio/radio';
	export type { EuiRadioGroupProps, EuiRadioGroupOption } from '@elastic/eui/src/components/form/radio/radio_group';
	export { EuiRadioGroup } from '@elastic/eui/src/components/form/radio/radio_group';

}
declare module '@elastic/eui/src/services/number/number' {
	export const isWithinRange: (min: number | string, max: number | string, value: number | string) => boolean;
	export function isEvenlyDivisibleBy(num: number, factor: number): boolean;

}
declare module '@elastic/eui/src/services/number' {
	export * from '@elastic/eui/src/services/number/number';

}
declare module '@elastic/eui/src/components/form/range/range_levels_colors' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import type { EuiRangeLevel } from '@elastic/eui/src/components/form/range/types';
	export const LEVEL_COLORS: readonly ["primary", "success", "warning", "danger"];
	export type EuiRangeLevelColor = (typeof LEVEL_COLORS)[number];
	export const isNamedLevelColor: (color?: EuiRangeLevelColor | string) => color is EuiRangeLevelColor;
	export const euiRangeLevelColor: (color: EuiRangeLevelColor | string, { euiTheme }: UseEuiTheme) => string;
	export const getLevelColor: (levels: EuiRangeLevel[], value: number) => "primary" | "success" | "warning" | "danger" | import("csstype").Property.Color | undefined;

}
declare module '@elastic/eui/src/components/form/range/range_input.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeInputStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeInput: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_input' {
	import { FunctionComponent } from 'react';
	import { EuiFieldNumberProps } from '@elastic/eui/src/components/form/field_number';
	import type { _SingleRangeValue, _SharedRangeInputSide } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeInputProps extends Omit<EuiFieldNumberProps, 'max' | 'min' | 'value' | 'step'>, Omit<_SingleRangeValue, 'onChange'>, _SharedRangeInputSide {
	    autoSize?: boolean;
	}
	export const EuiRangeInput: FunctionComponent<EuiRangeInputProps>;

}
declare module '@elastic/eui/src/components/form/range/types' {
	import type { ReactNode, CSSProperties, InputHTMLAttributes } from 'react';
	import type { CommonProps } from '@elastic/eui/src/components/common';
	import type { EuiInputPopoverProps } from '@elastic/eui/src/components/popover/input_popover';
	import type { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	import type { EuiRangeLevelColor } from '@elastic/eui/src/components/form/range/range_levels_colors';
	import type { EuiRangeInputProps } from '@elastic/eui/src/components/form/range/range_input';
	/**
	 * Internal type atoms split up both for easier categorization
	 * and for easier reusing/picking
	 */
	export interface _SharedRangeValuesProps {
	    max: number;
	    min: number;
	    /**
	     * The number to increment or decrement between each interval
	     * @default 1
	     */
	    step?: number;
	}
	export interface _SingleRangeValue extends _SharedRangeValuesProps {
	    value: string | number;
	    onChange?: (event: _SingleRangeChangeEvent, isValid: boolean) => void;
	}
	export interface _DualRangeValue extends _SharedRangeValuesProps {
	    value: [_SingleRangeValue['value'], _SingleRangeValue['value']];
	    onChange: (values: [_SingleRangeValue['value'], _SingleRangeValue['value']], isValid: boolean, event?: _DualRangeChangeEvent) => void;
	}
	export interface _SharedRangesValues extends _SharedRangeValuesProps {
	    value?: _SingleRangeValue['value'] | _DualRangeValue['value'];
	}
	export type _SingleRangeChangeEvent = React.ChangeEvent<HTMLInputElement> | React.KeyboardEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>;
	export type _DualRangeChangeEvent = _SingleRangeChangeEvent | React.KeyboardEvent<HTMLDivElement>;
	export interface _SharedRangeDataStructures {
	    /**
	     * Specified ticks at specified values
	     */
	    ticks?: EuiRangeTick[];
	    /**
	     * Modifies the number of tick marks and at what interval
	     */
	    tickInterval?: number;
	    /**
	     * Create colored indicators for certain intervals.
	     * An array of {@link EuiRangeLevel} objects
	     */
	    levels?: EuiRangeLevel[];
	}
	export interface _SharedRangeVisualConfiguration {
	    /**
	     * Pass `true` to displays an extra input control for direct manipulation.
	     * Pass `"inputWithPopover"` to only show the input but show the range in a dropdown.
	     */
	    showInput?: boolean | 'inputWithPopover';
	    /**
	     * Shows static min/max labels on the sides of the range slider
	     */
	    showLabels?: boolean;
	    /**
	     * Shows a thick line from min to value
	     */
	    showRange?: boolean;
	    /**
	     * Shows clickable tick marks and labels at the given interval (`step`/`tickInterval`)
	     */
	    showTicks?: boolean;
	}
	export interface _SharedRangeInputProps {
	    id?: string;
	    name?: string;
	    /**
	     * Only impacts ticks rendered by `showTicks` or inputs rendered by `showInput`.
	     */
	    compressed?: boolean;
	    /**
	     * Only impacts inputs rendered by the `showInput` prop.
	     * The range slider itself remains interactable unless `disabled` is applied.
	     */
	    readOnly?: boolean;
	    /**
	     * Disables both the range track and any input(s)
	     */
	    disabled?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    /**
	     * Only impacts inputs rendered by the `showInput` prop
	     */
	    isInvalid?: boolean;
	    /**
	     * Only impacts inputs rendered when the `showInput` prop is set to `"inputWithPopover"`
	     */
	    isLoading?: boolean;
	    /**
	     * Only impacts input popovers rendered when the `showInput` prop is set to `"inputWithPopover"`
	     *
	     * Allows customizing the underlying [EuiInputPopover](/#/layout/popover#popover-attached-to-input-element),
	     * except for props controlled by the range component
	     */
	    inputPopoverProps?: Omit<EuiInputPopoverProps, 'input' | 'isOpen' | 'closePopover' | 'disableFocusTrap' | 'ownFocus' | 'popoverScreenReaderText' | 'fullWidth'>;
	}
	export type _SharedRangeInputSide = {
	    /**
	     * @default 'max'
	     */
	    side?: 'min' | 'max';
	};
	/**
	 * Externally exported props types
	 */
	export interface EuiRangeProps extends CommonProps, Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'min' | 'max' | 'step' | 'onChange'>, _SingleRangeValue, _SharedRangeDataStructures, _SharedRangeVisualConfiguration, _SharedRangeInputProps {
	    /**
	     * Shows a tooltip styled value
	     */
	    showValue?: boolean;
	    /**
	     * Appends to the tooltip
	     */
	    valueAppend?: ReactNode;
	    /**
	     * Prepends to the tooltip
	     */
	    valuePrepend?: ReactNode;
	    /**
	     * Only impacts the input rendered by the `showInput` prop.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Only impacts the input rendered by the `showInput` prop.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	}
	export interface EuiDualRangeProps extends CommonProps, Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'min' | 'max' | 'step' | 'onChange'>, _DualRangeValue, _SharedRangeDataStructures, _SharedRangeVisualConfiguration, _SharedRangeInputProps {
	    /**
	     * Creates a draggble highlighted range area
	     */
	    isDraggable?: boolean;
	    onBlur?: (event: React.FocusEvent<HTMLInputElement> | React.FocusEvent<HTMLDivElement>) => void;
	    onFocus?: (event: React.FocusEvent<HTMLInputElement> | React.FocusEvent<HTMLDivElement>) => void;
	    /**
	     * Only impacts inputs rendered when the `showInput` prop is set to `"inputWithPopover"`.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Only impacts inputs rendered when the `showInput` prop is set to `"inputWithPopover"`.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * Intended to be used with aria attributes. Some attributes may be overwritten.
	     */
	    minInputProps?: Partial<Omit<EuiRangeInputProps, 'max' | 'min' | 'step' | 'compressed' | 'autoSize' | 'fullWidth' | 'controlOnly'>>;
	    /**
	     *  Intended to be used with aria attributes. Some attributes may be overwritten.
	     */
	    maxInputProps?: EuiDualRangeProps['minInputProps'];
	}
	export interface EuiRangeTick {
	    value: number;
	    label: ReactNode;
	    accessibleLabel?: string;
	}
	export interface EuiRangeLevel extends CommonProps, Pick<_SharedRangeValuesProps, 'min' | 'max'> {
	    /**
	     * Accepts one of `["primary", "success", "warning", "danger"]` or a valid CSS color value.
	     */
	    color: EuiRangeLevelColor | CSSProperties['color'];
	}

}
declare module '@elastic/eui/src/components/form/range/range.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeVariables: (euiThemeContext: UseEuiTheme) => {
	    trackColor: string;
	    highlightColor: string;
	    focusColor: string;
	    thumbHeight: string;
	    thumbWidth: string;
	    thumbBorderWidth: import("csstype").Property.BorderWidth<string | number> | undefined;
	    thumbBorderColor: string;
	    readonly thumbBackgroundColor: string;
	    trackWidth: string;
	    trackHeight: string;
	    trackBorderWidth: string;
	    readonly trackBorderColor: string;
	    trackBorderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    tickHeight: string;
	    tickWidth: string;
	    tickColor: string;
	    disabledOpacity: number;
	    highlightHeight: string;
	    height: string;
	    compressedHeight: string;
	    trackTopPositionWithTicks: string;
	    trackBottomPositionWithTicks: string;
	    trackTopPositionWithoutTicks: string;
	    levelsZIndex: number;
	    highlightZIndex: number;
	    thumbZIndex: number;
	};
	export const euiRangeTrackPerBrowser: (content: string) => string;
	export const euiRangeThumbBorder: (euiThemeContext: UseEuiTheme) => string;
	export const euiRangeThumbBoxShadow: (euiThemeContext: UseEuiTheme) => string;
	export const euiRangeThumbFocusBoxShadow: (euiThemeContext: UseEuiTheme) => string;
	export const euiRangeThumbStyle: (euiThemeContext: UseEuiTheme) => string;
	export const euiRangeThumbPerBrowser: (content: string) => string;
	export const euiRangeThumbFocus: (euiThemeContext: UseEuiTheme) => string;
	export const euiRangeStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiRange: import("@emotion/react").SerializedStyles;
	    hasInput: import("@emotion/react").SerializedStyles;
	    euiRange__horizontalSpacer: import("@emotion/react").SerializedStyles;
	    euiRange__slimHorizontalSpacer: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_draggable.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeDraggableStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeDraggable: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeDraggableInnerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeDraggable__inner: import("@emotion/react").SerializedStyles;
	    enabled: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_draggable' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import type { EuiDualRangeProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeDraggableProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>, Pick<EuiDualRangeProps, 'min' | 'max' | 'value' | 'disabled' | 'showTicks'> {
	    lowerPosition: string;
	    upperPosition: string;
	    onChange: (x: number, isFirstInteraction?: boolean) => void;
	}
	export const EuiRangeDraggable: FunctionComponent<EuiRangeDraggableProps>;

}
declare module '@elastic/eui/src/components/form/range/range_highlight.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeHighlightStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeHighlight: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeHighlightProgressStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeHighlight__progress: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeHighlightLevelsWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeHighlight__levelsWrapper: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeHighlightLevelsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeHighlight__levels: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_levels.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeLevelsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeLevels: import("@emotion/react").SerializedStyles;
	    hasRange: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeLevelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeLevel: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/utils' {
	export const EUI_THUMB_SIZE = 16;
	export const calculateThumbPosition: (value: number, min: number, max: number, trackWidth: number, thumbSize?: number) => number;

}
declare module '@elastic/eui/src/components/form/range/range_levels' {
	import { CSSProperties, FunctionComponent } from 'react';
	import type { EuiRangeProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeLevelsProps extends Pick<EuiRangeProps, 'levels' | 'min' | 'max' | 'showTicks' | 'showRange'> {
	    trackWidth: number;
	    style?: CSSProperties;
	}
	export const EuiRangeLevels: FunctionComponent<EuiRangeLevelsProps>;

}
declare module '@elastic/eui/src/components/form/range/range_highlight' {
	import React, { FunctionComponent } from 'react';
	import type { EuiRangeProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeHighlightProps extends Pick<EuiRangeProps, 'min' | 'max' | 'levels' | 'showTicks'> {
	    className?: string;
	    background?: string;
	    trackWidth: number;
	    lowerValue: number;
	    upperValue: number;
	    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
	}
	export const EuiRangeHighlight: FunctionComponent<EuiRangeHighlightProps>;

}
declare module '@elastic/eui/src/components/form/range/range_label.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeLabelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeLabel: import("@emotion/react").SerializedStyles;
	    min: import("@emotion/react").SerializedStyles;
	    max: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_label' {
	import { FunctionComponent } from 'react';
	import type { _SharedRangeInputProps, _SharedRangeInputSide } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeLabelProps extends Pick<_SharedRangeInputProps, 'disabled'>, _SharedRangeInputSide {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: string | number;
	}
	export const EuiRangeLabel: FunctionComponent<EuiRangeLabelProps>;

}
declare module '@elastic/eui/src/components/form/range/range_slider.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeSliderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeSlider: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	    hasRange: import("@emotion/react").SerializedStyles;
	    hasLevels: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_slider' {
	import { ChangeEventHandler, InputHTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiResizeObserverProps } from '@elastic/eui/src/components/observer/resize_observer';
	import type { EuiRangeProps, EuiRangeLevel } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeSliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'min' | 'max' | 'step' | 'onResize'>, CommonProps, Pick<EuiRangeProps, 'id' | 'name' | 'tabIndex' | 'min' | 'max' | 'step' | 'disabled' | 'isLoading' | 'showRange' | 'showTicks'> {
	    onChange?: ChangeEventHandler<HTMLInputElement>;
	    thumbColor?: EuiRangeLevel['color'];
	    onResize: EuiResizeObserverProps['onResize'];
	    ariaValueText?: string;
	}
	export const EuiRangeSlider: FunctionComponent<EuiRangeSliderProps>;

}
declare module '@elastic/eui/src/components/form/range/range_thumb.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeThumbStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeThumb: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_thumb' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import type { EuiRangeProps } from '@elastic/eui/src/components/form/range/types';
	interface BaseProps extends CommonProps, Pick<EuiRangeProps, 'min' | 'max' | 'value' | 'disabled' | 'showInput' | 'showTicks'> {
	}
	interface ButtonLike extends BaseProps, HTMLAttributes<HTMLButtonElement> {
	}
	interface DivLike extends BaseProps, Omit<HTMLAttributes<HTMLDivElement>, 'onClick' | 'onMouseDown'> {
	}
	export type EuiRangeThumbProps = ExclusiveUnion<ButtonLike, DivLike>;
	export const EuiRangeThumb: FunctionComponent<EuiRangeThumbProps>;
	export {};

}
declare module '@elastic/eui/src/components/form/range/range_ticks.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeTicksStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeTicks: import("@emotion/react").SerializedStyles;
	    isCustom: import("@emotion/react").SerializedStyles;
	    regular: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeTickStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeTick: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	    regular: import("@emotion/react").SerializedStyles;
	    selected: import("@emotion/react").SerializedStyles;
	    isCustom: import("@emotion/react").SerializedStyles;
	    hasPseudoTickMark: import("@emotion/react").SerializedStyles;
	    euiRangeTick__pseudo: import("@emotion/react").SerializedStyles;
	    isMin: import("@emotion/react").SerializedStyles;
	    isMax: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_ticks' {
	import { ButtonHTMLAttributes, MouseEventHandler, FunctionComponent } from 'react';
	import type { _SharedRangesValues, _SharedRangeDataStructures, _SharedRangeInputProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeTicksProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value'>, _SharedRangesValues, Pick<_SharedRangeInputProps, 'compressed' | 'disabled'>, Pick<_SharedRangeDataStructures, 'ticks' | 'tickInterval'> {
	    tickSequence: number[];
	    trackWidth: number;
	    onChange?: MouseEventHandler<HTMLButtonElement>;
	}
	export const EuiRangeTicks: FunctionComponent<EuiRangeTicksProps>;

}
declare module '@elastic/eui/src/components/form/range/range_track.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeTrackStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeTrack: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    hasLevels: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_track' {
	import { FunctionComponent, MouseEventHandler, HTMLAttributes } from 'react';
	import type { _SharedRangesValues, _SharedRangeDataStructures, _SharedRangeVisualConfiguration, _SharedRangeInputProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeTrackProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>, _SharedRangesValues, _SharedRangeDataStructures, Pick<_SharedRangeVisualConfiguration, 'showTicks' | 'showRange'>, Pick<_SharedRangeInputProps, 'compressed' | 'disabled'> {
	    trackWidth: number;
	    onChange?: MouseEventHandler<HTMLButtonElement>;
	}
	export const EuiRangeTrack: FunctionComponent<EuiRangeTrackProps>;

}
declare module '@elastic/eui/src/components/form/range/range_wrapper.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeWrapper: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_wrapper' {
	import React, { HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import type { _SharedRangeInputProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeWrapperProps extends CommonProps, HTMLAttributes<HTMLDivElement>, Pick<_SharedRangeInputProps, 'fullWidth' | 'compressed'> {
	}
	export const EuiRangeWrapper: React.ForwardRefExoticComponent<EuiRangeWrapperProps & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/form/range/dual_range.styles' {
	export const euiDualRangeStyles: () => {
	    euiDualRange: import("@emotion/react").SerializedStyles;
	    euiDualRange__slider: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/dual_range' {
	import React, { Component } from 'react';
	import { WithEuiThemeProps } from '@elastic/eui/src/services';
	import { FormContextValue } from '@elastic/eui/src/components/form/eui_form_context';
	import type { EuiDualRangeProps, _SingleRangeValue } from '@elastic/eui/src/components/form/range/types';
	type ValueMember = _SingleRangeValue['value'];
	export class EuiDualRangeClass extends Component<EuiDualRangeProps & WithEuiThemeProps> {
	    static contextType: React.Context<FormContextValue>;
	    static defaultProps: {
	        min: number;
	        max: number;
	        step: number;
	        compressed: boolean;
	        isLoading: boolean;
	        showLabels: boolean;
	        showInput: boolean;
	        showRange: boolean;
	        showTicks: boolean;
	        levels: never[];
	    };
	    state: {
	        id: string;
	        isPopoverOpen: boolean;
	        rangeWidth: number;
	    };
	    get isInPopover(): boolean;
	    preventPopoverClose: boolean;
	    private leftPosition;
	    private dragAcc;
	    get lowerValue(): string | number;
	    get upperValue(): string | number;
	    get lowerValueIsValid(): boolean;
	    get upperValueIsValid(): boolean;
	    get isValid(): boolean;
	    _determineInvalidThumbMovement: (newVal: ValueMember, lower: ValueMember, upper: ValueMember, e: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLInputElement>) => void;
	    _determineValidThumbMovement: (newVal: ValueMember, lower: ValueMember, upper: ValueMember, e: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>) => void;
	    _determineThumbMovement: (newVal: number, e: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>) => void;
	    _handleOnChange: (lower: ValueMember, upper: ValueMember, e?: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLInputElement> | React.KeyboardEvent<HTMLDivElement>) => void;
	    handleSliderChange: (e: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>) => void;
	    _resetToRangeEnds: (e: React.KeyboardEvent<HTMLInputElement>) => void;
	    _isDirectionalKeyPress: (event: React.KeyboardEvent<HTMLInputElement>) => boolean;
	    handleInputKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
	    handleLowerInputChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
	    handleUpperInputChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
	    _handleKeyDown: (value: ValueMember, event: React.KeyboardEvent<HTMLInputElement> | React.KeyboardEvent<HTMLDivElement>) => number;
	    handleLowerKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
	    handleUpperKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;
	    handleDraggableKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
	    calculateThumbPositionStyle: (value: number, width?: number) => {
	        left: string;
	    };
	    onThumbFocus: (e: React.FocusEvent<HTMLDivElement>) => void;
	    onThumbBlur: (e: React.FocusEvent<HTMLDivElement>) => void;
	    onInputFocus: (e: React.FocusEvent<HTMLInputElement>) => void;
	    onInputBlur: (e: React.FocusEvent<HTMLInputElement>) => NodeJS.Timeout;
	    closePopover: () => void;
	    setRangeWidth: ({ width }: {
	        width: number;
	    }) => void;
	    getNearestStep: (value: number) => number;
	    handleDrag: (x: number, isFirstInteraction?: boolean) => void;
	    render(): React.JSX.Element;
	}
	export const EuiDualRange: React.ForwardRefExoticComponent<Omit<EuiDualRangeProps, "theme"> & React.RefAttributes<Omit<EuiDualRangeProps, "theme">>>;
	export {};

}
declare module '@elastic/eui/src/components/form/range/range_tooltip.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiRangeTooltipStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeTooltip: import("@emotion/react").SerializedStyles;
	};
	export const euiRangeTooltipValueStyles: (euiThemeContext: UseEuiTheme) => {
	    euiRangeTooltip__value: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    hasTicks: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/range/range_tooltip' {
	import { FunctionComponent } from 'react';
	import type { EuiRangeProps } from '@elastic/eui/src/components/form/range/types';
	export interface EuiRangeTooltipProps extends Pick<EuiRangeProps, 'min' | 'max' | 'value' | 'valueAppend' | 'valuePrepend' | 'showTicks'> {
	    name?: string;
	}
	export const EuiRangeTooltip: FunctionComponent<EuiRangeTooltipProps>;

}
declare module '@elastic/eui/src/components/form/range/range' {
	import React, { Component } from 'react';
	import { WithEuiThemeProps } from '@elastic/eui/src/services';
	import { FormContextValue } from '@elastic/eui/src/components/form/eui_form_context';
	import type { EuiRangeProps, EuiRangeTick } from '@elastic/eui/src/components/form/range/types';
	export class EuiRangeClass extends Component<EuiRangeProps & WithEuiThemeProps> {
	    static contextType: React.Context<FormContextValue>;
	    static defaultProps: {
	        min: number;
	        max: number;
	        step: number;
	        compressed: boolean;
	        isLoading: boolean;
	        showLabels: boolean;
	        showInput: boolean;
	        showRange: boolean;
	        showTicks: boolean;
	        showValue: boolean;
	        levels: never[];
	    };
	    preventPopoverClose: boolean;
	    state: {
	        id: string;
	        isPopoverOpen: boolean;
	        trackWidth: number;
	    };
	    handleOnChange: (e: React.ChangeEvent<HTMLInputElement> | React.MouseEvent<HTMLButtonElement>) => void;
	    get isValid(): boolean;
	    setTrackWidth: ({ width }: {
	        width: number;
	    }) => void;
	    onInputFocus: (e: React.FocusEvent<HTMLInputElement>) => void;
	    onInputBlur: (e: React.FocusEvent<HTMLInputElement>) => NodeJS.Timeout;
	    closePopover: () => void;
	    handleAriaValueText: (ticks: EuiRangeTick[], currentVal: string | number) => string | undefined;
	    render(): React.JSX.Element;
	}
	export const EuiRange: React.ForwardRefExoticComponent<Omit<EuiRangeProps, "theme"> & React.RefAttributes<Omit<EuiRangeProps, "theme">>>;

}
declare module '@elastic/eui/src/components/form/range' {
	export { EuiDualRange } from '@elastic/eui/src/components/form/range/dual_range';
	export { EuiRange } from '@elastic/eui/src/components/form/range/range';
	export type { EuiRangeProps, EuiDualRangeProps, EuiRangeTick, EuiRangeLevel, } from '@elastic/eui/src/components/form/range/types';

}
declare module '@elastic/eui/src/components/form/select/select.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSelectStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSelect: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	    lineHeight: {
	        removePadding: string;
	        uncompressed: string;
	        compressed: string;
	        inGroup: {
	            uncompressed: string;
	            compressed: string;
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/form/select/select' {
	import React, { SelectHTMLAttributes, OptionHTMLAttributes, Ref, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	export interface EuiSelectOption extends OptionHTMLAttributes<HTMLOptionElement> {
	    text: React.ReactNode;
	}
	export type EuiSelectProps = Omit<SelectHTMLAttributes<HTMLSelectElement>, 'value'> & CommonProps & {
	    /**
	     * @default []
	     */
	    options?: EuiSelectOption[];
	    isInvalid?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    isLoading?: boolean;
	    /**
	     * Simulates no selection by creating an empty, selected, hidden first option
	     * @default false
	     */
	    hasNoInitialSelection?: boolean;
	    inputRef?: Ref<HTMLSelectElement>;
	    value?: string | number;
	    /**
	     * when `true` creates a shorter height input
	     * @default false
	     */
	    compressed?: boolean;
	    /**
	     * Creates an input group with element(s) coming before select.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after select.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	};
	export const EuiSelect: FunctionComponent<EuiSelectProps>;

}
declare module '@elastic/eui/src/components/form/select' {
	export type { EuiSelectProps, EuiSelectOption } from '@elastic/eui/src/components/form/select/select';
	export { EuiSelect } from '@elastic/eui/src/components/form/select/select';

}
declare module '@elastic/eui/src/components/form/switch/switch.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSwitchStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSwitch: import("@emotion/react").SerializedStyles;
	    enabled: string;
	    disabled: import("@emotion/react").SerializedStyles;
	    button: {
	        euiSwitch__button: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compressed: import("@emotion/react").SerializedStyles;
	        mini: import("@emotion/react").SerializedStyles;
	    };
	    body: {
	        euiSwitch__body: import("@emotion/react").SerializedStyles;
	        on: import("@emotion/react").SerializedStyles;
	        off: import("@emotion/react").SerializedStyles;
	        disabled: {
	            uncompressed: import("@emotion/react").SerializedStyles;
	            compressed: import("@emotion/react").SerializedStyles;
	            mini: import("@emotion/react").SerializedStyles;
	        };
	    };
	    icons: {
	        euiSwitch__icons: import("@emotion/react").SerializedStyles;
	        on: import("@emotion/react").SerializedStyles;
	        off: import("@emotion/react").SerializedStyles;
	        enabled: import("@emotion/react").SerializedStyles;
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	    thumb: {
	        euiSwitch__thumb: import("@emotion/react").SerializedStyles;
	        off: import("@emotion/react").SerializedStyles;
	        readonly on: {
	            uncompressed: import("@emotion/react").SerializedStyles;
	            compressed: import("@emotion/react").SerializedStyles;
	            mini: import("@emotion/react").SerializedStyles;
	        };
	        enabled: {
	            enabled: string;
	            uncompressed: string;
	            compressed: string;
	            mini: string;
	        };
	        disabled: {
	            disabled: import("@emotion/react").SerializedStyles;
	            uncompressed: string;
	            compressed: string;
	            mini: string;
	        };
	    };
	    label: {
	        euiSwitch__label: import("@emotion/react").SerializedStyles;
	        uncompressed: string;
	        compressed: import("@emotion/react").SerializedStyles;
	        mini: import("@emotion/react").SerializedStyles;
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/form/switch/switch' {
	import React, { ButtonHTMLAttributes, HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiSwitchEvent = React.BaseSyntheticEvent<React.MouseEvent<HTMLButtonElement>, HTMLButtonElement, EventTarget & {
	    checked: boolean;
	}>;
	export type EuiSwitchProps = CommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'disabled'> & {
	    /**
	     * Whether to render the text label
	     */
	    showLabel?: boolean;
	    /**
	     * Must be a string if `showLabel` prop is false
	     */
	    label: ReactNode | string;
	    checked: boolean;
	    onChange: (event: EuiSwitchEvent) => void;
	    disabled?: boolean;
	    /**
	     * Compressed switches are smaller and contain no icon signifiers
	     */
	    compressed?: boolean;
	    /**
	     * Object of props passed to the label's `<span />`
	     */
	    labelProps?: CommonProps & HTMLAttributes<HTMLSpanElement>;
	};
	export const EuiSwitch: FunctionComponent<EuiSwitchProps & {
	    /**
	     * Mini styling is similar to compressed, but even smaller.
	     * It's undocumented because it has very specific uses.
	     */
	    mini?: boolean;
	}>;

}
declare module '@elastic/eui/src/components/form/switch' {
	export type { EuiSwitchProps, EuiSwitchEvent } from '@elastic/eui/src/components/form/switch/switch';
	export { EuiSwitch } from '@elastic/eui/src/components/form/switch/switch';

}
declare module '@elastic/eui/src/components/form/text_area/text_area.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTextAreaStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTextArea: import("@emotion/react").SerializedStyles;
	    resize: {
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	        both: import("@emotion/react").SerializedStyles;
	        none: import("@emotion/react").SerializedStyles;
	    };
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    formControlLayout: {
	        euiTextArea: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/form/text_area/text_area' {
	import { TextareaHTMLAttributes, Ref, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutIconsProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons';
	export const RESIZE: readonly ["vertical", "horizontal", "both", "none"];
	export type EuiTextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & CommonProps & {
	    icon?: EuiFormControlLayoutIconsProps['icon'];
	    isLoading?: boolean;
	    isInvalid?: boolean;
	    /**
	     * Shows a button that allows users to quickly clear the textarea
	     */
	    isClearable?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    compressed?: boolean;
	    /**
	     * Which direction, if at all, should the textarea resize
	     * @default vertical
	     */
	    resize?: (typeof RESIZE)[number];
	    inputRef?: Ref<HTMLTextAreaElement>;
	};
	export const EuiTextArea: FunctionComponent<EuiTextAreaProps>;

}
declare module '@elastic/eui/src/components/form/text_area' {
	export type { EuiTextAreaProps } from '@elastic/eui/src/components/form/text_area/text_area';
	export { EuiTextArea } from '@elastic/eui/src/components/form/text_area/text_area';

}
declare module '@elastic/eui/src/components/form' {
	export * from '@elastic/eui/src/components/form/checkbox';
	export * from '@elastic/eui/src/components/form/described_form_group';
	export * from '@elastic/eui/src/components/form/field_number';
	export * from '@elastic/eui/src/components/form/field_password';
	export * from '@elastic/eui/src/components/form/field_search';
	export * from '@elastic/eui/src/components/form/field_text';
	export * from '@elastic/eui/src/components/form/file_picker';
	export * from '@elastic/eui/src/components/form/form';
	export * from '@elastic/eui/src/components/form/form_control_button';
	export * from '@elastic/eui/src/components/form/form_control_layout';
	export * from '@elastic/eui/src/components/form/form_error_text';
	export * from '@elastic/eui/src/components/form/form_fieldset';
	export * from '@elastic/eui/src/components/form/form_help_text';
	export * from '@elastic/eui/src/components/form/form_label';
	export * from '@elastic/eui/src/components/form/form_row';
	export * from '@elastic/eui/src/components/form/radio';
	export * from '@elastic/eui/src/components/form/range';
	export * from '@elastic/eui/src/components/form/select';
	export * from '@elastic/eui/src/components/form/super_select';
	export * from '@elastic/eui/src/components/form/switch';
	export * from '@elastic/eui/src/components/form/text_area';
	export * from '@elastic/eui/src/components/form/validatable_control';

}
declare module '@elastic/eui/src/components/link/external_link_icon' {
	import { FunctionComponent, AnchorHTMLAttributes } from 'react';
	import { EuiIconProps } from '@elastic/eui/src/components/icon';
	/**
	 * DRY util for indicating external links both via icon and to
	 * screen readers. Used internally by at EuiLink and EuiListGroupItem
	 */
	export type EuiExternalLinkIconProps = {
	    target?: AnchorHTMLAttributes<HTMLAnchorElement>['target'];
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	};
	export const EuiExternalLinkIcon: FunctionComponent<EuiExternalLinkIconProps & Partial<EuiIconProps>>;

}
declare module '@elastic/eui/src/components/list_item_layout/_list_item_layout' {
	import React, { AnchorHTMLAttributes, ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export const OPTION_CHECKED_STATES: readonly ["on", "off", "mixed", undefined];
	export type EuiListItemLayoutCheckedType = (typeof OPTION_CHECKED_STATES)[number];
	export type EuiListItemLayoutSharedProps = CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: 'li' | 'div';
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, 'children'>;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: 'checked' | 'selected';
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>['role'];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: 'truncate' | 'wrap';
	};
	export type EuiListItemLayoutAsLi = {
	    element: 'li';
	} & EuiListItemLayoutSharedProps & Omit<HTMLAttributes<HTMLLIElement>, 'role'>;
	export type EuiListItemLayoutAsDiv = {
	    element: 'div';
	} & EuiListItemLayoutSharedProps & Omit<HTMLAttributes<HTMLDivElement>, 'role'>;
	export type EuiListItemLayoutAsButton = {
	    element: 'button';
	} & EuiListItemLayoutSharedProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'disabled' | 'role'>;
	export type EuiListItemLayoutAsAnchor = {
	    element: 'a';
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & EuiListItemLayoutSharedProps & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'role'>;
	export type EuiListItemLayoutProps = ExclusiveUnion<EuiListItemLayoutAsLi, ExclusiveUnion<ExclusiveUnion<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor>, EuiListItemLayoutAsDiv>>;
	/**
	 * This is an EUI internal-only layout component that is used to share layout and
	 * styles between selection and navigational list components.
	 */
	export const EuiListItemLayout: React.ForwardRefExoticComponent<((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsLi, (import ("@elastic/eui/src/components/common").DisambiguateSet<(import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">), EuiListItemLayoutAsDiv> & {
	    element: "div";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.HTMLAttributes<HTMLDivElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsDiv, (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">)> & ((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">)))> & ((import ("@elastic/eui/src/components/common").DisambiguateSet<(import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">), EuiListItemLayoutAsDiv> & {
	    element: "div";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.HTMLAttributes<HTMLDivElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsDiv, (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">)> & ((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">))))) | (import ("@elastic/eui/src/components/common").DisambiguateSet<(import ("@elastic/eui/src/components/common").DisambiguateSet<(import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">), EuiListItemLayoutAsDiv> & {
	    element: "div";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.HTMLAttributes<HTMLDivElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsDiv, (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">)> & ((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor> & {
	    element: "a";
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "role">) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiListItemLayoutAsAnchor, EuiListItemLayoutAsButton> & {
	    element: "button";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "disabled" | "role">))), EuiListItemLayoutAsLi> & {
	    element: "li";
	} & CommonProps & EuiDisabledProps & {
	    children?: ReactNode;
	    /**
	     * Slot for prepended content (icons)
	     */
	    prepend?: ReactNode;
	    /**
	     * Slot for additional appended content (e.g. badges)
	     * Use extraAction instead for interactive elements.
	     */
	    append?: ReactNode;
	    /**
	     * Slot for additional interactive appended content (extra actions)
	     */
	    extraAction?: ReactNode;
	    /**
	     * Set to manually define the wrapping element for navigational items (`component=button/a`).
	     * This has no effect when `component=li/div`.
	     * @default 'li'
	     */
	    wrapperElement?: "li" | "div";
	    /**
	     * Props applied to the wrapper.
	     * Applies only for `component=button/a` if `wrapperElement` is defined or `extraAction` is passed.
	     */
	    wrapperProps?: CommonProps;
	    /**
	     * Props applied to the content wrapper element.
	     */
	    contentProps?: CommonProps;
	    /**
	     * Props applied to the label text element.
	     */
	    textProps?: CommonProps;
	    prependProps?: CommonProps;
	    appendProps?: CommonProps;
	    tooltipProps?: Omit<EuiToolTipProps, "children">;
	    /**
	     * Controls the item checked indicator and applies a semantic `aria-checked` attribute.
	     * Ensure to pass an appropriate `role` for the item that supports semantic
	     * `checked` state. For no/other role(s) `checked` only controls the visual checked indicator.
	     *
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     *
	     * When using `singleSelection=true` it's expected to only use the values `on` or `undefined`
	     * to toggle between checked and not checked.
	     */
	    checked?: EuiListItemLayoutCheckedType;
	    /**
	     * Controls the item selection state within a list (not the checked indicator).
	     * It applies an `aria-selected` or `aria-current` attributes depending on `component` and `role`.
	     * It adds a visual selected style when `isSingleSelection=true` or `showIndicator=false`.
	     */
	    isSelected?: boolean;
	    /**
	     * Highlights the item as currently navigated item within a listbox.
	     * The item is not actually focused, it will only be styled as active.
	     */
	    isFocused?: boolean;
	    /**
	     * Toggles between multi-selection (renders checkbox indicators) and
	     * single-selection (renders icon indicators).
	     * @default true
	     */
	    isSingleSelection?: boolean;
	    /**
	     * Manually overrides the selection type (checkbox vs selection) for checkable/selectable roles.
	     * This controls whether `aria-checked` or `aria-selected` attributes are set.
	     * For no `role` or unsupported roles, this has no effect and `aria-current` is applied.
	     *
	     * By default when unset, it's handled internally based on `isSingleSelection`
	     * and applies `aria-checked` to multi-selection and `aria-selected` to single-selection.
	     *
	     * Use only when you need to manually adjust this, e.g. for a single-selection
	     * multi-state checkbox item (supports exclusion or indeterminate).
	     */
	    selectionMode?: "checked" | "selected";
	    /**
	     * Controls the visibility of the indicator.
	     * @default true
	     */
	    showIndicator?: boolean;
	    /**
	     * Native `role` attribute.
	     * If you pass a custom role make sure to align `selectionMode` where needed as well.
	     * Set it to `checked` when the role natively supports checked states and to `selected` otherwise.
	     */
	    role?: HTMLAttributes<HTMLElement>["role"];
	    /**
	     * How to handle long text within the item.
	     * @default 'truncate'
	     */
	    textWrap?: "truncate" | "wrap";
	} & Omit<React.HTMLAttributes<HTMLLIElement>, "role">)) & React.RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/list_item_layout' {
	export { EuiListItemLayout } from '@elastic/eui/src/components/list_item_layout/_list_item_layout';
	export type { EuiListItemLayoutProps, EuiListItemLayoutAsLi, EuiListItemLayoutAsDiv, EuiListItemLayoutAsButton, EuiListItemLayoutAsAnchor, } from '@elastic/eui/src/components/list_item_layout/_list_item_layout';

}
declare module '@elastic/eui/src/components/context_menu/context_menu_item' {
	import React, { PropsWithChildren, ButtonHTMLAttributes, HTMLAttributes, FunctionComponent, ReactElement, ReactNode, Ref } from 'react';
	import { type _EuiExtendedButtonColor } from '@elastic/eui/src/global_styling';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { type IconType } from '@elastic/eui/src/components/icon';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export type EuiContextMenuItemIcon = IconType | ReactElement<any> | HTMLElement;
	export type EuiContextMenuItemLayoutAlignment = 'center' | 'top' | 'bottom';
	export interface EuiContextMenuItemProps extends PropsWithChildren, CommonProps {
	    icon?: EuiContextMenuItemIcon;
	    hasPanel?: boolean;
	    disabled?: boolean;
	    onClick?: (event: React.MouseEvent) => void;
	    buttonRef?: Ref<HTMLButtonElement>;
	    role?: HTMLAttributes<HTMLElement>['role'];
	    /**
	     * Required if using a tooltip. Add an optional tooltip on hover
	     */
	    toolTipContent?: ReactNode;
	    /**
	     * Optional configuration to pass to the underlying [EuiToolTip](/#/display/tooltip).
	     * Accepts any prop that EuiToolTip does, except for `content` and `children`.
	     */
	    toolTipProps?: Partial<Omit<EuiToolTipProps, 'content' | 'children'>>;
	    href?: string;
	    target?: string;
	    rel?: string;
	    /**
	     * @deprecated - will be removed in the future and handled statically as `center`
	     * How to align icon with content of button
	     */
	    layoutAlign?: EuiContextMenuItemLayoutAlignment;
	    /**
	     * Applies a color to the text and icon of the item.
	     *
	     * Deprecated: This won't match all `EuiButtonEmpty` colors in the near future.
	     * Use supported variants "text" and "danger".
	     *
	     */
	    color?: _EuiExtendedButtonColor;
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	}
	type Props = CommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'onClick' | 'disabled'> & EuiContextMenuItemProps;
	export const LAYOUT_ALIGN: EuiContextMenuItemLayoutAlignment[];
	export const EuiContextMenuItem: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/context_menu/context_menu.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiContextMenuVariables: ({ euiTheme }: UseEuiTheme) => {
	    panelWidth: string;
	};
	export const euiContextMenuStyles: (euiThemeContext: UseEuiTheme) => {
	    euiContextMenu: import("@emotion/react").SerializedStyles;
	    fixedHeight: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/context_menu/context_menu_panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiContextMenuPanelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiContextMenuPanel: import("@emotion/react").SerializedStyles;
	    next: {
	        in: import("@emotion/react").SerializedStyles;
	        out: import("@emotion/react").SerializedStyles;
	    };
	    previous: {
	        in: import("@emotion/react").SerializedStyles;
	        out: import("@emotion/react").SerializedStyles;
	    };
	    euiContextMenuPanel__title: import("@emotion/react").SerializedStyles;
	    euiContextMenuPanel__label: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/context_menu/context_menu_panel_title.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiContextMenuPanelTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiContextMenuPanelTitle: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/context_menu/context_menu_panel_title' {
	import { ReactNode, FunctionComponent, Ref } from 'react';
	import { CommonProps, NoArgCallback } from '@elastic/eui/src/components/common';
	import { EuiButtonIconProps } from '@elastic/eui/src/components/button';
	export type EuiContextMenuPanelTitleProps = CommonProps & {
	    component?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
	    id?: string;
	    title?: ReactNode;
	    buttonRef?: Ref<HTMLButtonElement>;
	    buttonProps?: EuiButtonIconProps;
	    onClose?: NoArgCallback<void>;
	};
	export const EuiContextMenuPanelTitle: FunctionComponent<EuiContextMenuPanelTitleProps>;

}
declare module '@elastic/eui/src/components/context_menu/context_menu_panel' {
	import React, { Component, CSSProperties, HTMLAttributes, PropsWithChildren, ReactElement, ReactNode } from 'react';
	import { FocusableElement } from 'tabbable';
	import { WithEuiStylesMemoizerProps } from '@elastic/eui/src/services';
	import { CommonProps, NoArgCallback } from '@elastic/eui/src/components/common';
	export type EuiContextMenuPanelHeightChangeHandler = (height: number) => void;
	export type EuiContextMenuPanelTransitionType = 'in' | 'out';
	export type EuiContextMenuPanelTransitionDirection = 'next' | 'previous';
	export type EuiContextMenuPanelShowPanelCallback = (currentPanelIndex?: number) => void;
	export type EuiContextMenuPanelProps = PropsWithChildren & CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'onKeyDown' | 'tabIndex' | 'onAnimationEnd' | 'title'> & {
	    /**
	     * Determines the initially focused menu item for keyboard and screen reader users.
	     *
	     * Can be set to `-1` to prevent autofocus (an uncommon case that must have
	     * keyboard accessibility accounted for manually if used)
	     */
	    initialFocusedItemIndex?: number;
	    items?: ReactElement[];
	    onClose?: NoArgCallback<void>;
	    onHeightChange?: EuiContextMenuPanelHeightChangeHandler;
	    onTransitionComplete?: NoArgCallback<void>;
	    onUseKeyboardToNavigate?: NoArgCallback<void>;
	    showNextPanel?: EuiContextMenuPanelShowPanelCallback;
	    showPreviousPanel?: NoArgCallback<void>;
	    title?: ReactNode;
	    transitionDirection?: EuiContextMenuPanelTransitionDirection;
	    transitionType?: EuiContextMenuPanelTransitionType;
	    height?: CSSProperties['height'];
	};
	type Props = EuiContextMenuPanelProps;
	interface State {
	    prevProps: {
	        items: Props['items'];
	    };
	    menuItems: FocusableElement[];
	    focusedItemIndex?: number;
	    currentHeight?: number;
	    height?: number;
	    waitingForInitialPopover: boolean;
	    tookInitialFocus: boolean;
	}
	export class EuiContextMenuPanelClass extends Component<WithEuiStylesMemoizerProps & Props, State> {
	    static defaultProps: Partial<Props>;
	    private _isMounted;
	    private backButton?;
	    private panel?;
	    private initialPopoverParent?;
	    constructor(props: WithEuiStylesMemoizerProps & Props);
	    findMenuItems: () => void;
	    focusMenuItem: (direction: "up" | "down") => void;
	    setInitialFocusedItemIndex: (event: React.FocusEvent<HTMLDivElement>) => void;
	    onKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
	    takeInitialFocus(): void;
	    reclaimPopoverFocus: () => void;
	    onTransitionComplete: () => void;
	    componentDidUpdate(prevProps: Props): void;
	    componentDidMount(): void;
	    componentWillUnmount(): void;
	    static getDerivedStateFromProps(nextProps: Props, prevState: State): Partial<State> | null;
	    updateHeight(): void;
	    getInitialPopoverParent(): void;
	    panelRef: (node: HTMLElement | null) => void;
	    rootId: (idSuffix?: string) => string;
	    render(): React.JSX.Element;
	}
	export const EuiContextMenuPanel: React.ForwardRefExoticComponent<Omit<EuiContextMenuPanelProps, "stylesMemoizer"> & React.RefAttributes<Omit<EuiContextMenuPanelProps, "stylesMemoizer">>>;
	export {};

}
declare module '@elastic/eui/src/components/context_menu/context_menu' {
	import React, { Component, HTMLAttributes, CSSProperties, ReactElement, ReactNode } from 'react';
	import { WithEuiStylesMemoizerProps } from '@elastic/eui/src/services';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiHorizontalRuleProps } from '@elastic/eui/src/components/horizontal_rule';
	import { EuiContextMenuPanelTransitionDirection, EuiContextMenuPanelTransitionType } from '@elastic/eui/src/components/context_menu/context_menu_panel';
	import { EuiContextMenuItemProps } from '@elastic/eui/src/components/context_menu/context_menu_item';
	export type EuiContextMenuPanelId = string | number;
	export type EuiContextMenuPanelItemDescriptorEntry = Omit<EuiContextMenuItemProps, 'hasPanel'> & {
	    name: React.ReactNode;
	    key?: string;
	    panel?: EuiContextMenuPanelId;
	};
	export interface EuiContextMenuPanelItemSeparator extends EuiHorizontalRuleProps {
	    isSeparator: true;
	    key?: string;
	}
	export type EuiContextMenuPanelItemRenderCustom = {
	    /**
	     * Allows rendering any custom content alongside your array of context menu items.
	     * Accepts either a component or an inline function component that returns any JSX.
	     */
	    renderItem: (() => ReactNode) | Function;
	    key?: string;
	};
	export type EuiContextMenuPanelItemDescriptor = ExclusiveUnion<ExclusiveUnion<EuiContextMenuPanelItemDescriptorEntry, EuiContextMenuPanelItemSeparator>, EuiContextMenuPanelItemRenderCustom>;
	export interface EuiContextMenuPanelDescriptor extends CommonProps {
	    id: EuiContextMenuPanelId;
	    title?: ReactNode;
	    items?: EuiContextMenuPanelItemDescriptor[];
	    content?: ReactNode;
	    width?: CSSProperties['width'];
	    initialFocusedItemIndex?: number;
	}
	export type EuiContextMenuProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'style'> & {
	    panels?: EuiContextMenuPanelDescriptor[];
	    /**
	     * Optional callback that fires on every panel change. Passes back
	     * the new panel ID and whether its direction was `next` or `previous`.
	     */
	    onPanelChange?: (panelDetails: {
	        panelId: EuiContextMenuPanelId;
	        direction?: EuiContextMenuPanelTransitionDirection;
	    }) => void;
	    initialPanelId?: EuiContextMenuPanelId;
	    height?: CSSProperties['height'];
	};
	interface State {
	    prevProps: {
	        panels?: EuiContextMenuPanelDescriptor[];
	    };
	    idToPanelMap: {
	        [id: string]: EuiContextMenuPanelDescriptor;
	    };
	    idToPreviousPanelIdMap: {
	        [panel: string]: EuiContextMenuPanelId;
	    };
	    idAndItemIndexToPanelIdMap: {
	        [id: string]: {
	            [index: string]: EuiContextMenuPanelId;
	        };
	    };
	    idToRenderedItemsMap: {
	        [id: string]: ReactElement[];
	    };
	    height?: number;
	    outgoingPanelId?: EuiContextMenuPanelId;
	    incomingPanelId?: EuiContextMenuPanelId;
	    transitionDirection?: EuiContextMenuPanelTransitionDirection;
	    isOutgoingPanelVisible: boolean;
	    focusedItemIndex?: number;
	    isUsingKeyboardToNavigate: boolean;
	}
	export class EuiContextMenuClass extends Component<WithEuiStylesMemoizerProps & EuiContextMenuProps, State> {
	    static defaultProps: Partial<EuiContextMenuProps>;
	    static getDerivedStateFromProps(nextProps: EuiContextMenuProps, prevState: State): Partial<State> | null;
	    constructor(props: WithEuiStylesMemoizerProps & EuiContextMenuProps);
	    componentDidUpdate(prevProps: EuiContextMenuProps): void;
	    hasPreviousPanel: (panelId: EuiContextMenuPanelId) => boolean;
	    showPanel(panelId: EuiContextMenuPanelId, direction?: EuiContextMenuPanelTransitionDirection): void;
	    showNextPanel: (itemIndex?: number) => void;
	    showPreviousPanel: () => void;
	    onIncomingPanelHeightChange: (height: number) => void;
	    onOutGoingPanelTransitionComplete: () => void;
	    onUseKeyboardToNavigate: () => void;
	    mapIdsToRenderedItems: (panels?: EuiContextMenuPanelDescriptor[]) => {
	        [id: string]: React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
	    };
	    renderItems(items: EuiContextMenuPanelItemDescriptor[] | undefined, idToPanelMap: {
	        [id: string]: EuiContextMenuPanelDescriptor;
	    }): React.JSX.Element[];
	    renderPanel(panelId: EuiContextMenuPanelId, transitionType: EuiContextMenuPanelTransitionType): React.JSX.Element | undefined;
	    render(): React.JSX.Element;
	}
	export const EuiContextMenu: React.ForwardRefExoticComponent<Omit<EuiContextMenuProps, "stylesMemoizer"> & React.RefAttributes<Omit<EuiContextMenuProps, "stylesMemoizer">>>;
	export {};

}
declare module '@elastic/eui/src/components/context_menu' {
	export type { EuiContextMenuProps, EuiContextMenuPanelDescriptor, EuiContextMenuPanelItemDescriptor, } from '@elastic/eui/src/components/context_menu/context_menu';
	export { EuiContextMenu } from '@elastic/eui/src/components/context_menu/context_menu';
	export type { EuiContextMenuPanelProps } from '@elastic/eui/src/components/context_menu/context_menu_panel';
	export { EuiContextMenuPanel } from '@elastic/eui/src/components/context_menu/context_menu_panel';
	export type { EuiContextMenuItemProps, EuiContextMenuItemIcon, EuiContextMenuItemLayoutAlignment, } from '@elastic/eui/src/components/context_menu/context_menu_item';
	export { EuiContextMenuItem } from '@elastic/eui/src/components/context_menu/context_menu_item';
	export { EuiContextMenuPanelTitle, type EuiContextMenuPanelTitleProps, } from '@elastic/eui/src/components/context_menu/context_menu_panel_title';

}
declare module '@elastic/eui/src/components/pagination/pagination_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPaginationButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPaginationButton: import("@emotion/react").SerializedStyles;
	    isActive: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/pagination/pagination_button' {
	import { FunctionComponent } from 'react';
	import { ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	export type EuiPaginationButtonProps = EuiButtonEmptyProps & {
	    isActive?: boolean;
	    pageIndex: number;
	    totalPages?: number;
	};
	type EuiPaginationButtonPropsForAnchor = PropsForAnchor<EuiPaginationButtonProps>;
	type EuiPaginationButtonPropsForButton = PropsForButton<EuiPaginationButtonProps>;
	type Props = ExclusiveUnion<EuiPaginationButtonPropsForAnchor, EuiPaginationButtonPropsForButton>;
	export const EuiPaginationButton: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/pagination/pagination_button_arrow' {
	import { FunctionComponent } from 'react';
	import { EuiButtonIconPropsForAnchor } from '@elastic/eui/src/components/button/button_icon';
	export const TYPES: ("first" | "last" | "next" | "previous")[];
	export type EuiPaginationButtonArrowType = (typeof TYPES)[number];
	export type Props = Partial<Omit<EuiButtonIconPropsForAnchor, 'type'>> & {
	    type: EuiPaginationButtonArrowType;
	    disabled?: boolean;
	    ariaControls?: string;
	};
	export const EuiPaginationButtonArrow: FunctionComponent<Props>;

}
declare module '@elastic/eui/src/components/pagination/pagination.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPaginationStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPagination: import("@emotion/react").SerializedStyles;
	    euiPagination__compressedText: import("@emotion/react").SerializedStyles;
	    euiPagination__list: import("@emotion/react").SerializedStyles;
	    euiPagination__ellipsis: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/pagination/pagination' {
	import { FunctionComponent, HTMLAttributes, MouseEvent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	export type PageClickHandler = (pageIndex: number) => void;
	export type SafeClickHandler = (e: MouseEvent, pageIndex: number) => void;
	export interface EuiPaginationProps {
	    /**
	     * The total number of pages.
	     * Pass `0` if total count is unknown.
	     */
	    pageCount?: number;
	    /**
	     * The current page using a zero based index.
	     * So if you set the activePage to 1, it will activate the second page.
	     * Pass `-1` for forcing to last page.
	     */
	    activePage?: number;
	    /**
	     * Click handler that passes back the internally calculated `activePage` index
	     */
	    onPageClick?: (pageIndex: number) => void;
	    /**
	     * If true, will only show next/prev arrows and simplified number set.
	     */
	    compressed?: boolean;
	    /**
	     * If passed in, passes value through to each button to set aria-controls.
	     */
	    'aria-controls'?: string;
	    /**
	     * Automatically reduces to the `compressed` version on smaller screens.
	     * Remove completely with `false` or provide your own list of responsive breakpoints.
	     */
	    responsive?: false | EuiBreakpointSize[];
	}
	type Props = CommonProps & HTMLAttributes<HTMLDivElement> & EuiPaginationProps;
	export const EuiPagination: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/pagination' {
	export type { EuiPaginationProps } from '@elastic/eui/src/components/pagination/pagination';
	export { EuiPagination } from '@elastic/eui/src/components/pagination/pagination';
	export type { EuiPaginationButtonProps } from '@elastic/eui/src/components/pagination/pagination_button';
	export { EuiPaginationButton } from '@elastic/eui/src/components/pagination/pagination_button';

}
declare module '@elastic/eui/src/components/table/table_pagination/table_pagination_defaults' {
	import { EuiTablePaginationProps } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
	/**
	 * Table pagination prop defaults live in a separate file because
	 * they'll be reused by basic tables and datagrids as fallbacks
	 */
	export const euiTablePaginationDefaults: Required<Pick<EuiTablePaginationProps, 'itemsPerPage' | 'itemsPerPageOptions' | 'showPerPageOptions'>>;
	export const useEuiTablePaginationDefaults: () => {
	    itemsPerPage: number;
	    itemsPerPageOptions: number[];
	    showPerPageOptions: boolean;
	};

}
declare module '@elastic/eui/src/components/table/table_pagination/table_pagination' {
	import { FunctionComponent } from 'react';
	import { EuiPaginationProps } from '@elastic/eui/src/components/pagination';
	export type PageChangeHandler = EuiPaginationProps['onPageClick'];
	export type ItemsPerPageChangeHandler = (pageSize: number) => void;
	export interface EuiTablePaginationProps extends Omit<EuiPaginationProps, 'onPageClick'> {
	    /**
	     * Option to completely hide the "Rows per page" selector.
	     *
	     * @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/basic_table/pagination_bar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * @internal
	 */
	export const euiBasicTablePaginationBarStyles: (theme: UseEuiTheme) => {
	    root: import("@emotion/react").SerializedStyles;
	    panelled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/basic_table/pagination_bar' {
	import React from 'react';
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	import type { ItemsPerPageChangeHandler, PageChangeHandler } from '@elastic/eui/src/components/table/table_pagination/table_pagination';
	export interface Pagination {
	    /**
	     * The current page (zero-based) index
	     */
	    pageIndex: number;
	    /**
	     * The maximum number of items that can be shown in a single page.
	     * Pass `0` to display the selected "Show all" option and hide the pagination.
	     *
	     * @default 10
	     */
	    pageSize?: number;
	    /**
	     * The total number of items the page is "sliced" of
	     */
	    totalItemCount: number;
	    /**
	     * Configures the page size dropdown options.
	     * Pass `0` as one of the options to create a "Show all" option.
	     *
	     * @default [10, 25, 50]
	     */
	    pageSizeOptions?: number[];
	    /**
	     * Set to false to hide the page size dropdown
	     *
	     * @default true
	     */
	    showPerPageOptions?: boolean;
	}
	/**
	 * @internal
	 */
	interface PaginationBarProps {
	    pagination: Pagination;
	    /**
	     * Enable the panelled style.
	     *
	     * Panelled style adds contrast between the table navigation controls
	     * and table content itself. It should be used in tables rendered outside
	     * EUI containers like `<EuiPanel>` or `<EuiFlyout>`.
	     * @default false
	     */
	    panelled?: boolean;
	    responsiveBreakpoint?: EuiBreakpointSize | boolean;
	    onPageSizeChange: ItemsPerPageChangeHandler;
	    onPageChange: PageChangeHandler;
	    /**
	     * id of the table being controlled
	     */
	    'aria-controls'?: string;
	    'aria-label'?: string;
	}
	/**
	 * An internal utility component that renders EuiTablePagination with
	 * proper configuration and handles the `panelled` styles.
	 * @internal
	 */
	export const PaginationBar: ({ pagination, panelled, responsiveBreakpoint, onPageSizeChange, onPageChange, "aria-controls": ariaControls, "aria-label": ariaLabel, }: PaginationBarProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/basic_table/action_types' {
	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';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	type IconFunction<T extends object> = (item: T) => EuiIconType;
	type ButtonColor = EuiButtonIconProps['color'] | EuiButtonEmptyProps['color'];
	type EuiButtonIconColorFunction<T> = (item: T) => ButtonColor;
	export interface DefaultItemActionBase<T extends object> {
	    /**
	     * The display name of the action (will render as visible text if rendered within a collapsed menu)
	     */
	    name: ReactNode | ((item: T) => ReactNode);
	    /**
	     * Describes the action (will render as tooltip content)
	     */
	    description: string | ((item: T) => string);
	    /**
	     * 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, event: MouseEvent) => void;
	    href?: string | ((item: T) => string);
	    target?: string;
	    /**
	     * A callback function that determines whether the action is available
	     */
	    available?: (item: T) => boolean;
	    /**
	     * A callback function that determines whether the action is enabled
	     */
	    enabled?: (item: T) => 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> {
	    /**
	     * The type of action
	     */
	    type?: 'button';
	    color?: EuiButtonEmptyProps['color'] | EuiButtonIconColorFunction<T>;
	}
	export interface DefaultItemIconButtonAction<T extends object> extends DefaultItemActionBase<T> {
	    type: 'icon';
	    /**
	     * Associates an icon with the button
	     */
	    icon: EuiIconType | IconFunction<T>;
	    /**
	     * Defines the color of the button
	     */
	    color?: EuiButtonIconProps['color'] | EuiButtonIconColorFunction<T>;
	}
	export type DefaultItemAction<T extends object> = ExclusiveUnion<DefaultItemEmptyButtonAction<T>, DefaultItemIconButtonAction<T>>;
	export type CustomItemAction<T> = {
	    /**
	     * Allows rendering a totally custom action
	     */
	    render: (item: T, enabled: boolean) => ReactElement;
	    /**
	     * A callback that defines whether the action is available
	     */
	    available?: (item: T) => boolean;
	    /**
	     * A callback that defines whether the action is enabled
	     */
	    enabled?: (item: T) => boolean;
	} & Pick<DefaultItemActionBase<{}>, 'isPrimary' | 'showOnHover'>;
	export type Action<T extends object> = DefaultItemAction<T> | CustomItemAction<T>;
	export const isCustomItemAction: <T extends object>(action: DefaultItemAction<T> | CustomItemAction<T>) => action is CustomItemAction<T>;
	export const callWithItemIfFunction: <T>(item: T) => <U>(prop: U | ((item: T) => U)) => U;
	export {};

}
declare module '@elastic/eui/src/services/sort/sort_direction' {
	import PropTypes from 'prop-types'; const ASC: "asc"; const DESC: "desc";
	export type Direction = typeof ASC | typeof DESC;
	export const SortDirection: Readonly<{
	    ASC: "asc";
	    DESC: "desc";
	    isAsc(direction: Direction): direction is "asc";
	    reverse(direction: Direction): "desc" | "asc";
	}>;
	export const SortDirectionType: PropTypes.Requireable<"desc" | "asc">;
	export {};

}
declare module '@elastic/eui/src/services/objects' {
	export const get: (object: {}, path: string[] | string, defaultValue?: any) => any;
	export const omit: (object: {} | null | undefined, paths: string[]) => Partial<{}>;

}
declare module '@elastic/eui/src/services/sort/comparators' {
	export type Primitive = string | boolean | number | null | undefined;
	type Comparator<T = Primitive> = (a: T, b: T) => number;
	export const Comparators: Readonly<{
	    default: (direction?: "asc" | "desc") => (v1: Primitive, v2: Primitive) => number;
	    reverse: <T>(comparator: Comparator<T>) => Comparator<T>;
	    value<T>(valueCallback: (value: T) => Primitive, comparator?: Comparator): Comparator<T>;
	    property<T extends object>(prop: string, comparator?: Comparator): Comparator<T>;
	}>;
	export {};

}
declare module '@elastic/eui/src/components/basic_table/table_types' {
	import { ReactElement, ReactNode, TdHTMLAttributes } from 'react';
	import { HorizontalAlignment } from '@elastic/eui/src/services';
	import { Pagination } from '@elastic/eui/src/components/basic_table/pagination_bar';
	import { Action } from '@elastic/eui/src/components/basic_table/action_types';
	import { Primitive } from '@elastic/eui/src/services/sort/comparators';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiTableRowCellProps, EuiTableRowCellMobileOptionsShape } from '@elastic/eui/src/components/table/table_row_cell';
	import { EuiToolTipProps, EuiIconTipProps } from '@elastic/eui/src/components/tool_tip';
	export type ItemId<T> = string | number | ((item: T) => string);
	export type ItemIdResolved = string | number;
	export type EuiTableDataType = 'auto' | 'string' | 'number' | 'boolean' | 'date';
	export interface EuiTableFooterProps<T> {
	    items: T[];
	    pagination?: Pagination;
	}
	/** Allows adding an icon with a tooltip to column names */
	export type EuiTableColumnNameTooltipProps = {
	    /** The main content of the tooltip */
	    content: ReactNode;
	    /**
	     * The icon type to display
	     * @default 'question'
	     */
	    icon?: IconType;
	    /** Additional props for EuiIcon */
	    iconProps?: EuiIconTipProps['iconProps'];
	    /** Additional props for the EuiToolTip */
	    tooltipProps?: Omit<EuiToolTipProps, 'children' | 'position'> & {
	        position?: EuiToolTipProps['position'];
	    };
	};
	export interface EuiTableFieldDataColumnType<T> extends CommonProps, Omit<TdHTMLAttributes<HTMLTableCellElement>, 'width' | 'align'> {
	    /**
	     * A field of the item (may be a nested field)
	     */
	    field: keyof T | (string & {});
	    /**
	     * The display name of the column
	     */
	    name: ReactNode;
	    /**
	     * Allows adding an icon with a tooltip displayed next to the name
	     */
	    nameTooltip?: EuiTableColumnNameTooltipProps;
	    /**
	     * A description of the column (will be presented as a title over the column header)
	     */
	    description?: string;
	    /**
	     * Describes the data types of the displayed value (serves as a rendering hint for the table)
	     */
	    dataType?: EuiTableDataType;
	    /**
	     * Requested width of the column.
	     *
	     * Exact width settings are not guaranteed in certain table layouts
	     * or configurations, and may be adjusted by browser's algorithm.
	     * Consider this value a guidance.
	     *
	     * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/table-layout#values|table-layout algorithms on MDN}
	     */
	    width?: string;
	    /**
	     * Requested minimum width of the column.
	     *
	     * Exact width settings are not guaranteed in certain table layouts
	     * or configurations, and may be adjusted by browser's algorithm.
	     * Consider this value a guidance.
	     *
	     * This property takes effect only when `tableLayout="auto"` is set on the table.
	     */
	    minWidth?: string;
	    /**
	     * Requested maximum width of the column.
	     *
	     * Exact width settings are not guaranteed in certain table layouts
	     * or configurations, and may be adjusted by browser's algorithm.
	     * Consider this value a guidance.
	     *
	     * This property takes effect only when `tableLayout="auto"` is set on the table.
	     */
	    maxWidth?: string;
	    /**
	     * 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);
	    /**
	     * Disables the user's ability to change the sort, but will still
	     * show the current sort direction in the column header
	     */
	    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.
	     * - To enable multi-line truncation, use a configuration object with `lines`
	     * 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;
	    };
	    /**
	     * A custom renderer for this column's cell content.
	     * Unlike computed columns or `mobileOptions.render`, this function receives:
	     * - `value`: The value of the specified field for this row
	     * - `item`: The full data item (row object)
	     */
	    render?: (value: any, item: T) => ReactNode;
	    /**
	     * Content to display in the footer beneath this column
	     */
	    footer?: string | ReactElement | ((props: EuiTableFooterProps<T>) => ReactNode);
	    /**
	     * If passing `itemIdToExpandedRowMap` to your table, set this flag to `true`
	     * for the custom column or cell used to toggle the expanded row.
	     */
	    isExpander?: boolean;
	}
	export type EuiTableComputedColumnType<T> = CommonProps & Omit<TdHTMLAttributes<HTMLTableCellElement>, 'width' | 'align'> & {
	    /**
	     * A function that computes the value for each item and renders it
	     */
	    render: (item: T) => ReactNode;
	    /**
	     * The display name of the column
	     */
	    name?: ReactNode;
	    /**
	     * Allows configuring an icon with a tooltip, to be displayed next to the name
	     */
	    nameTooltip?: EuiTableColumnNameTooltipProps;
	    /**
	     * If provided, allows this column to be sorted on. Must return the value to sort against.
	     */
	    sortable?: (item: T) => Primitive;
	} & Pick<EuiTableFieldDataColumnType<T>, 'readOnly' | 'description' | 'width' | 'minWidth' | 'maxWidth' | 'align' | 'truncateText' | 'isExpander'>;
	export type EuiTableActionsColumnType<T extends object> = {
	    /**
	     * An array of one of the objects: {@link DefaultItemAction} or {@link CustomItemAction}
	     */
	    actions: Array<Action<T>>;
	    /**
	     * The display name of the column
	     */
	    name?: ReactNode;
	    /**
	     * Allows configuring an icon with a tooltip, to be displayed next to the name
	     */
	    nameTooltip?: EuiTableColumnNameTooltipProps;
	    /**
	     * Whether the actions column should always stick to the right side
	     * of the table no matter the inline (horizontal) scroll position.
	     *
	     * This option should be used in tables with `scrollableInline={true}`
	     * and will be enabled by default in future versions of EUI.
	     *
	     * Currently, it can only be used when the actions column is the last column
	     * of the table.
	     *
	     * When set to `true` and `hasBackground: false` is set on the table,
	     * `--euiTableCellStickyBackgroundColor` CSS variable should be set to match
	     * the background color of the element containing the table.
	     * Otherwise, the sticky column will use the default `backgroundBasePlain`
	     * background color.
	     * @beta
	     * @default false
	     */
	    sticky?: boolean;
	} & Pick<EuiTableFieldDataColumnType<T>, 'description' | 'width' | 'minWidth' | 'maxWidth'>;
	export interface EuiTableSortingType<T> {
	    /**
	     * Indicates the property/field to sort on
	     */
	    sort?: {
	        field: keyof T;
	        direction: 'asc' | 'desc';
	    };
	    /**
	     * Enables/disables unsorting of table columns. Supported by EuiInMemoryTable.
	     */
	    allowNeutralSort?: boolean;
	    /**
	     * Enables the default sorting ability for each column.
	     */
	    enableAllColumns?: boolean;
	    /**
	     * Disables the user's ability to change the sort but still shows the current direction
	     */
	    readOnly?: boolean;
	}
	export interface EuiTableSelectionType<T> {
	    /**
	     * A callback that will be called whenever the item selection changes.
	     *
	     * Required if `selected` is passed.
	     */
	    onSelectionChange?: (selection: T[]) => void;
	    /**
	     * A callback that is called per item to indicate whether it is selectable
	     */
	    selectable?: (item: T) => boolean;
	    /**
	     * A callback that is called per item to retrieve a message for its selectable state.
	     * We display these messages as a tooltip on an unselectable checkbox
	     */
	    selectableMessage?: (selectable: boolean, item: T) => string;
	    /**
	     * Sets initially selected items. Use for uncontrolled selection behavior (checkbox
	     * will only change from user input, and not from developer control).
	     *
	     * This prop will be ignored if `selected` is passed.
	     */
	    initialSelected?: T[];
	    /**
	     * Used for controlled selection behavior, e.g. when you want to programmatically
	     * control which selection checkboxes are checked, and which are not.
	     */
	    selected?: T[];
	}

}
declare module '@elastic/eui/src/components/table/table_header_cell_shared' {
	export const HEADER_CELL_SCOPE: readonly ["col", "row", "colgroup", "rowgroup"];

}
declare module '@elastic/eui/src/components/table/sticky_header' {
	export { EuiTableStickyHeader } from '@elastic/eui/src/components/table/sticky_header/sticky_header';
	export { useEuiTableWithinStickyHeader } from '@elastic/eui/src/components/table/sticky_header/context';

}
declare module '@elastic/eui/src/components/table/store/use_unique_column_id' {
	import React from 'react';
	/**
	 * Returns a stable unique column ID to be used when registering columns.
	 * It uses `React.useId()` when available and falls back to UUID v4 on React 17.
	 *
	 * This is needed so that static `uuid` mocks don't break column registration
	 * (at least in React 18+; in older versions this function would need
	 * to be mocked to return something unique, but stable).
	 * @internal
	 */
	export const useEuiTableStoreUniqueColumnId: typeof React.useId;

}
declare module '@elastic/eui/src/components/table/table_header_cell' {
	import { FunctionComponent, ThHTMLAttributes, ReactNode } 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';
	import type { EuiTableColumnNameTooltipProps } from '@elastic/eui/src/components/basic_table/table_types';
	import { HEADER_CELL_SCOPE } from '@elastic/eui/src/components/table/table_header_cell_shared';
	import type { EuiTableSharedWidthProps, EuiTableStickyCellOptions } from '@elastic/eui/src/components/table/types';
	export type TableHeaderCellScope = (typeof HEADER_CELL_SCOPE)[number];
	export type EuiTableHeaderCellProps = CommonProps & Omit<ThHTMLAttributes<HTMLTableCellElement>, 'align' | 'scope' | 'width'> & EuiTableSharedWidthProps & {
	    align?: HorizontalAlignment;
	    isSortAscending?: boolean;
	    isSorted?: boolean;
	    mobileOptions?: Pick<EuiTableRowCellMobileOptionsShape, 'only' | 'show'>;
	    onSort?: NoArgCallback<void>;
	    scope?: TableHeaderCellScope;
	    /** Allows adding an icon with a tooltip displayed next to the name */
	    tooltipProps?: EuiTableColumnNameTooltipProps;
	    description?: string;
	    /**
	     * Shows the sort indicator but removes the button
	     */
	    readOnly?: boolean;
	    /**
	     * Content rendered outside the visible cell content wrapper. Useful for, e.g. screen reader text.
	     *
	     * Used by EuiBasicTable to render hidden copy markers
	     */
	    append?: ReactNode;
	    /**
	     * Whether the cell should stick to a side of the table.
	     *
	     * This option is not applied in the responsive cards layout - see
	     * {@link EuiTableProps#responsiveBreakpoint|`responsiveBreakpoint`}.
	     *
	     * Currently, it can only be used when the cell is in the first or the last
	     * column of a table.
	     *
	     * When set to `true` and `hasBackground: false` is set on the table,
	     * `--euiTableCellStickyBackgroundColor` CSS variable should be set to match
	     * the background color of the element containing the table.
	     * Otherwise, the sticky cell will use the default `backgroundBasePlain`
	     * background color.
	     * @internal
	     * @beta
	     * @default false
	     */
	    sticky?: EuiTableStickyCellOptions;
	};
	export const EuiTableHeaderCell: FunctionComponent<EuiTableHeaderCellProps>;

}
declare module '@elastic/eui/src/components/table/table_header_cell_checkbox' {
	import { FunctionComponent, ThHTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { HEADER_CELL_SCOPE } from '@elastic/eui/src/components/table/table_header_cell_shared';
	import type { EuiTableSharedWidthProps } from '@elastic/eui/src/components/table/types';
	export type EuiTableHeaderCellCheckboxScope = (typeof HEADER_CELL_SCOPE)[number];
	export interface EuiTableHeaderCellCheckboxProps extends EuiTableSharedWidthProps {
	    scope?: EuiTableHeaderCellCheckboxScope;
	    append?: ReactNode;
	}
	export const EuiTableHeaderCellCheckbox: FunctionComponent<CommonProps & Omit<ThHTMLAttributes<HTMLTableCellElement>, 'width'> & EuiTableHeaderCellCheckboxProps>;

}
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/react").SerializedStyles;
	};

}
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/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, { Key, ReactNode } 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[];
	}
	export const EuiTableSortMobile: {
	    ({ className, anchorPosition, items, ...rest }: EuiTableSortMobileProps): React.JSX.Element;
	    displayName: string;
	};
	export {};

}
declare module '@elastic/eui/src/global_styling/functions/supports' {
	export const cssSupportsSelector: (selector: string, value: string) => string;
	/**
	 * Util to check if the "previous sibling" selector :has(+) is supported
	 */
	export const cssSupportsHasWithNextSibling: (value: string) => string;

}
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/react").SerializedStyles;
	    desktop: {
	        desktop: import("@emotion/react").SerializedStyles;
	        expanded: {
	            expanded: import("@emotion/react").SerializedStyles;
	            hasBackground: string;
	        };
	        clickable: import("@emotion/react").SerializedStyles;
	        selected: import("@emotion/react").SerializedStyles;
	        checkboxOffset: import("@emotion/react").SerializedStyles;
	    };
	    mobile: {
	        mobile: import("@emotion/react").SerializedStyles;
	        hasBorder: string;
	        hasBackground: import("@emotion/react").SerializedStyles;
	        selected: import("@emotion/react").SerializedStyles;
	        /**
	         * Left column offset (no border)
	         * Used for selection checkbox, which will be absolutely positioned
	         */
	        hasLeftColumn: import("@emotion/react").SerializedStyles;
	        /**
	         * Right column styles + border
	         * Used for cell actions and row expander arrow
	         */
	        hasRightColumn: import("@emotion/react").SerializedStyles;
	        /**
	         * Bottom of card - expanded rows
	         */
	        expanded: import("@emotion/react").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 {
	    /**
	     * Indicates if the table has a single column of checkboxes for selecting
	     * rows (used for mobile styling)
	     */
	    hasSelection?: boolean;
	    /**
	     * Indicates that the current row's checkbox is selectable / not disabled
	     */
	    isSelectable?: boolean;
	    /**
	     * Indicates the current row has been selected
	     */
	    isSelected?: boolean;
	    /**
	     * Indicates if the table has a dedicated column for actions
	     * (used for mobile styling and desktop action hover behavior)
	     */
	    hasActions?: boolean | 'custom';
	    /**
	     * 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/components/table/table_row_cell_checkbox' {
	import { FunctionComponent, TdHTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const EuiTableRowCellCheckbox: FunctionComponent<CommonProps & TdHTMLAttributes<HTMLTableCellElement> & {
	    append?: ReactNode;
	}>;

}
declare module '@elastic/eui/src/components/table' {
	export type { EuiTableProps } from '@elastic/eui/src/components/table/table';
	export { EuiTable } from '@elastic/eui/src/components/table/table';
	export type { EuiTableBodyProps } from '@elastic/eui/src/components/table/table_body';
	export { EuiTableBody } from '@elastic/eui/src/components/table/table_body';
	export { EuiTableFooter } from '@elastic/eui/src/components/table/table_footer';
	export type { EuiTableFooterCellProps } from '@elastic/eui/src/components/table/table_footer_cell';
	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 { 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';
	export { EuiTableHeaderCellCheckbox } from '@elastic/eui/src/components/table/table_header_cell_checkbox';
	export type { EuiTablePaginationProps } from '@elastic/eui/src/components/table/table_pagination';
	export { EuiTablePagination } from '@elastic/eui/src/components/table/table_pagination';
	export { EuiTableHeaderMobile } from '@elastic/eui/src/components/table/mobile/table_header_mobile';
	export type { EuiTableSortMobileProps } from '@elastic/eui/src/components/table/mobile/table_sort_mobile';
	export { EuiTableSortMobile } from '@elastic/eui/src/components/table/mobile/table_sort_mobile';
	export type { EuiTableSortMobileItemProps } from '@elastic/eui/src/components/table/mobile/table_sort_mobile_item';
	export { EuiTableSortMobileItem } from '@elastic/eui/src/components/table/mobile/table_sort_mobile_item';
	export type { EuiTableRowProps } from '@elastic/eui/src/components/table/table_row';
	export { EuiTableRow } from '@elastic/eui/src/components/table/table_row';
	export type { EuiTableRowCellProps } from '@elastic/eui/src/components/table/table_row_cell';
	export { EuiTableRowCell } from '@elastic/eui/src/components/table/table_row_cell';
	export { EuiTableRowCellCheckbox } from '@elastic/eui/src/components/table/table_row_cell_checkbox';
	export { EUI_TABLE_CSS_CONTAINER_NAME } from '@elastic/eui/src/components/table/const';

}
declare module '@elastic/eui/src/components/list_group/list_group_item_extra_action.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiListGroupItemExtraActionStyles: ({ euiTheme, }: UseEuiTheme) => {
	    euiListGroupItemExtraAction: import("@emotion/react").SerializedStyles;
	    hoverStyles: import("@emotion/react").SerializedStyles;
	    alwaysShow: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/list_group/list_group_item_extra_action' {
	import { FunctionComponent } from 'react';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	export type EuiListGroupItemExtraActionProps = {
	    alwaysShow?: boolean;
	} & EuiButtonIconPropsForButton;
	type _FromEuiListGroupItem = {
	    parentIsDisabled?: boolean;
	};
	export const EuiListGroupItemExtraAction: FunctionComponent<EuiListGroupItemExtraActionProps & _FromEuiListGroupItem>;
	export {};

}
declare module '@elastic/eui/src/components/list_group/list_group_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiListGroupItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiListGroupItem: import("@emotion/react").SerializedStyles;
	    euiListGroupItem__inner: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	};
	export const euiListGroupItemTooltipStyles: {
	    euiListGroupItem__tooltip: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/list_group/list_group_item' {
	import React, { HTMLAttributes, AnchorHTMLAttributes, ButtonHTMLAttributes, ReactNode, ReactElement, MouseEventHandler, FunctionComponent } from 'react';
	import { EuiDisabledProps } from '@elastic/eui/src/services';
	import { ExclusiveUnion, CommonProps } from '@elastic/eui/src/components/common';
	import { IconType, EuiIconProps } from '@elastic/eui/src/components/icon';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	import { EuiListGroupItemExtraActionProps } from '@elastic/eui/src/components/list_group/list_group_item_extra_action';
	export const COLORS: readonly ["primary", "text", "subdued"];
	export type EuiListGroupItemColor = (typeof COLORS)[number];
	export type EuiListGroupItemProps = CommonProps & Omit<ExclusiveUnion<ExclusiveUnion<ButtonHTMLAttributes<HTMLButtonElement>, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>>, HTMLAttributes<HTMLSpanElement>>, 'onClick' | 'color' | 'target' | 'rel'> & EuiDisabledProps & {
	    /**
	     * By default the item will get the color `text`.
	     * You can customize the color of the item by passing a color name.
	     * @default 'text'
	     */
	    color?: EuiListGroupItemColor;
	    /**
	     * Content to be displayed in the list item
	     */
	    label: ReactNode;
	    /**
	     * Apply styles indicating an item is active
	     */
	    isActive?: boolean;
	    /**
	     * Make the list item label a link.
	     * While permitted, `href` and `onClick` should not be used together in most cases and may create problems.
	     */
	    href?: string;
	    rel?: string;
	    target?: string;
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	    /**
	     * Adds `EuiIcon` of `EuiIcon.type`
	     */
	    iconType?: IconType;
	    /**
	     * Further extend the props applied to EuiIcon
	     */
	    iconProps?: Omit<EuiIconProps, 'type'>;
	    /**
	     * Custom node to pass as the icon. Cannot be used in conjunction
	     * with `iconType` and `iconProps`.
	     */
	    icon?: ReactElement;
	    /**
	     * Display tooltip on list item
	     */
	    showToolTip?: boolean;
	    /**
	     * An object of {@link EuiListGroupItemExtraAction} props.
	     * Adds an `EuiButtonIcon` to the right side of the item; `iconType` is required;
	     * pass `alwaysShow` if you don't want the default behavior of only showing on hover
	     */
	    extraAction?: EuiListGroupItemExtraActionProps;
	    /**
	     * Make the list item label a button.
	     * While permitted, `href` and `onClick` should not be used together in most cases and may create problems.
	     */
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Allow link text to wrap
	     */
	    wrapText?: boolean;
	    /**
	     * Pass-through ref reference specifically for targeting
	     * instances where the item content is rendered as a `button`
	     */
	    buttonRef?: React.Ref<HTMLButtonElement>;
	    /**
	     * Text to be displayed in the tooltip when `showToolTip` is true.
	     * By default the text will be same as the label text.
	     */
	    toolTipText?: string;
	    /**
	     * Allows customizing the tooltip shown when `showToolTip` is true.
	     * Accepts any props that [EuiToolTip](/#/display/tooltip) accepts.
	     */
	    toolTipProps?: Partial<EuiToolTipProps>;
	};
	export const EuiListGroupItem: FunctionComponent<EuiListGroupItemProps>;

}
declare module '@elastic/eui/src/components/list_group/list_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiListGroupStyles: (euiThemeContext: UseEuiTheme) => {
	    euiListGroup: import("@emotion/react").SerializedStyles;
	    bordered: import("@emotion/react").SerializedStyles;
	    maxWidthDefault: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/list_group/list_group' {
	import { FunctionComponent, HTMLAttributes, CSSProperties } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group/list_group_item';
	export type EuiListGroupProps = CommonProps & Omit<HTMLAttributes<HTMLUListElement>, 'color'> & {
	    /**
	     * Add a border to the list container
	     */
	    bordered?: boolean;
	    /**
	     * Items to display in this group. See {@link EuiListGroupItem}
	     */
	    listItems?: EuiListGroupItemProps[];
	    /**
	     * Change the colors of all `listItems` at once
	     * @default text
	     */
	    color?: EuiListGroupItemProps['color'];
	    /**
	     * Sets the max-width of the page.
	     * Set to `true` to use the default size,
	     * set to `false` to not restrict the width,
	     * or set to a number/string for a custom CSS width/measurement.
	     */
	    maxWidth?: boolean | CSSProperties['maxWidth'];
	    /**
	     * Display tooltips on all list items
	     */
	    showToolTips?: boolean;
	    /**
	     * Allow link text to wrap vs truncated
	     */
	    wrapText?: boolean;
	    ariaLabelledby?: string;
	};
	export const EuiListGroup: FunctionComponent<EuiListGroupProps>;

}
declare module '@elastic/eui/src/components/list_group/pinnable_list_group/pinnable_list_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPinnableListGroupItemExtraActionStyles: ({ euiTheme, }: UseEuiTheme) => {
	    euiPinnableListGroup__itemExtraAction: import("@emotion/react").SerializedStyles;
	    pinned: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/list_group/pinnable_list_group/pinnable_list_group' {
	import { FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiListGroupProps } from '@elastic/eui/src/components/list_group/list_group';
	import { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group/list_group_item';
	export type EuiPinnableListGroupItemProps = EuiListGroupItemProps & {
	    /**
	     * Saves the pinned status and changes the visibility of the pin icon
	     */
	    pinned?: boolean;
	    /**
	     * Passing `onPinClick` to the full EuiPinnableListGroup, will make every item pinnable.
	     * Set this property to `false` to turn off individual item pinnability
	     */
	    pinnable?: boolean;
	};
	export interface EuiPinnableListGroupProps extends CommonProps, EuiListGroupProps {
	    /**
	     * Extends `EuiListGroupItemProps`, at the very least, expecting a `label`.
	     * See {@link EuiPinnableListGroupItemProps}
	     */
	    listItems: EuiPinnableListGroupItemProps[];
	    /**
	     * Shows the pin icon and calls this function on click.
	     * Returns `item: EuiPinnableListGroupItemProps`
	     */
	    onPinClick: (item: EuiPinnableListGroupItemProps) => void;
	    /**
	     * The pin icon needs a title/aria-label for accessibility.
	     * It is a function that passes the item back and must return a string `(item) => string`.
	     * Default is `"Pin item"`
	     */
	    pinTitle?: (item: EuiPinnableListGroupItemProps) => string;
	    /**
	     * The unpin icon needs a title/aria-label for accessibility.
	     * It is a function that passes the item back and must return a string `(item) => string`.
	     * Default is `"Unpin item"`
	     */
	    unpinTitle?: (item: EuiPinnableListGroupItemProps) => string;
	}
	export const EuiPinnableListGroup: FunctionComponent<EuiPinnableListGroupProps>;

}
declare module '@elastic/eui/src/components/list_group/pinnable_list_group' {
	export type { EuiPinnableListGroupProps, EuiPinnableListGroupItemProps, } from '@elastic/eui/src/components/list_group/pinnable_list_group/pinnable_list_group';
	export { EuiPinnableListGroup } from '@elastic/eui/src/components/list_group/pinnable_list_group/pinnable_list_group';

}
declare module '@elastic/eui/src/components/list_group' {
	export type { EuiListGroupProps } from '@elastic/eui/src/components/list_group/list_group';
	export { EuiListGroup } from '@elastic/eui/src/components/list_group/list_group';
	export type { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group/list_group_item';
	export type { EuiListGroupItemExtraActionProps } from '@elastic/eui/src/components/list_group/list_group_item_extra_action';
	export { EuiListGroupItem } from '@elastic/eui/src/components/list_group/list_group_item';
	export type { EuiPinnableListGroupProps, EuiPinnableListGroupItemProps, } from '@elastic/eui/src/components/list_group/pinnable_list_group';
	export { EuiPinnableListGroup } from '@elastic/eui/src/components/list_group/pinnable_list_group';

}
declare module '@elastic/eui/src/components/flyout/const' {
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	/** Allowed flyout render types. */
	export const FLYOUT_TYPES: readonly ["push", "overlay"];
	/** Type representing a supported flyout render type. */
	export type _EuiFlyoutType = (typeof FLYOUT_TYPES)[number];
	/** Allowed flyout attachment sides. */
	export const FLYOUT_SIDES: readonly ["left", "right"];
	/** Type representing a supported flyout side. */
	export type _EuiFlyoutSide = (typeof FLYOUT_SIDES)[number];
	/** Allowed named flyout sizes used by the manager. */
	export const FLYOUT_SIZES: readonly ["s", "m", "l", "fill"];
	/** Type representing a supported named flyout size. */
	export type EuiFlyoutSize = (typeof FLYOUT_SIZES)[number];
	/** Menu display mode: always render menu when flyoutMenuProps is provided. */
	export const MENU_DISPLAY_ALWAYS: "always";
	/** Menu display mode: only render menu when it has content (back button, history, title, or custom actions). */
	export const MENU_DISPLAY_AUTO: "auto";
	/** Allowed flyout menu display modes. */
	export const FLYOUT_MENU_DISPLAY_MODES: readonly ["always", "auto"];
	/** Type representing a supported flyout menu display mode. */
	export type EuiFlyoutMenuDisplayMode = (typeof FLYOUT_MENU_DISPLAY_MODES)[number];
	/** Allowed padding sizes for flyout content. */
	export const FLYOUT_PADDING_SIZES: readonly ["none", "s", "m", "l"];
	/** Type representing a supported flyout padding size. */
	export type _EuiFlyoutPaddingSize = (typeof FLYOUT_PADDING_SIZES)[number];
	/** Default minimum breakpoint at which push-type flyouts begin to push content. */
	export const DEFAULT_PUSH_MIN_BREAKPOINT: EuiBreakpointSize;
	/** Default flyout type when none is provided. */
	export const DEFAULT_TYPE: _EuiFlyoutType;
	/** Default side where flyouts anchor when none is provided. */
	export const DEFAULT_SIDE: _EuiFlyoutSide;
	/** Default named flyout size. */
	export const DEFAULT_SIZE: EuiFlyoutSize;
	/** Default padding size inside flyouts. */
	export const DEFAULT_PADDING_SIZE: _EuiFlyoutPaddingSize;
	/** Default flyout menu display mode. */
	export const DEFAULT_MENU_DISPLAY_MODE: EuiFlyoutMenuDisplayMode;
	/**
	 * Custom type checker for named flyout sizes since the prop
	 * `size` can also be CSSProperties['width'] (string | number)
	 */
	export function isEuiFlyoutSizeNamed(value: unknown): value is EuiFlyoutSize;

}
declare module '@elastic/eui/src/components/flyout/flyout.styles' {
	import { EuiFlyoutSize } from '@elastic/eui/src/components/flyout/const';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const FLYOUT_BREAKPOINT: "m";
	export const euiFlyoutSlideInRight: import("@emotion/serialize").Keyframes;
	export const euiFlyoutSlideOutRight: import("@emotion/serialize").Keyframes;
	export const euiFlyoutSlideInLeft: import("@emotion/serialize").Keyframes;
	export const euiFlyoutSlideOutLeft: import("@emotion/serialize").Keyframes;
	/**
	 * When a `container` reference element is provided, the flyout's position
	 * and dimensions are constrained to the container's bounding rect via
	 * inline styles computed in JS.
	 */
	export const euiFlyoutStyles: (euiThemeContext: UseEuiTheme) => {
	    noMaxWidth: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    overlay: {
	        overlay: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    push: {
	        push: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	    };
	    noAnimation: import("@emotion/react").SerializedStyles;
	    paddingSizes: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    fill: import("@emotion/react").SerializedStyles;
	    euiFlyout: import("@emotion/react").SerializedStyles;
	};
	/**
	 * Applies a max-width constraint at the flyout breakpoint.
	 */
	export const maxedFlyoutWidth: (euiThemeContext: UseEuiTheme) => string;
	/**
	 * Composes the full set of named size styles (`s`, `m`, `l`, `fill`).
	 *
	 * Uses `%` units for widths. Media queries drive responsive breakpoints.
	 *
	 * When a child flyout is stacked on top of the parent, the parent flyout
	 * size will match the child flyout size. The `s` and `m` sizes include
	 * overrides for this stacked-child behavior.
	 */
	export const composeFlyoutSizing: (euiThemeContext: UseEuiTheme) => {
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    fill: import("@emotion/react").SerializedStyles;
	};
	/**
	 * Composes all inline styles for a flyout based on its configuration.
	 * Uses a CSS custom property (`--euiFlyoutMainWidth`) for synchronous
	 * tracking of the main flyout width during resize drag, falling back to
	 * the pixel value from manager state when the variable is not set.
	 */
	export const composeFlyoutInlineStyles: (size: EuiFlyoutSize | string | number, layoutMode: "side-by-side" | "stacked", siblingFlyoutId: string | null, siblingFlyoutWidth: number | null, maxWidth: boolean | number | string | undefined, zIndex?: number) => React.CSSProperties;

}
declare module '@elastic/eui/src/components/flyout/_flyout_close_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutCloseButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlyout__closeButton: import("@emotion/react").SerializedStyles;
	    inside: import("@emotion/react").SerializedStyles;
	    outside: import("@emotion/react").SerializedStyles;
	    outsideSide: {
	        right: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flyout/_flyout_close_button' {
	import { FunctionComponent } from 'react';
	import type { EuiFlyoutProps } from '@elastic/eui/src/components/flyout/flyout';
	type EuiFlyoutCloseButtonProps = EuiFlyoutProps['closeButtonProps'] & Required<Pick<EuiFlyoutProps, 'closeButtonPosition' | 'onClose' | 'side'>>;
	export const EuiFlyoutCloseButton: FunctionComponent<EuiFlyoutCloseButtonProps>;
	export {};

}
declare module '@elastic/eui/src/components/flyout/flyout_menu.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutMenuStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlyoutMenu__container: import("@emotion/react").SerializedStyles;
	    euiFlyoutMenu__spacer: import("@emotion/react").SerializedStyles;
	    euiFlyoutMenu__actions: import("@emotion/react").SerializedStyles;
	    euiFlyoutMenu__hiddenTitle: import("@emotion/react").SerializedStyles;
	    euiFlyoutMenu__paginationCounter: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout_menu_context' {
	import { EuiFlyoutProps } from '@elastic/eui/src/components/flyout/flyout';
	interface EuiFlyoutMenuContextProps {
	    onClose?: EuiFlyoutProps['onClose'];
	}
	export const EuiFlyoutMenuContext: import("react").Context<EuiFlyoutMenuContextProps>;
	export {};

}
declare module '@elastic/eui/src/components/flyout/types' {
	export type EuiFlyoutCloseEvent = MouseEvent | TouchEvent | KeyboardEvent;
	/**
	 * Describes the source that triggered a flyout close. Passed to `onClose` via
	 * the optional `meta` argument so consumers can react differently per source.
	 *
	 * - `close-button`: the default/X close button (base flyout and managed menu)
	 * - `escape`: the Escape key
	 * - `outside-click`: a click on the overlay mask or outside the flyout
	 * - `navigation-back`: a managed flyout closed because the user pressed Back
	 * - `navigation-cascade`: a managed flyout closed because a parent navigated
	 *   away or the main flyout closed (e.g. a tab switch)
	 */
	export type EuiFlyoutCloseReason = 'close-button' | 'escape' | 'outside-click' | 'navigation-back' | 'navigation-cascade';
	/**
	 * Optional metadata passed as the second argument to a flyout's `onClose`
	 * callback, describing why the flyout closed.
	 */
	export interface EuiFlyoutCloseMeta {
	    reason: EuiFlyoutCloseReason;
	}

}
declare module '@elastic/eui/src/components/flyout/flyout_menu' {
	import React, { FunctionComponent, HTMLAttributes } from 'react';
	import { EuiButtonProps } from '@elastic/eui/src/components/button';
	import { CommonProps, PropsForAnchor } from '@elastic/eui/src/components/common';
	import type { IconType } from '@elastic/eui/src/components/icon';
	type EuiFlyoutMenuBackButtonProps = Pick<PropsForAnchor<EuiButtonProps>, 'aria-label' | 'data-test-subj' | 'onClick'>;
	/**
	 * History item for the flyout menu history popover
	 */
	export interface EuiFlyoutHistoryItem {
	    /**
	     * Title for the history item
	     */
	    title: string;
	    /**
	     * An optional icon to display next to the session title in the history menu
	     */
	    iconType?: IconType;
	    /**
	     * onClick handler for the history item
	     */
	    onClick: () => void;
	}
	/**
	 * Pagination configuration for the flyout menu
	 */
	export interface EuiFlyoutMenuPagination {
	    /**
	     * Zero-based index of the currently displayed item
	     */
	    currentIndex: number;
	    /**
	     * Total number of items
	     */
	    total: number;
	    /**
	     * Called when the user clicks the Previous button
	     */
	    onPrevious: () => void;
	    /**
	     * Called when the user clicks the Next button
	     */
	    onNext: () => void;
	}
	/**
	 * Custom action item for the flyout menu component
	 */
	export interface EuiFlyoutMenuCustomAction {
	    /**
	     * Icon type for the action button
	     */
	    iconType: string;
	    /**
	     * onClick handler for the action button
	     */
	    onClick: () => void;
	    /**
	     * Aria label for the action button
	     */
	    'aria-label': string;
	}
	/**
	 * Props for EuiFlyoutMenu
	 */
	export type EuiFlyoutMenuProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * An id to use for the title element. Useful for setting aria-labelledby on the flyout.
	     * Example:
	     * ```jsx
	     * <EuiFlyout
	     *   aria-labelledby="myMenuTitleId"
	     *   flyoutMenuProps={{ title: 'Menu title', titleId: 'myMenuTitleId' }
	     * >
	     *  ...
	     * </EuiFlyout>
	     * ```
	     */
	    titleId?: string;
	    /**
	     * Title for the menu component. In a managed flyout context, the title is used to indicate the flyout session for history navigation.
	     */
	    title?: React.ReactNode;
	    /**
	     * An optional icon to display next to the session title in the history menu
	     */
	    iconType?: IconType;
	    /**
	     * Hides the title in the `EuiFlyoutMenu`.
	     * @default true
	     * @deprecated Use `EuiFlyoutHeader` for visible titles instead.
	     * `hideTitle` is still honored but may be removed in a future major version.
	     */
	    hideTitle?: boolean;
	    /**
	     * Hides the close button in the menu component
	     * @default false
	     */
	    hideCloseButton?: boolean;
	    /**
	     * Shows a back button in the menu component
	     * @default false
	     */
	    showBackButton?: boolean;
	    /**
	     * Props to pass to the back button, such as `onClick` handler
	     */
	    backButtonProps?: EuiFlyoutMenuBackButtonProps;
	    /**
	     * List of history items for the history popover
	     */
	    historyItems?: EuiFlyoutHistoryItem[];
	    /**
	     * List of custom action items for the menu component
	     */
	    customActions?: EuiFlyoutMenuCustomAction[];
	    /**
	     * Enables Prev/Next navigation controls and a position counter in the menu bar.
	     * Pagination replaces back/history navigation in the left menu slot.
	     */
	    pagination?: EuiFlyoutMenuPagination;
	};
	/**
	 * The component for the top menu bar inside a flyout. Since this is a private
	 * component, rendering is controlled using the `flyoutMenuProps` prop on
	 * `EuiFlyout`. In managed session flyouts, the Flyout Manager controls a back
	 * button and history popover for navigating to different flyout sessions
	 * within the managed context.
	 *
	 * @private
	 */
	export const EuiFlyoutMenu: FunctionComponent<EuiFlyoutMenuProps>;
	export {};

}
declare module '@elastic/eui/src/components/flyout/manager/const' {
	/**
	 * Allowed values for `session` prop to control the way the session is managed for a flyout.
	 */
	export const SESSION_START = "start";
	export const SESSION_INHERIT = "inherit";
	export const SESSION_NEVER = "never";
	/**
	 * Data attribute applied to a managed flyout element to help identify it as a managed flyout.
	 */
	export const PROPERTY_FLYOUT = "data-managed-flyout";
	/**
	 * Data attribute indicating whether the flyout is the `main` or `child` flyout.
	 */
	export const PROPERTY_LEVEL = "data-managed-flyout-level";
	/**
	 * Data attribute representing how multiple flyouts are laid out
	 * (`side-by-side` or `stacked`).
	 */
	export const PROPERTY_LAYOUT_MODE = "data-managed-flyout-layout-mode";
	/** Stacked layout mode where child flyouts overlay on top of the main flyout. */
	export const LAYOUT_MODE_STACKED = "stacked";
	/** Side-by-side layout mode where child flyouts render adjacent to the main flyout. */
	export const LAYOUT_MODE_SIDE_BY_SIDE = "side-by-side";
	/** The primary (parent) flyout in a session. */
	export const LEVEL_MAIN = "main";
	/** The secondary (child) flyout spawned by the main flyout. */
	export const LEVEL_CHILD = "child";
	/** Flyout is mounting and playing its opening animation. */
	export const STAGE_OPENING = "opening";
	/** Flyout is fully visible and interactive. */
	export const STAGE_ACTIVE = "active";
	/** Flyout is unmounted or not currently visible/interactable. */
	export const STAGE_INACTIVE = "inactive";
	/** Main flyout is transitioning behind an active session flyout. */
	export const STAGE_BACKGROUNDING = "backgrounding";
	/** Main flyout is backgrounded behind an active session flyout. */
	export const STAGE_BACKGROUNDED = "backgrounded";
	/** Flyout is returning to the foreground from a backgrounded state. */
	export const STAGE_RETURNING = "returning";
	/** Flyout is playing its closing animation. */
	export const STAGE_CLOSING = "closing";

}
declare module '@elastic/eui/src/components/flyout/manager/types' {
	import type { IconType } from '@elastic/eui/src/components/icon';
	import type { EuiFlyoutMenuPagination } from '@elastic/eui/src/components/flyout/flyout_menu';
	import type { Action } from '@elastic/eui/src/components/flyout/manager/actions';
	import { STAGE_CLOSING, STAGE_OPENING, STAGE_ACTIVE, STAGE_INACTIVE, STAGE_BACKGROUNDING, STAGE_BACKGROUNDED, STAGE_RETURNING, LAYOUT_MODE_SIDE_BY_SIDE, LAYOUT_MODE_STACKED, LEVEL_CHILD, LEVEL_MAIN } from '@elastic/eui/src/components/flyout/manager/const';
	export type EuiFlyoutLayoutMode = typeof LAYOUT_MODE_STACKED | typeof LAYOUT_MODE_SIDE_BY_SIDE;
	export type EuiFlyoutLevel = typeof LEVEL_MAIN | typeof LEVEL_CHILD;
	export type EuiFlyoutActivityStage = typeof STAGE_OPENING | typeof STAGE_ACTIVE | typeof STAGE_INACTIVE | typeof STAGE_BACKGROUNDING | typeof STAGE_BACKGROUNDED | typeof STAGE_RETURNING | typeof STAGE_CLOSING;
	export interface EuiManagedFlyoutState {
	    flyoutId: string;
	    level: EuiFlyoutLevel;
	    width?: number;
	    size?: string;
	    minWidth?: number;
	    activityStage?: EuiFlyoutActivityStage;
	    pagination?: EuiFlyoutMenuPagination;
	}
	/** Entry for a child flyout in session history. */
	export interface ChildHistoryEntry {
	    flyoutId: string;
	    title: string;
	    iconType?: IconType;
	}
	export interface FlyoutSession {
	    /** ID of the main flyout for this session */
	    mainFlyoutId: string;
	    /** ID of the child flyout for this session */
	    childFlyoutId: string | null;
	    /** Title of the main flyout in this session */
	    title: string;
	    /** Optional icon for this session when shown in history popover */
	    iconType?: IconType;
	    /** z-index value to be used by the flyout session */
	    zIndex: number;
	    /** Title of the current child flyout. */
	    childTitle?: string;
	    /** Icon of the current child flyout. */
	    childIconType?: IconType;
	    /** Stack of child flyouts we navigated away from. */
	    childHistory: ChildHistoryEntry[];
	    /** Key that scopes this session's history; same Symbol reference = same history group. Always set (from action or Symbol()). */
	    historyKey: symbol;
	}
	export interface PushPaddingOffsets {
	    /** Push padding applied to the left side (in pixels) */
	    left: number;
	    /** Push padding applied to the right side (in pixels) */
	    right: number;
	}
	export interface EuiFlyoutManagerState {
	    sessions: FlyoutSession[];
	    flyouts: EuiManagedFlyoutState[];
	    layoutMode: EuiFlyoutLayoutMode;
	    /** Active push padding offsets (updated by active push flyouts) */
	    pushPadding?: PushPaddingOffsets;
	    currentZIndex: number;
	    unmanagedFlyouts: string[];
	    /** The container element that flyouts are positioned relative to (if any). */
	    containerElement?: HTMLElement | null;
	    /**
	     * Reference width used for layout and resize clamping (container or viewport).
	     * Set by the layout mode hook so flyouts use the same value for consistent clamping.
	     */
	    referenceWidth?: number;
	}
	/**
	 * Public API surface provided through React context.
	 * Kept intentionally decoupled from action types to avoid module cycles.
	 */
	export interface FlyoutManagerApi {
	    state: EuiFlyoutManagerState;
	    dispatch: (action: Action) => void;
	    addFlyout: (flyoutId: string, title: string, level?: EuiFlyoutLevel, size?: string, historyKey?: symbol, iconType?: IconType, minWidth?: number) => void;
	    closeFlyout: (flyoutId: string) => void;
	    closeAllFlyouts: () => void;
	    setActiveFlyout: (flyoutId: string | null) => void;
	    setFlyoutWidth: (flyoutId: string, width: number) => void;
	    setPagination: (flyoutId: string, pagination: EuiFlyoutMenuPagination | undefined) => void;
	    setPushPadding: (side: 'left' | 'right', width: number) => void;
	    setContainerElement: (element: HTMLElement | null) => void;
	    goBack: () => void;
	    goToFlyout: (flyoutId: string, level?: EuiFlyoutLevel) => void;
	    addUnmanagedFlyout: (flyoutId: string) => void;
	    closeUnmanagedFlyout: (flyoutId: string) => void;
	    historyItems: Array<{
	        title: string;
	        iconType?: IconType;
	        onClick: () => void;
	    }>;
	}

}
declare module '@elastic/eui/src/components/flyout/manager/actions' {
	import type { IconType } from '@elastic/eui/src/components/icon';
	import type { EuiFlyoutMenuPagination } from '@elastic/eui/src/components/flyout/flyout_menu';
	import { EuiFlyoutActivityStage, EuiFlyoutLevel, EuiFlyoutLayoutMode } from '@elastic/eui/src/components/flyout/manager/types'; const PREFIX: "eui/flyoutManager";
	interface BaseAction {
	    type: `${typeof PREFIX}/${string}`;
	}
	/** Dispatched when a flyout registers itself with the manager. */
	export const ACTION_ADD: "eui/flyoutManager/add";
	/** Dispatched to remove a flyout from the manager (usually on close/unmount). */
	export const ACTION_CLOSE: "eui/flyoutManager/close";
	/** Dispatched to remove all flyouts from the manager. */
	export const ACTION_CLOSE_ALL: "eui/flyoutManager/closeAll";
	/** Dispatched to set which flyout is currently active within the session. */
	export const ACTION_SET_ACTIVE: "eui/flyoutManager/setActive";
	/** Dispatched when an active flyout's pixel width changes (for responsive layout). */
	export const ACTION_SET_WIDTH: "eui/flyoutManager/setWidth";
	/** Dispatched to set a flyout's menu pagination. */
	export const ACTION_SET_PAGINATION: "eui/flyoutManager/setPagination";
	/** Dispatched to switch layout mode between `side-by-side` and `stacked`. */
	export const ACTION_SET_LAYOUT_MODE: "eui/flyoutManager/setLayoutMode";
	/** Dispatched to update a flyout's activity stage (e.g., opening -> active). */
	export const ACTION_SET_ACTIVITY_STAGE: "eui/flyoutManager/setActivityStage";
	/** Dispatched to go back one session (remove current session). */
	export const ACTION_GO_BACK: "eui/flyoutManager/goBack";
	/** Dispatched to navigate to a specific flyout (remove all sessions after it). */
	export const ACTION_GO_TO_FLYOUT: "eui/flyoutManager/goToFlyout";
	/** Dispatched to set push padding offset for a side. */
	export const ACTION_SET_PUSH_PADDING: "eui/flyoutManager/setPushPadding";
	/** Dispatched to set the container element for container-relative flyouts. */
	export const ACTION_SET_CONTAINER_ELEMENT: "eui/flyoutManager/setContainerElement";
	/** Dispatched to set the reference width used for layout and resize clamping. */
	export const ACTION_SET_REFERENCE_WIDTH: "eui/flyoutManager/setReferenceWidth";
	export const ACTION_ADD_UNMANAGED_FLYOUT: "eui/flyoutManager/addUnmanagedFlyout";
	export const ACTION_CLOSE_UNMANAGED_FLYOUT: "eui/flyoutManager/closeUnmanagedFlyout";
	/**
	 * Add a flyout to manager state. The manager will create or update
	 * the current session depending on the `level` provided.
	 */
	export interface AddFlyoutAction extends BaseAction {
	    type: typeof ACTION_ADD;
	    flyoutId: string;
	    title: string;
	    level: EuiFlyoutLevel;
	    size?: string;
	    historyKey?: symbol;
	    iconType?: IconType;
	    minWidth?: number;
	}
	/** Remove a flyout from manager state. Also updates the active session. */
	export interface CloseFlyoutAction extends BaseAction {
	    type: typeof ACTION_CLOSE;
	    flyoutId: string;
	}
	/** Remove all flyouts from manager state. */
	export interface CloseAllFlyoutsAction extends BaseAction {
	    type: typeof ACTION_CLOSE_ALL;
	}
	/** Set the active flyout within the current session (or clear with `null`). */
	export interface SetActiveFlyoutAction extends BaseAction {
	    type: typeof ACTION_SET_ACTIVE;
	    flyoutId: string | null;
	}
	/** Update a flyout's measured width in pixels. */
	export interface SetWidthAction extends BaseAction {
	    type: typeof ACTION_SET_WIDTH;
	    flyoutId: string;
	    width: number;
	}
	/** Set the manager pagination value for a flyout. */
	export interface SetPaginationAction extends BaseAction {
	    type: typeof ACTION_SET_PAGINATION;
	    flyoutId: string;
	    pagination: EuiFlyoutMenuPagination | undefined;
	}
	/** Change how flyouts are arranged: `side-by-side` or `stacked`. */
	export interface SetLayoutModeAction extends BaseAction {
	    type: typeof ACTION_SET_LAYOUT_MODE;
	    layoutMode: EuiFlyoutLayoutMode;
	}
	/** Set a specific flyout's activity stage. */
	export interface SetActivityStageAction extends BaseAction {
	    type: typeof ACTION_SET_ACTIVITY_STAGE;
	    flyoutId: string;
	    activityStage: EuiFlyoutActivityStage;
	}
	/** Go back one session (remove current session from stack). */
	export interface GoBackAction extends BaseAction {
	    type: typeof ACTION_GO_BACK;
	}
	/** Navigate to a specific flyout (remove all sessions after it, or pop to child in history). */
	export interface GoToFlyoutAction extends BaseAction {
	    type: typeof ACTION_GO_TO_FLYOUT;
	    flyoutId: string;
	    /** When 'child', find flyout in current session's childHistory and pop to it. When 'main' or omitted, find session by mainFlyoutId. */
	    level?: EuiFlyoutLevel;
	}
	/** Set push padding offset for a specific side. */
	export interface SetPushPaddingAction extends BaseAction {
	    type: typeof ACTION_SET_PUSH_PADDING;
	    side: 'left' | 'right';
	    width: number;
	}
	export interface AddUnmanagedFlyoutAction extends BaseAction {
	    type: typeof ACTION_ADD_UNMANAGED_FLYOUT;
	    flyoutId: string;
	}
	export interface CloseUnmanagedFlyoutAction extends BaseAction {
	    type: typeof ACTION_CLOSE_UNMANAGED_FLYOUT;
	    flyoutId: string;
	}
	/** Set the container element for container-relative positioning. */
	export interface SetContainerElementAction extends BaseAction {
	    type: typeof ACTION_SET_CONTAINER_ELEMENT;
	    element: HTMLElement | null;
	}
	/** Set the reference width for layout and resize clamping. */
	export interface SetReferenceWidthAction extends BaseAction {
	    type: typeof ACTION_SET_REFERENCE_WIDTH;
	    width: number;
	}
	/** Union of all flyout manager actions. */
	export type Action = AddFlyoutAction | CloseFlyoutAction | CloseAllFlyoutsAction | SetActiveFlyoutAction | SetWidthAction | SetPaginationAction | SetLayoutModeAction | SetActivityStageAction | GoBackAction | GoToFlyoutAction | SetPushPaddingAction | AddUnmanagedFlyoutAction | CloseUnmanagedFlyoutAction | SetContainerElementAction | SetReferenceWidthAction;
	/**
	 * Register a flyout with the manager.
	 * - `title` is used for the flyout menu.
	 * - `level` determines whether the flyout is `main` or `child`.
	 * - Optional `size` is the named EUI size (e.g. `s`, `m`, `l`).
	 * - Optional `historyKey` (Symbol) scopes history; only flyouts with the same reference share Back/history. Omit for a unique group per session.
	 * - Optional `iconType` is shown next to the session title in the history menu.
	 */
	export const addFlyout: (flyoutId: string, title: string, level?: EuiFlyoutLevel, size?: string, historyKey?: symbol, iconType?: IconType, minWidth?: number) => AddFlyoutAction;
	/** Unregister a flyout and update the session accordingly. */
	export const closeFlyout: (flyoutId: string) => CloseFlyoutAction;
	/** Unregister all flyouts. */
	export const closeAllFlyouts: () => CloseAllFlyoutsAction;
	/** Set or clear the active flyout for the current session. */
	export const setActiveFlyout: (flyoutId: string | null) => SetActiveFlyoutAction;
	/** Record a flyout's current width in pixels. */
	export const setFlyoutWidth: (flyoutId: string, width: number) => SetWidthAction;
	/**
	 * Set (or clear) the menu pagination config for a flyout. When set, this
	 * overrides any pagination passed via `flyoutMenuProps.pagination` on the
	 * flyout itself, allowing reactive updates from a different React root.
	 *
	 * Only works for managed flyouts. Unmanaged flyouts (session={false}) must use
	 * the `flyoutMenuProps.pagination` prop instead.
	 */
	export const setPagination: (flyoutId: string, pagination: EuiFlyoutMenuPagination | undefined) => SetPaginationAction;
	/** Switch layout mode between `side-by-side` and `stacked`. */
	export const setLayoutMode: (layoutMode: EuiFlyoutLayoutMode) => SetLayoutModeAction;
	/** Update a flyout's activity stage. */
	export const setActivityStage: (flyoutId: string, activityStage: EuiFlyoutActivityStage) => SetActivityStageAction;
	/** Go back one session (remove current session from stack). */
	export const goBack: () => GoBackAction;
	/** Navigate to a specific flyout (remove all sessions after it, or pop to child in history when level === 'child'). */
	export const goToFlyout: (flyoutId: string, level?: EuiFlyoutLevel) => GoToFlyoutAction;
	/** Set push padding offset for a specific side. */
	export const setPushPadding: (side: "left" | "right", width: number) => SetPushPaddingAction;
	/** Register an unmanaged flyout for z-index positioning purposes */
	export const addUnmanagedFlyout: (flyoutId: string) => AddUnmanagedFlyoutAction;
	/** Unregister an unmanaged flyout */
	export const closeUnmanagedFlyout: (flyoutId: string) => CloseUnmanagedFlyoutAction;
	/** Set the container element for container-relative flyout positioning. */
	export const setContainerElement: (element: HTMLElement | null) => SetContainerElementAction;
	/** Set the reference width for layout and resize clamping. */
	export const setReferenceWidth: (width: number) => SetReferenceWidthAction;
	export {};

}
declare module '@elastic/eui/src/components/flyout/manager/reducer' {
	import { Action } from '@elastic/eui/src/components/flyout/manager/actions';
	import { EuiFlyoutManagerState } from '@elastic/eui/src/components/flyout/manager/types';
	/**
	 * Default flyout manager state used to initialize the reducer.
	 */
	export const initialState: EuiFlyoutManagerState;
	/**
	 * Reducer handling all flyout manager actions and state transitions.
	 */
	export function flyoutManagerReducer(state: EuiFlyoutManagerState | undefined, action: Action): EuiFlyoutManagerState;

}
declare module '@elastic/eui/src/components/flyout/manager/store' {
	import type { IconType } from '@elastic/eui/src/components/icon';
	import type { EuiFlyoutMenuPagination } from '@elastic/eui/src/components/flyout/flyout_menu';
	import type { EuiFlyoutCloseMeta } from '@elastic/eui/src/components/flyout/types';
	import type { EuiFlyoutLevel, EuiFlyoutManagerState, FlyoutSession } from '@elastic/eui/src/components/flyout/manager/types';
	import type { Action } from '@elastic/eui/src/components/flyout/manager/actions';
	type Listener = () => void;
	/**
	 * Events emitted by the flyout manager store for external consumers.
	 */
	export type FlyoutManagerEvent = {
	    type: 'CLOSE_SESSION';
	    session: FlyoutSession;
	};
	type EventListener = (event: FlyoutManagerEvent) => void;
	export interface FlyoutManagerStore {
	    getState: () => EuiFlyoutManagerState;
	    subscribe: (listener: Listener) => () => void;
	    subscribeToEvents: (listener: EventListener) => () => void;
	    dispatch: (action: Action) => void;
	    addFlyout: (flyoutId: string, title: string, level?: EuiFlyoutLevel, size?: string, historyKey?: symbol, iconType?: IconType, minWidth?: number) => void;
	    closeFlyout: (flyoutId: string) => void;
	    closeAllFlyouts: () => void;
	    setActiveFlyout: (flyoutId: string | null) => void;
	    setFlyoutWidth: (flyoutId: string, width: number) => void;
	    setPagination: (flyoutId: string, pagination: EuiFlyoutMenuPagination | undefined) => void;
	    setPushPadding: (side: 'left' | 'right', width: number) => void;
	    setContainerElement: (element: HTMLElement | null) => void;
	    goBack: () => void;
	    goToFlyout: (flyoutId: string, level?: EuiFlyoutLevel) => void;
	    addUnmanagedFlyout: (flyoutId: string) => void;
	    closeUnmanagedFlyout: (flyoutId: string) => void;
	    /**
	     * Reads and clears any close `meta` previously stashed for `flyoutId` (e.g.
	     * `goBack` stamps the flyouts it removes with `navigation-back`). Used
	     * internally by managed flyouts to report the correct close reason; defaults
	     * to `navigation-cascade` when nothing was stashed.
	     */
	    consumeCloseMeta: (flyoutId: string) => EuiFlyoutCloseMeta | undefined;
	    historyItems: Array<{
	        title: string;
	        iconType?: IconType;
	        onClick: () => void;
	    }>;
	}
	/**
	 * Returns a singleton store instance shared across all React roots within the same JS context.
	 * Uses module-level singleton to ensure deduplication even if modules are loaded twice.
	 */
	export function getFlyoutManagerStore(): FlyoutManagerStore;
	/**
	 * For testing purposes - allows resetting the store
	 */
	export function _resetFlyoutManagerStore(): void;
	export {};

}
declare module '@elastic/eui/src/components/flyout/manager/selectors' {
	export const useSession: (flyoutId?: string | null) => import ("@elastic/eui/src/components/flyout/manager/types").FlyoutSession | null;
	/** True when any managed flyout session is currently active. */
	export const useHasActiveSession: () => boolean;
	/** True if the given `flyoutId` is the main or child flyout in the latest session. */
	export const useIsFlyoutActive: (flyoutId: string) => boolean;
	export const useFlyout: (flyoutId?: string | null) => import ("@elastic/eui/src/components/flyout/manager/types").EuiManagedFlyoutState | null;
	export const useIsFlyoutRegistered: (flyoutId?: string | null) => boolean;
	/** The most recent flyout session or `null` if none. */
	export const useCurrentSession: () => import ("@elastic/eui/src/components/flyout/manager/types").FlyoutSession | null;
	/** The registered state of the current session's main flyout, if present. */
	export const useCurrentMainFlyout: () => import ("@elastic/eui/src/components/flyout/manager/types").EuiManagedFlyoutState | null;
	/** The registered state of the current session's child flyout, if present. */
	export const useCurrentChildFlyout: () => import ("@elastic/eui/src/components/flyout/manager/types").EuiManagedFlyoutState | null;
	/** The measured width (px) of the specified flyout, or `null` if unknown. */
	export const useFlyoutWidth: (flyoutId?: string | null) => number | undefined;
	/** Returns the store pagination override for a flyout, if set. */
	export const useFlyoutPagination: (flyoutId?: string | null) => import("..").EuiFlyoutMenuPagination | undefined;
	/** The configured minWidth (px) of the specified flyout, or `undefined` if not set. */
	export const useFlyoutMinWidth: (flyoutId?: string | null) => number | undefined;
	/** The configured size of the parent (main) flyout for a given child flyout ID. */
	export const useParentFlyoutSize: (childFlyoutId: string) => string | undefined;
	/** True if the provided `flyoutId` is the main flyout and it currently has a child. */
	export const useHasChildFlyout: (flyoutId: string) => boolean;
	/** Get the current push padding offsets from manager state. */
	export const usePushPaddingOffsets: () => import ("@elastic/eui/src/components/flyout/manager/types").PushPaddingOffsets;
	/** True if there's any active push padding (left or right side). */
	export const useHasPushPadding: () => boolean;
	/** Get the ref for the current flyout z-index to be used */
	export const useCurrentFlyoutZIndexRef: () => import("react").MutableRefObject<number>;

}
declare module '@elastic/eui/src/components/flyout/manager/context' {
	import React from 'react';
	/**
	 * React provider that marks descendants as being rendered inside
	 * an EUI managed flyout. Used by hooks/components to alter behavior
	 * (e.g., focus handling) when inside a managed flyout tree.
	 */
	export const EuiFlyoutIsManagedProvider: ({ isManaged, children, }: {
	    isManaged: boolean;
	    children: React.ReactNode;
	}) => React.JSX.Element;
	/**
	 * Hook that returns `true` when called within an EUI managed flyout subtree.
	 */
	export const useIsInManagedFlyout: () => boolean;

}
declare module '@elastic/eui/src/components/flyout/manager/hooks' {
	export { useIsFlyoutActive, useHasActiveSession, useCurrentSession, useCurrentMainFlyout, useCurrentChildFlyout, useFlyoutWidth, useFlyoutPagination, useParentFlyoutSize, useHasChildFlyout, usePushPaddingOffsets, useHasPushPadding, } from '@elastic/eui/src/components/flyout/manager/selectors';
	export { useFlyoutLayoutMode } from '@elastic/eui/src/components/flyout/manager/layout_mode';
	export { useIsInManagedFlyout } from '@elastic/eui/src/components/flyout/manager/context';
	export type { EuiFlyoutActivityStage } from '@elastic/eui/src/components/flyout/manager/types';
	/** Access the flyout manager context (state and actions). */
	export const useFlyoutManager: () => import ("@elastic/eui/src/components/flyout/manager/types").FlyoutManagerApi | null;
	/**
	 * Stable flyout ID utility. Uses the passed `id` if provided and not already registered,
	 * otherwise generates a deterministic ID for the component's lifetime.
	 * The ID remains stable across re-renders to maintain consistency in effects and other hooks.
	 */
	export const useFlyoutId: (flyoutId?: string) => string;

}
declare module '@elastic/eui/src/components/flyout/manager/layout_mode' {
	import { EuiFlyoutLayoutMode } from '@elastic/eui/src/components/flyout/manager/types';
	/**
	 * Hook to handle responsive layout mode for managed flyouts.
	 * Decides whether to place flyouts side-by-side or stacked based on
	 * the reference width (the reference container's width, defaulting to
	 * document.body when not set) and flyout widths/sizes.
	 */
	export const useApplyFlyoutLayoutMode: () => void;
	/**
	 * Convert a flyout `size` value to a pixel width.
	 * When `referenceWidth` is provided, named sizes are calculated as a percentage
	 * of that width (container-relative). Otherwise falls back to `window.innerWidth`.
	 */
	export const getWidthFromSize: (size: string | number, referenceWidth?: number) => number;
	/** Current layout mode for managed flyouts (`side-by-side` or `stacked`). */
	export const useFlyoutLayoutMode: () => EuiFlyoutLayoutMode;

}
declare module '@elastic/eui/src/components/flyout/manager/provider' {
	import React from 'react';
	import { FlyoutManagerApi } from '@elastic/eui/src/components/flyout/manager/types';
	/**
	 * React context that exposes the Flyout Manager API (state + actions).
	 */
	export const EuiFlyoutManagerContext: React.Context<FlyoutManagerApi | null>;
	/**
	 * Provides the Flyout Manager API via context and runs layout-mode logic.
	 */
	export const EuiFlyoutManager: React.FC<{
	    children: React.ReactNode;
	}>;
	/** Hook to access the Flyout Manager API from context. */
	export const useFlyoutManager: () => FlyoutManagerApi | null;

}
declare module '@elastic/eui/src/components/flyout/manager/activity_stage' {
	import type { EuiFlyoutActivityStage, EuiFlyoutLevel } from '@elastic/eui/src/components/flyout/manager/types';
	export interface UseFlyoutActivityStageParams {
	    flyoutId: string;
	    level: EuiFlyoutLevel;
	    /** When false, skip intermediate stages (CLOSING, RETURNING, BACKGROUNDING) and transition directly to final state. */
	    shouldAnimate?: boolean;
	}
	export interface UseFlyoutActivityStageReturn {
	    activityStage: EuiFlyoutActivityStage;
	    /**
	     * Pass to the flyout's `onAnimationEnd` prop to finalize transitional stages
	     * (e.g. CLOSING -> INACTIVE). When `shouldAnimate` is false, the intermediate
	     * CLOSING/RETURNING/BACKGROUNDING stages are skipped, but OPENING -> ACTIVE
	     * still relies on this handler since new flyouts always start in OPENING.
	     */
	    onAnimationEnd: () => void;
	}
	/**
	 * Encapsulates all activity-stage transitions and animation-driven updates
	 * for managed flyouts.
	 *
	 * Performance: reads `useFlyoutManager()` once and derives isActive,
	 * hasChild, and layoutMode inline (replaces useIsFlyoutActive,
	 * useHasChildFlyout, useFlyoutLayoutMode hooks).
	 */
	export const useFlyoutActivityStage: ({ flyoutId, level, shouldAnimate, }: UseFlyoutActivityStageParams) => {
	    activityStage: EuiFlyoutActivityStage;
	    onAnimationEnd: () => void;
	};

}
declare module '@elastic/eui/src/components/flyout/manager/flyout_managed.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { _EuiFlyoutSide } from '@elastic/eui/src/components/flyout/const';
	import type { EuiFlyoutActivityStage, EuiFlyoutLevel } from '@elastic/eui/src/components/flyout/manager/types';
	/**
	 * Emotion styles for managed flyouts.
	 * Provides base 3D context and animations tied to managed flyout stages
	 * via data attributes.
	 */
	export const euiManagedFlyoutStyles: (euiThemeContext: UseEuiTheme) => {
	    stage: (activeStage: EuiFlyoutActivityStage, side: _EuiFlyoutSide | undefined, level: EuiFlyoutLevel) => (false | import("@emotion/react").SerializedStyles)[];
	    managedFlyout: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/flyout/manager/validation' {
	import { EuiFlyoutSize } from '@elastic/eui/src/components/flyout/const';
	import { EuiFlyoutComponentProps } from '@elastic/eui/src/components/flyout/flyout.component';
	import { EuiFlyoutLevel } from '@elastic/eui/src/components/flyout/manager/types';
	type FlyoutValidationErrorType = 'INVALID_SIZE_TYPE' | 'INVALID_SIZE_COMBINATION' | 'INVALID_FLYOUT_MENU_TITLE';
	export interface FlyoutValidationError {
	    type: FlyoutValidationErrorType;
	    message: string;
	    flyoutId?: string;
	    parentFlyoutId?: string;
	    level?: EuiFlyoutLevel;
	    size?: string | number;
	    parentSize?: string | number;
	}
	/**
	 * Checks if a size is a named size (s, m, l)
	 */
	export function isNamedSize(size: unknown): size is EuiFlyoutSize;
	/**
	 * Validates that a managed flyout only uses named sizes
	 */
	export function validateManagedFlyoutSize(size: EuiFlyoutComponentProps['size'], flyoutId: string, level: EuiFlyoutLevel): FlyoutValidationError | null;
	/**
	 * Validates size combinations for parent-child flyouts
	 */
	export function validateSizeCombination(parentSize: EuiFlyoutSize, childSize: EuiFlyoutSize): FlyoutValidationError | null;
	/**
	 * Creates a user-friendly error message for validation errors
	 */
	export function createValidationErrorMessage(error: FlyoutValidationError): string;
	export {};

}
declare module '@elastic/eui/src/components/flyout/manager/flyout_managed' {
	import React from 'react';
	import { EuiFlyoutComponentProps } from '@elastic/eui/src/components/flyout/flyout.component';
	import { EuiFlyoutMenuProps } from '@elastic/eui/src/components/flyout/flyout_menu';
	import type { EuiFlyoutLevel } from '@elastic/eui/src/components/flyout/manager/types';
	/**
	 * Props for `EuiManagedFlyout`, the internal persistent flyout used by
	 * the manager. Extends base flyout props and requires a `level` to
	 * distinguish `main` vs `child` behavior.
	 */
	export interface EuiManagedFlyoutProps extends EuiFlyoutComponentProps {
	    level: EuiFlyoutLevel;
	    historyKey?: symbol;
	    flyoutMenuProps?: Omit<EuiFlyoutMenuProps, 'historyItems' | 'showBackButton'>;
	    onActive?: () => void;
	}
	/**
	 * Persistent managed flyout rendered inside the provider. Handles:
	 * - registration/unregistration with the manager
	 * - size validation and parent/child size compatibility
	 * - width tracking for responsive layouts
	 * - lifecycle stage transitions and data attributes for styling
	 */
	export const EuiManagedFlyout: React.ForwardRefExoticComponent<Omit<EuiManagedFlyoutProps, "ref"> & React.RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/flyout/manager/flyout_child' {
	import React from 'react';
	import { type EuiManagedFlyoutProps } from '@elastic/eui/src/components/flyout/manager/flyout_managed';
	/**
	 * Props for `EuiFlyoutChild`, a managed child flyout that pairs with a main flyout.
	 *
	 * Notes:
	 * - `type`, `side`, and `level` are fixed by the component and thus omitted.
	 */
	export type EuiFlyoutChildProps = Omit<EuiManagedFlyoutProps, 'closeButtonPosition' | 'hideCloseButton' | 'type' | 'level' | 'hasChildBackground'>;
	/**
	 * Managed child flyout that renders alongside or stacked over the main flyout,
	 * depending on the current layout mode. Handles required managed flyout props.
	 */
	export const EuiFlyoutChild: React.ForwardRefExoticComponent<Omit<EuiFlyoutChildProps, "ref"> & React.RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/flyout/manager/flyout_main.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Emotion styles for the main (parent) managed flyout.
	 * Adds subtle borders when a child flyout is present, depending on side.
	 *
	 * Returns an object with:
	 * - `hasChildFlyout.left` and `.right`: border styles to separate from child.
	 */
	export const euiMainFlyoutStyles: (euiThemeContext: UseEuiTheme) => {
	    hasChildFlyout: {
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flyout/hooks' {
	import { EuiFlyoutProps } from '@elastic/eui/src/components/flyout/flyout';
	/**
	 * Determines if a flyout should be rendered in a "pushed" state based on its
	 * configuration and the current window or container size.
	 */
	export const useIsPushed: (props: Pick<EuiFlyoutProps, "type" | "pushMinBreakpoint"> & {
	    containerWidth?: number;
	}) => boolean;

}
declare module '@elastic/eui/src/components/flyout/manager/flyout_main' {
	import React from 'react';
	import { type EuiManagedFlyoutProps } from '@elastic/eui/src/components/flyout/manager/flyout_managed';
	/**
	 * Props for `EuiFlyoutMain`, the primary managed flyout component.
	 * The `level` prop is fixed internally to `main` and is therefore omitted.
	 */
	export type EuiFlyoutMainProps = Omit<EuiManagedFlyoutProps, 'level'>;
	/**
	 * Managed main flyout. Handles ID management, child-flyout styling,
	 * and push/overlay behavior based on provided props.
	 */
	export const EuiFlyoutMain: React.ForwardRefExoticComponent<Omit<EuiFlyoutMainProps, "ref"> & React.RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/flyout/manager' {
	/**
	 * Convenience re-exports of bound action creators for external usage.
	 */
	export { addFlyout as addFlyoutAction, closeFlyout as closeFlyoutAction, closeAllFlyouts as closeAllFlyoutsAction, setActiveFlyout as setActiveFlyoutAction, setFlyoutWidth as setFlyoutWidthAction, setPagination as setPaginationAction, setPushPadding as setPushPaddingAction, setActivityStage as setActivityStageAction, } from '@elastic/eui/src/components/flyout/manager/actions';
	/** Reducer and default state for the flyout manager. */
	export { flyoutManagerReducer, initialState } from '@elastic/eui/src/components/flyout/manager/reducer';
	/** Flyout manager store singleton and types. */
	export { getFlyoutManagerStore, type FlyoutManagerStore, type FlyoutManagerEvent, } from '@elastic/eui/src/components/flyout/manager/store';
	export type { EuiFlyoutManagerState, FlyoutSession } from '@elastic/eui/src/components/flyout/manager/types';
	/** Provider component exposing the Flyout Manager API via context. */
	export { EuiFlyoutManager } from '@elastic/eui/src/components/flyout/manager/provider';
	/**
	 * Hooks for reading manager state and derived information.
	 */
	/**
	 * Selectors and derived state hooks for managed flyouts.
	 */
	export { useCurrentChildFlyout, useCurrentMainFlyout, useCurrentSession, useFlyoutId, useFlyoutLayoutMode, useFlyoutManager, useFlyoutPagination, useFlyoutWidth, useHasChildFlyout, useIsFlyoutActive, useIsInManagedFlyout, useHasActiveSession, useParentFlyoutSize, usePushPaddingOffsets, useHasPushPadding, } from '@elastic/eui/src/components/flyout/manager/hooks';
	export { EuiFlyoutChild, type EuiFlyoutChildProps } from '@elastic/eui/src/components/flyout/manager/flyout_child';
	export { EuiFlyoutMain, type EuiFlyoutMainProps } from '@elastic/eui/src/components/flyout/manager/flyout_main';
	/** Utility functions for flyout sizing and layout. */
	export { getWidthFromSize } from '@elastic/eui/src/components/flyout/manager/layout_mode';

}
declare module '@elastic/eui/src/components/overlay_mask/overlay_mask.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiOverlayMaskStyles: ({ euiTheme, highContrastMode, }: UseEuiTheme) => {
	    euiOverlayMask: string;
	    aboveHeader: string;
	    belowHeader: string;
	    noAnimation: string;
	};

}
declare module '@elastic/eui/src/components/overlay_mask/overlay_mask_body.styles' {
	export const euiOverlayMaskBodyStyles: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/overlay_mask/overlay_mask' {
	import { FunctionComponent, HTMLAttributes, MutableRefObject, ReactNode, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiOverlayMaskInterface {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Should the mask visually sit above or below the EuiHeader (controlled by z-index)
	     */
	    headerZindexLocation?: 'above' | 'below';
	    /**
	     * React ref to be passed to the wrapping container
	     */
	    maskRef?: Ref<HTMLDivElement> | MutableRefObject<HTMLDivElement>;
	    /**
	     * If enabled, the mask will have a fade in animation.
	     * @default true
	     */
	    hasAnimation?: boolean;
	}
	export type EuiOverlayMaskProps = Omit<CommonProps, 'css'> & Omit<Partial<Record<keyof HTMLAttributes<HTMLDivElement>, string>>, keyof EuiOverlayMaskInterface> & EuiOverlayMaskInterface;
	export const EuiOverlayMask: FunctionComponent<EuiOverlayMaskProps>;

}
declare module '@elastic/eui/src/components/overlay_mask' {
	export type { EuiOverlayMaskProps } from '@elastic/eui/src/components/overlay_mask/overlay_mask';
	export { EuiOverlayMask } from '@elastic/eui/src/components/overlay_mask/overlay_mask';

}
declare module '@elastic/eui/src/components/flyout/_flyout_overlay' {
	import React, { PropsWithChildren } from 'react';
	import type { EuiFlyoutComponentProps } from '@elastic/eui/src/components/flyout/flyout.component';
	export interface EuiFlyoutOverlayProps extends PropsWithChildren {
	    hasOverlayMask: boolean;
	    maskProps: EuiFlyoutComponentProps['maskProps'];
	    isPushed: boolean;
	    maskZIndex: number;
	    /**
	     * Use 'above' to stack the flyout and mask above fixed headers (mask-level
	     * z-index); 'below' to keep them in the flyout stacking level.
	     */
	    headerZindexLocation?: 'above' | 'below';
	    /**
	     * When provided, clips the overlay mask to the container's bounding rect
	     * rather than covering the full viewport.
	     */
	    containerRect?: DOMRect | null;
	}
	/**
	 * Light wrapper for conditionally rendering portals or overlay masks:
	 *  - If ownFocus is set, wrap with an overlay and allow the user to click it to close it.
	 *  - Otherwise still wrap within an EuiPortal so it appends to the bottom of the window.
	 * Push flyouts have no overlay OR portal behavior.
	 *
	 * @internal
	 */
	export const EuiFlyoutOverlay: ({ children, isPushed, maskProps, hasOverlayMask, maskZIndex, headerZindexLocation, containerRect, }: EuiFlyoutOverlayProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/resizable_container/types' {
	import { KeyboardEvent, MouseEvent, TouchEvent } from 'react';
	export type PanelModeType = 'collapsible' | 'main' | 'custom';
	export type PanelPosition = 'first' | 'middle' | 'last';
	export type PanelDirection = 'left' | 'right';
	export type KeyMoveDirection = 'forward' | 'backward';
	export type ResizeTrigger = 'pointer' | 'key';
	export interface EuiResizablePanelController {
	    id: string;
	    size: number;
	    getSizePx: () => number;
	    minSize: string[];
	    mode?: PanelModeType;
	    isCollapsed: boolean;
	    prevSize: number;
	    position: PanelPosition;
	}
	export interface EuiResizableButtonController {
	    id: string;
	    ref: HTMLElement;
	    isDisabled: boolean;
	    isFocused: boolean;
	}
	export interface EuiResizableContainerRegistry {
	    panels: {
	        [key: string]: EuiResizablePanelController;
	    };
	    resizers: {
	        [key: string]: EuiResizableButtonController;
	    };
	}
	export type EuiResizableButtonMouseEvent = MouseEvent<HTMLButtonElement> | TouchEvent<HTMLButtonElement>;
	export type EuiResizableButtonKeyEvent = KeyboardEvent<HTMLButtonElement>;
	export interface EuiResizableContainerState {
	    isDragging: boolean;
	    currentResizerPos: number;
	    prevPanelId: string | null;
	    nextPanelId: string | null;
	    containerSize: number;
	    isHorizontal?: boolean;
	    panels: EuiResizableContainerRegistry['panels'];
	    resizers: EuiResizableContainerRegistry['resizers'];
	}
	export interface ActionToggleOptions {
	    direction: PanelDirection;
	}
	interface ActionReset {
	    type: 'EUI_RESIZABLE_RESET';
	}
	interface ActionInit {
	    type: 'EUI_RESIZABLE_CONTAINER_INIT';
	    payload: {
	        isHorizontal: boolean;
	    };
	}
	export interface ActionDragStart {
	    type: 'EUI_RESIZABLE_DRAG_START';
	    payload: {
	        prevPanelId: string;
	        nextPanelId: string;
	        position: number;
	    };
	}
	export interface ActionDragMove {
	    type: 'EUI_RESIZABLE_DRAG_MOVE';
	    payload: {
	        prevPanelId: string;
	        nextPanelId: string;
	        position: number;
	    };
	}
	export interface ActionKeyMove {
	    type: 'EUI_RESIZABLE_KEY_MOVE';
	    payload: {
	        prevPanelId: string;
	        nextPanelId: string;
	        direction: KeyMoveDirection;
	    };
	}
	export interface ActionResize {
	    type: 'EUI_RESIZABLE_RESIZE';
	    payload: {};
	}
	export interface ActionToggle {
	    type: 'EUI_RESIZABLE_TOGGLE';
	    payload: {
	        panelId: string;
	        options: ActionToggleOptions;
	    };
	}
	interface ActionRegisterPanel {
	    type: 'EUI_RESIZABLE_PANEL_REGISTER';
	    payload: {
	        panel: EuiResizablePanelController;
	    };
	}
	interface ActionDeregisterPanel {
	    type: 'EUI_RESIZABLE_PANEL_DEREGISTER';
	    payload: {
	        panelId: EuiResizablePanelController['id'];
	    };
	}
	interface ActionRegisterResizer {
	    type: 'EUI_RESIZABLE_BUTTON_REGISTER';
	    payload: {
	        resizer: EuiResizableButtonController;
	    };
	}
	interface ActionDeregisterResizer {
	    type: 'EUI_RESIZABLE_BUTTON_DEREGISTER';
	    payload: {
	        resizerId: EuiResizableButtonController['id'];
	    };
	}
	export interface ActionFocus {
	    type: 'EUI_RESIZABLE_BUTTON_FOCUS';
	    payload: {
	        resizerId: EuiResizableButtonController['id'];
	    };
	}
	interface ActionBlur {
	    type: 'EUI_RESIZABLE_BUTTON_BLUR';
	}
	interface ActionOnChange {
	    type: 'EUI_RESIZABLE_ONCHANGE';
	}
	export type EuiResizableContainerAction = ActionReset | ActionInit | ActionRegisterPanel | ActionDeregisterPanel | ActionRegisterResizer | ActionDeregisterResizer | ActionDragStart | ActionDragMove | ActionKeyMove | ActionResize | ActionToggle | ActionFocus | ActionBlur | ActionOnChange;
	export interface EuiResizableContainerActions {
	    reset: () => void;
	    initContainer: (isHorizontal: boolean) => void;
	    registerPanel: (panel: EuiResizablePanelController) => void;
	    deregisterPanel: (panelId: EuiResizablePanelController['id']) => void;
	    registerResizer: (resizer: EuiResizableButtonController) => void;
	    deregisterResizer: (resizerId: EuiResizableButtonController['id']) => void;
	    dragStart: ({ prevPanelId, nextPanelId, position, }: ActionDragStart['payload']) => void;
	    dragMove: ({ prevPanelId, nextPanelId, position, }: ActionDragMove['payload']) => void;
	    keyMove: ({ prevPanelId, nextPanelId, direction, }: ActionKeyMove['payload']) => void;
	    resizerFocus: (resizerId: ActionFocus['payload']['resizerId']) => void;
	    resizerBlur: () => void;
	    togglePanel: (panelId: ActionToggle['payload']['panelId'], options: ActionToggle['payload']['options']) => void;
	}
	export {};

}
declare module '@elastic/eui/src/components/resizable_container/context' {
	import React from 'react';
	import { EuiResizableContainerRegistry } from '@elastic/eui/src/components/resizable_container/types';
	interface ContainerContextProps {
	    registry?: EuiResizableContainerRegistry;
	}
	interface ContextProviderProps extends Required<ContainerContextProps> {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: any;
	}
	export function EuiResizableContainerContextProvider({ children, registry, }: ContextProviderProps): React.JSX.Element;
	export const useEuiResizableContainerContext: () => ContainerContextProps;
	export {};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiResizableButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiResizableButton: import("@emotion/react").SerializedStyles;
	    horizontal: import("@emotion/react").SerializedStyles;
	    vertical: import("@emotion/react").SerializedStyles;
	    accountForScrollbars: {
	        horizontal: {
	            both: import("@emotion/react").SerializedStyles;
	            before: import("@emotion/react").SerializedStyles;
	            after: import("@emotion/react").SerializedStyles;
	            none: import("@emotion/react").SerializedStyles;
	        };
	        vertical: {
	            both: import("@emotion/react").SerializedStyles;
	            before: import("@emotion/react").SerializedStyles;
	            after: import("@emotion/react").SerializedStyles;
	            none: import("@emotion/react").SerializedStyles;
	        };
	    };
	    border: import("@emotion/react").SerializedStyles;
	    borderDirection: {
	        horizontal: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	    };
	    handle: import("@emotion/react").SerializedStyles;
	    handleDirection: {
	        horizontal: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	    };
	    alignIndicator: {
	        center: import("@emotion/react").SerializedStyles;
	        start: import("@emotion/react").SerializedStyles;
	        end: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_button' {
	import React, { FunctionComponent, ButtonHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiResizableButtonController, EuiResizableButtonMouseEvent, EuiResizableButtonKeyEvent } from '@elastic/eui/src/components/resizable_container/types';
	export type EuiResizableButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & CommonProps & {
	    /**
	     * Defaults to displaying a resizer for vertical (y-axis) resizing.
	     * Set to `true` to display a resizer for horizontal (x-axis) resizing.
	     */
	    isHorizontal?: boolean;
	    /**
	     * By default, EuiResizableButton will show a grab handle to indicate resizability.
	     * This indicator can be optionally hidden to show a plain border instead.
	     */
	    indicator?: 'handle' | 'border';
	    /**
	     * Allows customizing the alignment of grab `handle` indicators (does nothing for
	     * border indicators). Defaults to `center`, but consider using `start` for extremely
	     * tall content that scrolls off-screen
	     */
	    alignIndicator?: 'center' | 'start' | 'end';
	    /**
	     * By default, EuiResizableButton will overlap into the panels before/after it.
	     * This can occasionally occlude interactive elements like scrollbars. To prevent
	     * this overlap, use this prop to remove the overlap for the specified side.
	     */
	    accountForScrollbars?: 'before' | 'after' | 'both';
	    /**
	     * When disabled, the resizer button will be completely hidden
	     */
	    disabled?: boolean;
	};
	/**
	 * A generic button for indicating/facilitating resizable content,
	 * usable outside of the EuiResizableContainer context
	 */
	export const EuiResizableButton: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & CommonProps & {
	    /**
	     * Defaults to displaying a resizer for vertical (y-axis) resizing.
	     * Set to `true` to display a resizer for horizontal (x-axis) resizing.
	     */
	    isHorizontal?: boolean;
	    /**
	     * By default, EuiResizableButton will show a grab handle to indicate resizability.
	     * This indicator can be optionally hidden to show a plain border instead.
	     */
	    indicator?: "handle" | "border";
	    /**
	     * Allows customizing the alignment of grab `handle` indicators (does nothing for
	     * border indicators). Defaults to `center`, but consider using `start` for extremely
	     * tall content that scrolls off-screen
	     */
	    alignIndicator?: "center" | "start" | "end";
	    /**
	     * By default, EuiResizableButton will overlap into the panels before/after it.
	     * This can occasionally occlude interactive elements like scrollbars. To prevent
	     * this overlap, use this prop to remove the overlap for the specified side.
	     */
	    accountForScrollbars?: "before" | "after" | "both";
	    /**
	     * When disabled, the resizer button will be completely hidden
	     */
	    disabled?: boolean;
	} & React.RefAttributes<HTMLButtonElement>>;
	/**
	 * Resizer button specific to controlled EuiResizableContainer usage
	 */
	export type EuiResizableButtonControls = Omit<EuiResizableButtonProps, 'onFocus'> & {
	    registration: {
	        register: (resizer: EuiResizableButtonController) => void;
	        deregister: (resizerId: EuiResizableButtonController['id']) => void;
	    };
	    onKeyDown: (e: EuiResizableButtonKeyEvent) => void;
	    onKeyUp: (e: EuiResizableButtonKeyEvent) => void;
	    onMouseDown: (e: EuiResizableButtonMouseEvent) => void;
	    onTouchStart: (e: EuiResizableButtonMouseEvent) => void;
	    onBlur: () => void;
	    onFocus: (id: string) => void;
	};
	export const EuiResizableButtonControlled: FunctionComponent<Partial<EuiResizableButtonControls>>;
	export const euiResizableButtonWithControls: (controls: EuiResizableButtonControls) => (props: CommonProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/accessibility/screen_reader_only/screen_reader_only.styles' {
	export const euiScreenReaderOnly: () => string;
	export const euiScreenReaderOnlyStyles: {
	    euiScreenReaderOnly: import("@emotion/react").SerializedStyles;
	    'euiScreenReaderOnly-showOnFocus': import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_collapse_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiResizableCollapseButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiResizableCollapseButton: import("@emotion/react").SerializedStyles;
	    collapsible: {
	        collapsible: import("@emotion/react").SerializedStyles;
	        horizontal: {
	            after: import("@emotion/react").SerializedStyles;
	            before: import("@emotion/react").SerializedStyles;
	            middle: import("@emotion/react").SerializedStyles;
	            top: import("@emotion/react").SerializedStyles;
	            bottom: import("@emotion/react").SerializedStyles;
	            readonly left: import("@emotion/react").SerializedStyles;
	            readonly right: import("@emotion/react").SerializedStyles;
	        };
	        vertical: {
	            after: import("@emotion/react").SerializedStyles;
	            before: import("@emotion/react").SerializedStyles;
	            middle: import("@emotion/react").SerializedStyles;
	            left: import("@emotion/react").SerializedStyles;
	            right: import("@emotion/react").SerializedStyles;
	            readonly top: import("@emotion/react").SerializedStyles;
	            readonly bottom: import("@emotion/react").SerializedStyles;
	        };
	    };
	    collapsed: {
	        collapsed: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontalPositions: {
	            top: import("@emotion/react").SerializedStyles;
	            bottom: import("@emotion/react").SerializedStyles;
	            middle: import("@emotion/react").SerializedStyles;
	            left: import("@emotion/react").SerializedStyles;
	            right: import("@emotion/react").SerializedStyles;
	        };
	        verticalPositions: {
	            left: import("@emotion/react").SerializedStyles;
	            right: import("@emotion/react").SerializedStyles;
	            middle: import("@emotion/react").SerializedStyles;
	            top: import("@emotion/react").SerializedStyles;
	            bottom: import("@emotion/react").SerializedStyles;
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_collapse_button' {
	import { FunctionComponent } from 'react';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	import { ToggleOptions } from '@elastic/eui/src/components/resizable_container/resizable_panel';
	import { EuiResizableContainerProps } from '@elastic/eui/src/components/resizable_container/resizable_container';
	export type EuiResizableCollapseButtonProps = Omit<EuiButtonIconPropsForButton, 'iconType'> & {
	    /**
	     * Position of the toggle button.
	     * Enums based on the `direction` of the EuiResizableContainer
	     */
	    internalPosition?: ToggleOptions['position'];
	    /**
	     * Position of the toggle button.
	     * Enums based on the `direction` of the EuiResizableContainer
	     */
	    externalPosition?: 'before' | 'after';
	    /**
	     * Same direction derived from EuiResizableContainer
	     */
	    direction?: EuiResizableContainerProps['direction'];
	    isVisible?: boolean;
	    isCollapsed?: boolean;
	};
	export const EuiResizableCollapseButton: FunctionComponent<EuiResizableCollapseButtonProps>;

}
declare module '@elastic/eui/src/components/resizable_container/resizable_panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiResizablePanelStyles: {
	    euiResizablePanel: import("@emotion/react").SerializedStyles;
	    collapsed: import("@emotion/react").SerializedStyles;
	};
	export const euiResizablePanelContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiResizablePanel__content: import("@emotion/react").SerializedStyles;
	    scrollable: import("@emotion/react").SerializedStyles;
	    collapsedChildren: import("@emotion/react").SerializedStyles;
	    horizontal: {
	        collapsed: import("@emotion/react").SerializedStyles;
	        hasCollapsibleButton: import("@emotion/react").SerializedStyles;
	    };
	    vertical: {
	        collapsed: import("@emotion/react").SerializedStyles;
	        hasCollapsibleButton: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_panel' {
	import React, { CSSProperties, ReactNode, FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { PanelPaddingSize, _EuiPanelProps } from '@elastic/eui/src/components/panel/panel';
	import { EuiResizablePanelController, ActionToggleOptions, PanelModeType } from '@elastic/eui/src/components/resizable_container/types';
	export interface ToggleOptions {
	    'data-test-subj'?: string;
	    className?: string;
	    /**
	     * Position of the toggle button.
	     * Enums based on the `direction` of the EuiResizableContainer
	     */
	    position?: 'top' | 'middle' | 'bottom' | 'left' | 'right';
	}
	export type ModeOptions = PanelModeType | [PanelModeType, Partial<ToggleOptions>];
	export type ToggleCollapseCallback = (panelId: EuiResizablePanelController['id'], options: ActionToggleOptions) => void;
	export const getModeType: (mode?: ModeOptions) => PanelModeType | undefined;
	export const getToggleOptions: (mode?: ModeOptions) => {
	    'data-test-subj': string;
	    className: string | null;
	    position: string;
	};
	export interface EuiResizablePanelControls {
	    isHorizontal: boolean;
	    registration: {
	        register: (panel: EuiResizablePanelController) => void;
	        deregister: (panelId: EuiResizablePanelController['id']) => void;
	    };
	    /**
	     * See {@link ToggleCollapseCallback}
	     */
	    onToggleCollapsed?: ToggleCollapseCallback;
	    onToggleCollapsedInternal: ToggleCollapseCallback;
	}
	export interface EuiResizablePanelProps extends _EuiPanelProps, CommonProps, Partial<EuiResizablePanelControls> {
	    /**
	     * Specify a desired minimum panel size in pixels or percents,
	     * for example "300px" or "30%"
	     * The actual minimum size will be calculated,
	     * using the larger of this prop and the panelProps.paddingSize
	     */
	    minSize?: string;
	    /**
	     * Specify id of panel if you want to track panel size in "onPanelWidthChange" callback
	     */
	    id?: string;
	    /**
	     * Initial size of the panel in percents
	     * Specify this prop if you don't need to handle the panel size from outside
	     */
	    initialSize?: number;
	    /**
	     * Size of the panel in percents.
	     * Specify this prop if you want to control the size from outside, the panel will ignore the "initialSize"
	     */
	    size?: number;
	    /**
	     * Add Eui scroll and overflow for the panel
	     */
	    scrollable?: boolean;
	    mode?: ModeOptions;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * Custom CSS properties applied to the wrapping `.euiResizablePanel` div
	     */
	    style?: CSSProperties;
	    /**
	     * tabIndex={0} provides full keyboard access when content overflows `<EuiResizablePanel />`
	     */
	    tabIndex?: number;
	    /**
	     * Props to add to the wrapping `.euiResizablePanel` div
	     */
	    wrapperProps?: CommonProps & HTMLAttributes<HTMLDivElement>;
	    /**
	     * Padding to add directly to the wrapping `.euiResizablePanel` div
	     * Gives space around the actual panel.
	     */
	    wrapperPadding?: PanelPaddingSize;
	}
	export const EuiResizablePanel: FunctionComponent<EuiResizablePanelProps>;
	export function euiResizablePanelWithControls(controls: EuiResizablePanelControls): (props: EuiResizablePanelProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/resizable_container/helpers' {
	import { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
	import { EuiResizableContainerRegistry, EuiResizableContainerState, EuiResizableContainerActions } from '@elastic/eui/src/components/resizable_container/types';
	interface Params {
	    initialState: EuiResizableContainerState;
	    containerRef: React.RefObject<HTMLDivElement>;
	    onPanelWidthChange?: ({}: {
	        [key: string]: number;
	    }) => any;
	}
	export const isTouchEvent: (event: MouseEvent | ReactMouseEvent | TouchEvent | ReactTouchEvent) => event is TouchEvent | ReactTouchEvent;
	export const pxToPercent: (proportion: number, whole: number) => number;
	export const sizesOnly: (panelObject: EuiResizableContainerRegistry["panels"]) => {
	    [key: string]: number;
	};
	export const getPanelMinSize: (panelMinSize: string[], containerSize: number) => number;
	export const getPosition: (event: ReactMouseEvent | MouseEvent | ReactTouchEvent | TouchEvent, isHorizontal: boolean) => number;
	export const useContainerCallbacks: ({ initialState, containerRef, onPanelWidthChange, }: Params) => [EuiResizableContainerActions, EuiResizableContainerState];
	export {};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_container.styles' {
	export const euiResizableContainerStyles: {
	    euiResizableContainer: import("@emotion/react").SerializedStyles;
	    horizontal: import("@emotion/react").SerializedStyles;
	    vertical: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/resizable_container/resizable_container' {
	import { ReactNode, CSSProperties, FunctionComponent, HTMLAttributes, ComponentType } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiResizableButtonProps } from '@elastic/eui/src/components/resizable_container/resizable_button';
	import { EuiResizablePanelProps, ToggleCollapseCallback } from '@elastic/eui/src/components/resizable_container/resizable_panel';
	import { EuiResizableContainerActions, ResizeTrigger } from '@elastic/eui/src/components/resizable_container/types';
	export interface EuiResizableContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, CommonProps {
	    /**
	     * Specify the container direction
	     */
	    direction?: 'vertical' | 'horizontal';
	    /**
	     * Pure function which accepts Panel and Resizer components in arguments
	     * and returns a component tree
	     */
	    children: (Panel: ComponentType<EuiResizablePanelProps>, Resizer: ComponentType<EuiResizableButtonProps>, actions: Partial<EuiResizableContainerActions>) => ReactNode;
	    /**
	     * Pure function which accepts an object where keys are IDs of panels, which sizes were changed,
	     * and values are actual sizes in percents
	     */
	    onPanelWidthChange?: ({}: {
	        [key: string]: number;
	    }) => void;
	    onToggleCollapsed?: ToggleCollapseCallback;
	    /**
	     * Called when resizing starts
	     */
	    onResizeStart?: (trigger: ResizeTrigger) => void;
	    /**
	     * Called when resizing ends
	     */
	    onResizeEnd?: () => void;
	    style?: CSSProperties;
	}
	export const EuiResizableContainer: FunctionComponent<EuiResizableContainerProps>;

}
declare module '@elastic/eui/src/components/resizable_container' {
	export type { EuiResizableContainerProps } from '@elastic/eui/src/components/resizable_container/resizable_container';
	export { EuiResizableContainer } from '@elastic/eui/src/components/resizable_container/resizable_container';
	export type { EuiResizableButtonProps } from '@elastic/eui/src/components/resizable_container/resizable_button';
	export { EuiResizableButton } from '@elastic/eui/src/components/resizable_container/resizable_button';

}
declare module '@elastic/eui/src/components/flyout/_flyout_resize_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutResizeButtonStyles: ({ euiTheme }: UseEuiTheme) => {
	    root: import("@emotion/react").SerializedStyles;
	    overlay: {
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    push: {
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    noOverlay: {
	        root: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/flyout/_flyout_resize_button' {
	import React from 'react';
	import { EuiResizableButtonProps } from '@elastic/eui/src/components/resizable_container';
	import type { _EuiFlyoutType, _EuiFlyoutSide } from '@elastic/eui/src/components/flyout/const';
	import type { EuiFlyoutComponentProps } from '@elastic/eui/src/components/flyout/flyout.component';
	type EuiFlyoutResizeButtonProps = Pick<EuiResizableButtonProps, 'onMouseDown' | 'onKeyDown' | 'onTouchStart'> & {
	    type: _EuiFlyoutType;
	    side: _EuiFlyoutSide;
	    ownFocus: EuiFlyoutComponentProps['ownFocus'];
	    isPushed: boolean;
	};
	export const EuiFlyoutResizeButton: ({ type, side, ownFocus, isPushed, ...resizableButtonProps }: EuiFlyoutResizeButtonProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/flyout/flyout_resizable' {
	import React from 'react';
	import { EuiFlyoutProps } from '@elastic/eui/src/components/flyout/flyout';
	export type EuiFlyoutResizableProps = {
	    maxWidth?: number;
	} & Omit<EuiFlyoutProps, 'maxWidth' | 'resizable'>;
	export const EuiFlyoutResizable: React.ForwardRefExoticComponent<Omit<EuiFlyoutResizableProps, "ref"> & React.RefAttributes<HTMLElement | HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/flyout/use_flyout_resizable' {
	import React from 'react';
	import type { EuiFlyoutResizableProps } from '@elastic/eui/src/components/flyout/flyout_resizable';
	type UseEuiFlyoutResizable = Pick<EuiFlyoutResizableProps, 'onResize' | 'side'> & {
	    enabled: boolean;
	    minWidth?: number;
	    maxWidth: number | undefined;
	    siblingFlyoutWidth?: number | null;
	    referenceWidth?: number;
	    size: string | number;
	};
	/**
	 * @internal
	 */
	export const useEuiFlyoutResizable: ({ enabled, minWidth, maxWidth, siblingFlyoutWidth, referenceWidth, onResize, side, size: _size, }: UseEuiFlyoutResizable) => {
	    onKeyDown: (e: React.KeyboardEvent) => void;
	    onMouseDown: (e: React.MouseEvent | React.TouchEvent) => void;
	    setFlyoutRef: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
	    size: string | number;
	};
	export {};

}
declare module '@elastic/eui/src/components/flyout/use_flyout_z_index' {
	/**
	 * @internal
	 */
	export interface UseEuiFlyoutZIndex {
	    /** Use 'above' to stack the flyout above fixed headers (mask-level z-index); 'below' otherwise. */
	    headerZindexLocation?: 'above' | 'below';
	    isPushed: boolean;
	    managedFlyoutIndex: number;
	    isChildFlyout: boolean;
	}
	/**
	 * @internal
	 */
	export const useEuiFlyoutZIndex: ({ headerZindexLocation, isPushed, managedFlyoutIndex, isChildFlyout, }: UseEuiFlyoutZIndex) => {
	    flyoutZIndex: number;
	    maskZIndex: number;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout_parent_context' {
	import React from 'react';
	/**
	 * Provider that wraps a flyout's children to indicate they're inside a parent flyout.
	 * Nested flyouts can use this to automatically default to session inheritance.
	 */
	export const EuiFlyoutParentProvider: ({ children, }: {
	    children: React.ReactNode;
	}) => React.JSX.Element;
	/**
	 * Hook that returns `true` when called within a parent flyout's children.
	 * Used to automatically determine if a nested flyout should inherit the session.
	 */
	export const useIsInsideParentFlyout: () => boolean;

}
declare module '@elastic/eui/src/components/flyout/use_flyout_menu' {
	import { EuiFlyoutMenuDisplayMode } from '@elastic/eui/src/components/flyout/const';
	import { EuiFlyoutMenuProps } from '@elastic/eui/src/components/flyout/flyout_menu';
	/**
	 * @internal
	 */
	export interface UseEuiFlyoutMenu {
	    flyoutMenuProps?: EuiFlyoutMenuProps;
	    flyoutMenuDisplayMode: EuiFlyoutMenuDisplayMode;
	    ariaLabelledBy?: string;
	}
	/**
	 * Hook to manage flyout menu state and rendering logic.
	 * Determines whether the menu should be rendered based on display mode
	 * and menu content, and computes the appropriate aria-labelledby value.
	 *
	 * @internal
	 */
	export const useEuiFlyoutMenu: ({ flyoutMenuProps: _flyoutMenuProps, flyoutMenuDisplayMode, ariaLabelledBy: _ariaLabelledBy, }: UseEuiFlyoutMenu) => {
	    flyoutMenuId: string | undefined;
	    flyoutMenuProps: {
	        className?: string;
	        "aria-label"?: string;
	        'data-test-subj'?: string;
	        css?: import("@emotion/serialize").Interpolation<import("@emotion/react").Theme>;
	        defaultChecked?: boolean | undefined;
	        defaultValue?: string | number | readonly string[] | undefined;
	        suppressContentEditableWarning?: boolean | undefined;
	        suppressHydrationWarning?: boolean | undefined;
	        accessKey?: string | undefined;
	        autoFocus?: boolean | undefined;
	        contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
	        contextMenu?: string | undefined;
	        dir?: string | undefined;
	        draggable?: (boolean | "false" | "true") | undefined;
	        hidden?: boolean | undefined;
	        id?: string | undefined;
	        lang?: string | undefined;
	        nonce?: string | undefined;
	        slot?: string | undefined;
	        spellCheck?: (boolean | "false" | "true") | undefined;
	        style?: import("react").CSSProperties | undefined;
	        tabIndex?: number | undefined;
	        title?: string | (string & import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) | (string & Iterable<import("react").ReactNode>) | (string & import("react").ReactPortal) | undefined;
	        translate?: "yes" | "no" | undefined;
	        radioGroup?: string | undefined;
	        role?: import("react").AriaRole | undefined;
	        about?: string | undefined;
	        content?: string | undefined;
	        datatype?: string | undefined;
	        inlist?: any;
	        prefix?: string | undefined;
	        property?: string | undefined;
	        rel?: string | undefined;
	        resource?: string | undefined;
	        rev?: string | undefined;
	        typeof?: string | undefined;
	        vocab?: string | undefined;
	        autoCapitalize?: string | undefined;
	        autoCorrect?: string | undefined;
	        autoSave?: string | undefined;
	        color?: string | undefined;
	        itemProp?: string | undefined;
	        itemScope?: boolean | undefined;
	        itemType?: string | undefined;
	        itemID?: string | undefined;
	        itemRef?: string | undefined;
	        results?: number | undefined;
	        security?: string | undefined;
	        unselectable?: "on" | "off" | undefined;
	        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
	        is?: string | undefined;
	        "aria-activedescendant"?: string | undefined;
	        "aria-atomic"?: (boolean | "false" | "true") | undefined;
	        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
	        "aria-braillelabel"?: string | undefined;
	        "aria-brailleroledescription"?: string | undefined;
	        "aria-busy"?: (boolean | "false" | "true") | undefined;
	        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
	        "aria-colcount"?: number | undefined;
	        "aria-colindex"?: number | undefined;
	        "aria-colindextext"?: string | undefined;
	        "aria-colspan"?: number | undefined;
	        "aria-controls"?: string | undefined;
	        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
	        "aria-describedby"?: string | undefined;
	        "aria-description"?: string | undefined;
	        "aria-details"?: string | undefined;
	        "aria-disabled"?: (boolean | "false" | "true") | undefined;
	        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
	        "aria-errormessage"?: string | undefined;
	        "aria-expanded"?: (boolean | "false" | "true") | undefined;
	        "aria-flowto"?: string | undefined;
	        "aria-grabbed"?: (boolean | "false" | "true") | undefined;
	        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
	        "aria-hidden"?: (boolean | "false" | "true") | undefined;
	        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
	        "aria-keyshortcuts"?: string | undefined;
	        "aria-labelledby"?: string | undefined;
	        "aria-level"?: number | undefined;
	        "aria-live"?: "off" | "assertive" | "polite" | undefined;
	        "aria-modal"?: (boolean | "false" | "true") | undefined;
	        "aria-multiline"?: (boolean | "false" | "true") | undefined;
	        "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
	        "aria-orientation"?: "horizontal" | "vertical" | undefined;
	        "aria-owns"?: string | undefined;
	        "aria-placeholder"?: string | undefined;
	        "aria-posinset"?: number | undefined;
	        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
	        "aria-readonly"?: (boolean | "false" | "true") | undefined;
	        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
	        "aria-required"?: (boolean | "false" | "true") | undefined;
	        "aria-roledescription"?: string | undefined;
	        "aria-rowcount"?: number | undefined;
	        "aria-rowindex"?: number | undefined;
	        "aria-rowindextext"?: string | undefined;
	        "aria-rowspan"?: number | undefined;
	        "aria-selected"?: (boolean | "false" | "true") | undefined;
	        "aria-setsize"?: number | undefined;
	        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
	        "aria-valuemax"?: number | undefined;
	        "aria-valuemin"?: number | undefined;
	        "aria-valuenow"?: number | undefined;
	        "aria-valuetext"?: string | undefined;
	        children?: import("react").ReactNode | undefined;
	        dangerouslySetInnerHTML?: {
	            __html: string | TrustedHTML;
	        } | undefined;
	        onCopy?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCut?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onPaste?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
	        onFocus?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
	        onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
	        onBlur?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
	        onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
	        onChange?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onChangeCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onBeforeInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onReset?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onResetCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onSubmit?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onInvalid?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
	        onLoad?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onError?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
	        onAbort?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onDurationChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEmptied?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEncrypted?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEnded?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedData?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadStart?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPause?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPlaying?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onProgress?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onRateChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onResize?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSeeked?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSeeking?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onStalled?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSuspend?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onWaiting?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onAuxClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onContextMenu?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onDrag?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnd?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnter?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragExit?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragLeave?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragOver?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragStart?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDrop?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onDropCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
	        onMouseDown?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseMove?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOut?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOver?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseUp?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
	        onSelect?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
	        onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchMove?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchStart?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
	        onPointerDown?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerMove?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerUp?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOver?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOut?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
	        onScroll?: import("react").UIEventHandler<HTMLDivElement> | undefined;
	        onScrollCapture?: import("react").UIEventHandler<HTMLDivElement> | undefined;
	        onWheel?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
	        onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
	        onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
	        onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
	        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
	        iconType?: import("..").IconType;
	        hideTitle?: boolean;
	        hideCloseButton?: boolean;
	        showBackButton?: boolean;
	        backButtonProps?: {
	            onClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
	            "aria-label"?: string | undefined;
	            'data-test-subj'?: string | undefined;
	        };
	        historyItems?: import ("@elastic/eui/src/components/flyout/flyout_menu").EuiFlyoutHistoryItem[];
	        customActions?: import ("@elastic/eui/src/components/flyout/flyout_menu").EuiFlyoutMenuCustomAction[];
	        pagination?: import ("@elastic/eui/src/components/flyout/flyout_menu").EuiFlyoutMenuPagination;
	    };
	    shouldRenderMenu: boolean;
	    ariaLabelledBy: string | undefined;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout.component' {
	import { ComponentPropsWithRef, CSSProperties, ElementType, JSX } from 'react';
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	import { CommonProps, PropsOfElement } from '@elastic/eui/src/components/common';
	import { EuiFocusTrapProps } from '@elastic/eui/src/components/focus_trap';
	import type { EuiOverlayMaskProps } from '@elastic/eui/src/components/overlay_mask';
	import type { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	import { _EuiFlyoutPaddingSize, _EuiFlyoutSide, _EuiFlyoutType, EuiFlyoutMenuDisplayMode, EuiFlyoutSize } from '@elastic/eui/src/components/flyout/const';
	import { EuiFlyoutMenuProps } from '@elastic/eui/src/components/flyout/flyout_menu';
	import type { EuiFlyoutCloseEvent, EuiFlyoutCloseMeta } from '@elastic/eui/src/components/flyout/types';
	interface _EuiFlyoutComponentProps {
	    /**
	     * A required callback function fired when the flyout is closed.
	     *
	     * The optional second `meta` argument describes why the flyout closed via
	     * `meta.reason` (e.g. `'close-button'`, `'escape'`, `'outside-click'`, and,
	     * for managed flyouts, `'navigation-back'` or `'navigation-cascade'`).
	     */
	    onClose: (event: EuiFlyoutCloseEvent, meta?: EuiFlyoutCloseMeta) => void;
	    /**
	     * Defines the width of the panel.
	     * Pass a predefined size of `s | m | l`, or pass any number/string compatible with the CSS `width` attribute
	     * @default m
	     */
	    size?: EuiFlyoutSize | CSSProperties['width'];
	    /**
	     * Sets the minimum width of the panel.
	     * Especially useful when set with `resizable = true`.
	     */
	    minWidth?: number;
	    /**
	     * Sets the max-width of the panel,
	     * set to `true` to use the default size,
	     * set to `false` to not restrict the width,
	     * set to a number for a custom width in px,
	     * set to a string for a custom width in custom measurement.
	     * @default false
	     */
	    maxWidth?: boolean | number | string;
	    /**
	     * Customize the padding around the content of the flyout header, body and footer
	     * @default l
	     */
	    paddingSize?: _EuiFlyoutPaddingSize;
	    /**
	     * Adds an EuiOverlayMask and wraps in an EuiPortal
	     * @default true
	     */
	    ownFocus?: boolean;
	    /**
	     * Hides the default close button. You must provide another close button somewhere within the flyout.
	     * @default false
	     */
	    hideCloseButton?: boolean;
	    /**
	     * Extends EuiButtonIconProps onto the close button
	     */
	    closeButtonProps?: Partial<EuiButtonIconPropsForButton>;
	    /**
	     * Position of close button.
	     * `inside`: Floating to just inside the flyout, always top right;
	     * `outside`: Floating just outside the flyout near the top (side dependent on `side`). Helpful when the close button may cover other interactable content.
	     * @default inside
	     */
	    closeButtonPosition?: 'inside' | 'outside';
	    /**
	     * Adjustments to the EuiOverlayMask that is added when `ownFocus = true`.
	     *
	     * @deprecated Prefer the `container` prop to scope flyouts to an
	     * application area. `maskProps` is still honored but may be removed
	     * in a future major version.
	     */
	    maskProps?: EuiOverlayMaskProps;
	    /**
	     * How to display the the flyout in relation to the body content;
	     * `push` keeps it visible, pushing the `<body>` content via padding
	     * @default overlay
	     */
	    type?: _EuiFlyoutType;
	    /**
	     * Forces this interaction on the mask overlay or body content.
	     * Defaults depend on `ownFocus` and `type` values
	     */
	    outsideClickCloses?: boolean;
	    /**
	     * Which side of the window to attach to.
	     * The `left` option should only be used for navigation.
	     * @default right
	     */
	    side?: _EuiFlyoutSide;
	    /**
	     * Named breakpoint (`xs` through `xl`) for customizing the minimum window width to enable the `push` type
	     * @default l
	     */
	    pushMinBreakpoint?: EuiBreakpointSize;
	    /**
	     * @deprecated - use `hasAnimation` instead
	     * Enables a slide in animation on flyouts
	     * @default true for overlay flyouts, `false` for push flyouts
	     */
	    pushAnimation?: boolean;
	    /**
	     * Enables a slide in animation on flyouts
	     * @default true for overlay flyouts, `false` for push flyouts
	     */
	    hasAnimation?: boolean;
	    style?: CSSProperties;
	    /**
	     * When the flyout is used as a child in a managed flyout session, setting `true` gives the shaded background style.
	     * @default false
	     */
	    hasChildBackground?: boolean;
	    /**
	     * Object of props passed to EuiFocusTrap.
	     * `shards` specifies an array of elements that will be considered part of the flyout, preventing the flyout from being closed when clicked.
	     * `closeOnMouseup` will delay the close callback, allowing time for external toggle buttons to handle close behavior.
	     * `returnFocus` defines the return focus behavior and provides the possibility to check the available target element or opt out of the behavior in favor of manually returning focus
	     */
	    focusTrapProps?: Pick<EuiFocusTrapProps, 'closeOnMouseup' | 'shards' | 'returnFocus'>;
	    /**
	     * By default, EuiFlyout will consider any fixed `EuiHeader`s that sit alongside or above the EuiFlyout
	     * as part of the flyout's focus trap. This prevents focus fighting with interactive elements
	     * within fixed headers.
	     *
	     * Set this to `false` if you need to disable this behavior for a specific reason.
	     *
	     * @deprecated Prefer `includeSelectorInFocusTrap` when using the
	     * `container` prop. `includeFixedHeadersInFocusTrap` is still honored
	     * but may be removed in a future major version.
	     */
	    includeFixedHeadersInFocusTrap?: boolean;
	    /**
	     * Specify additional css selectors to include in the focus trap.
	     */
	    includeSelectorInFocusTrap?: string[] | string;
	    /**
	     * Props for the flyout menu to have one rendered in the flyout.
	     * If used, the close button will be automatically hidden, as the flyout menu has its own close button.
	     *
	     * Use `flyoutMenuDisplayMode` to control whether/when the menu is rendered. See {@link EuiFlyoutMenuDisplayMode}.
	     */
	    flyoutMenuProps?: EuiFlyoutMenuProps;
	    /**
	     * Controls the display mode of the flyout menu:
	     * - `'auto'`: Render the menu whenever menu props are available and there is navigation content
	     * (back button, history, custom actions) or a visible title.
	     * - `'always'`: Render the menu whenever menu props are available. This may result in a close-only menu.
	     *
	     * @default 'auto'
	     */
	    flyoutMenuDisplayMode?: EuiFlyoutMenuDisplayMode;
	    /**
	     * Whether the flyout should be resizable.
	     * @default false
	     */
	    resizable?: boolean;
	    /**
	     * Optional callback that fires when the flyout is resized.
	     */
	    onResize?: (width: number) => void;
	    /**
	     * Optional reference container element. When not specified or set to
	     * `null`, the flyout uses standard viewport-relative `position: fixed`
	     * behavior with no additional positioning styles.
	     *
	     * When a specific element is provided, the flyout is visually constrained
	     * to that element's bounds (e.g. does not overlap side navigation,
	     * toolbars). The flyout remains mounted in `document.body` with
	     * `position: fixed`; the container's bounding rect is read (via
	     * `ResizeObserver` and window scroll/resize listeners) to compute inline
	     * positioning styles that pin the flyout inside the container. No DOM
	     * mutations are applied to the container except push-mode padding.
	     *
	     * Resize clamping and responsive breakpoints use the container's width
	     * when provided, or the viewport width otherwise.
	     *
	     * Can be set globally via `EuiProvider` component defaults so all
	     * flyouts are scoped to the application container by default. Individual
	     * flyouts can override with `container={null}` to force viewport mode.
	     *
	     * A getter function `() => HTMLElement | null` or a CSS selector string
	     * (e.g. `'#app-main'`) can also be passed.
	     */
	    container?: HTMLElement | null | (() => HTMLElement | null) | string;
	}
	type Props<T extends ElementType> = CommonProps & {
	    /**
	     * Sets the HTML element for `EuiFlyout`
	     */
	    as?: T;
	} & _EuiFlyoutComponentProps & Omit<PropsOfElement<T>, keyof _EuiFlyoutComponentProps>;
	export type EuiFlyoutComponentProps<T extends ElementType = 'div' | 'nav'> = Props<T> & Omit<ComponentPropsWithRef<T>, keyof Props<T>>;
	export const EuiFlyoutComponent: <T extends ElementType = "div" | "nav">(props: EuiFlyoutComponentProps<T>) => JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/flyout/flyout' {
	import React, { ElementType } from 'react';
	import { type EuiFlyoutComponentProps } from '@elastic/eui/src/components/flyout/flyout.component';
	import { SESSION_INHERIT, SESSION_NEVER, SESSION_START } from '@elastic/eui/src/components/flyout/manager/const';
	export type { EuiFlyoutSize, _EuiFlyoutPaddingSize, _EuiFlyoutSide, } from '@elastic/eui/src/components/flyout/const';
	export { FLYOUT_SIDES, FLYOUT_PADDING_SIZES, FLYOUT_SIZES, FLYOUT_TYPES, FLYOUT_MENU_DISPLAY_MODES, } from '@elastic/eui/src/components/flyout/const';
	export type EuiFlyoutProps<T extends ElementType = 'div' | 'nav'> = Omit<EuiFlyoutComponentProps<T>, 'as'> & {
	    /**
	     * Controls the way the session is managed for this flyout.
	     * - `start`: Creates a new flyout session. Use this for the main flyout.
	     * - `inherit`: Inherits an existing session if one is active, otherwise functions as a standard flyout.
	     * - `never`: Disregards session management and always functions as a standard flyout.
	     *
	     * When the `session` prop is undefined (not set), the flyout will automatically inherit from
	     * a parent flyout if it's nested inside one. Otherwise, it defaults to `never`.
	     *
	     * Check out [EuiFlyout session management](https://eui.elastic.co/docs/components/containers/flyout/#flyout-session-management)
	     * documentation to learn more.
	     * @default undefined (auto-inherit when nested, otherwise 'never')
	     */
	    session?: typeof SESSION_START | typeof SESSION_INHERIT | typeof SESSION_NEVER;
	    /**
	     * Optional Symbol to scope flyout history. Only flyouts that receive the same Symbol reference share Back button and history; omit to get a unique group per session.
	     * @default undefined (each session gets a unique key and does not share history)
	     */
	    historyKey?: symbol;
	    /**
	     * Callback fired when the flyout becomes active/visible, which may happen programmatically from history navigation.
	     */
	    onActive?: () => void;
	    /**
	     * The HTML element to render as the flyout container.
	     */
	    as?: T;
	};
	export const EuiFlyout: React.ForwardRefExoticComponent<Omit<EuiFlyoutProps<"div" | "nav">, "ref"> & React.RefAttributes<HTMLElement | HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/flyout/flyout_body.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutBodyStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlyoutBody: import("@emotion/react").SerializedStyles;
	    overflow: {
	        euiFlyoutBody__overflow: import("@emotion/react").SerializedStyles;
	        noBanner: import("@emotion/react").SerializedStyles;
	        hasBanner: import("@emotion/react").SerializedStyles;
	    };
	    euiFlyoutBody__banner: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout_body' {
	import { FunctionComponent, HTMLAttributes, ReactNode, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFlyoutBodyProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps & {
	    /**
	     * Use to display a banner at the top of the body. It is suggested to use `EuiCallOut` for it.
	     */
	    banner?: ReactNode;
	    /**
	     * [Scrollable regions (or their children) should be focusable](https://dequeuniversity.com/rules/axe/4.0/scrollable-region-focusable)
	     * to allow keyboard users to scroll the region via arrow keys.
	     *
	     * By default, EuiFlyoutBody's scroll overflow wrapper sets a `tabIndex` of `0`.
	     * If you know your flyout body content already contains focusable children
	     * that satisfy keyboard accessibility requirements, you can use this prop
	     * to override this default.
	     */
	    scrollableTabIndex?: number;
	    /**
	     * Use to access the flyout's internal scrollable container.
	     */
	    scrollContainerRef?: Ref<HTMLDivElement>;
	}>;
	export const EuiFlyoutBody: EuiFlyoutBodyProps;

}
declare module '@elastic/eui/src/components/flyout/flyout_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlyoutFooter: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout_footer' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFlyoutFooterProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps>;
	export const EuiFlyoutFooter: EuiFlyoutFooterProps;

}
declare module '@elastic/eui/src/components/flyout/flyout_header.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFlyoutHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFlyoutHeader: import("@emotion/react").SerializedStyles;
	    hasBorder: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/flyout/flyout_header' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFlyoutHeaderProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps & {
	    hasBorder?: boolean;
	}>;
	export const EuiFlyoutHeader: EuiFlyoutHeaderProps;

}
declare module '@elastic/eui/src/components/flyout' {
	export type { EuiFlyoutProps, EuiFlyoutSize } from '@elastic/eui/src/components/flyout/flyout';
	export { EuiFlyout } from '@elastic/eui/src/components/flyout/flyout';
	export type { EuiFlyoutCloseEvent, EuiFlyoutCloseReason, EuiFlyoutCloseMeta, } from '@elastic/eui/src/components/flyout/types';
	export type { EuiFlyoutBodyProps } from '@elastic/eui/src/components/flyout/flyout_body';
	export { EuiFlyoutBody } from '@elastic/eui/src/components/flyout/flyout_body';
	export type { EuiFlyoutFooterProps } from '@elastic/eui/src/components/flyout/flyout_footer';
	export { EuiFlyoutFooter } from '@elastic/eui/src/components/flyout/flyout_footer';
	export type { EuiFlyoutHeaderProps } from '@elastic/eui/src/components/flyout/flyout_header';
	export { EuiFlyoutHeader } from '@elastic/eui/src/components/flyout/flyout_header';
	export { euiFlyoutSlideInRight, euiFlyoutSlideInLeft } from '@elastic/eui/src/components/flyout/flyout.styles';
	export type { EuiFlyoutResizableProps } from '@elastic/eui/src/components/flyout/flyout_resizable';
	export { EuiFlyoutResizable } from '@elastic/eui/src/components/flyout/flyout_resizable';
	export type { EuiFlyoutMenuProps, EuiFlyoutHistoryItem, EuiFlyoutMenuCustomAction, EuiFlyoutMenuPagination, } from '@elastic/eui/src/components/flyout/flyout_menu';
	export { EuiFlyoutMenu } from '@elastic/eui/src/components/flyout/flyout_menu';
	export { useIsInManagedFlyout, useHasActiveSession } from '@elastic/eui/src/components/flyout/manager';
	export { useIsInsideParentFlyout } from '@elastic/eui/src/components/flyout/flyout_parent_context';
	export { getFlyoutManagerStore, type FlyoutManagerStore, type FlyoutManagerEvent, type EuiFlyoutManagerState, type FlyoutSession, } from '@elastic/eui/src/components/flyout/manager';

}
declare module '@elastic/eui/src/components/provider/component_defaults/component_defaults' {
	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, EuiTableProps } from '@elastic/eui/src/components/table';
	import type { EuiFlyoutProps } from '@elastic/eui/src/components/flyout';
	import type { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	import type { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export type EuiComponentDefaults = {
	    /**
	     * Provide a global configuration for EuiPortal's default insertion position.
	     */
	    EuiPortal?: Pick<EuiPortalProps, 'insert'>;
	    /**
	     * Provide a global configuration for EuiFocusTrap's `gapMode` and `crossFrame` props
	     */
	    EuiFocusTrap?: Pick<EuiFocusTrapProps, 'gapMode' | 'crossFrame'>;
	    /**
	     * Provide global settings for EuiTablePagination's props that affect page size
	     * / the rows per page selection.
	     *
	     * 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.
	     *
	     * Defaults will be inherited by all `EuiBasicTable`s and `EuiInMemoryTable`s.
	     */
	    EuiTable?: Pick<EuiTableProps, 'responsiveBreakpoint' | 'scrollableInline' | 'tableLayout' | 'stickyScrollbar' | 'stickyHeader'>;
	    /**
	     * Provide a global configuration for `EuiFlyout`s.
	     * Defaults will be inherited by all `EuiFlyout`s.
	     */
	    EuiFlyout?: Pick<EuiFlyoutProps, 'includeSelectorInFocusTrap' | 'includeFixedHeadersInFocusTrap' | 'container'>;
	    /**
	     * Provide a global configuration for `EuiPopover`s.
	     * Defaults will be inherited by every `EuiPopover`.
	     */
	    EuiPopover?: Pick<EuiPopoverProps, 'repositionOnScroll'>;
	    /**
	     * Provide a global configuration for `EuiToolTip`s.
	     * Defaults will be inherited by every `EuiToolTip`.
	     */
	    EuiToolTip?: Pick<EuiToolTipProps, 'repositionOnScroll'>;
	};
	export const EuiComponentDefaultsContext: React.Context<EuiComponentDefaults>;
	export type EuiComponentDefaultsProviderProps = PropsWithChildren & {
	    componentDefaults?: EuiComponentDefaults;
	};
	export const EuiComponentDefaultsProvider: FunctionComponent<EuiComponentDefaultsProviderProps>;
	export const useComponentDefaults: () => EuiComponentDefaults;
	export const usePropsWithComponentDefaults: <TComponentName extends keyof EuiComponentDefaults, TComponentProps>(componentName: TComponentName, props: TComponentProps) => TComponentProps;
	/**
	 * Used only to generate prop type definitions (via `@elastic/eui-docgen`) to document `EuiComponentDefaults` in a props table.
	 *
	 * @see https://github.com/elastic/eui/issues/8388
	 */
	export const EuiProviderComponentDefaultsProps: FunctionComponent<EuiComponentDefaults>;

}
declare module '@elastic/eui/src/components/provider/component_defaults' {
	export * from '@elastic/eui/src/components/provider/component_defaults/component_defaults';

}
declare module '@elastic/eui/src/components/focus_trap/focus_trap' {
	import { FunctionComponent, CSSProperties } from 'react';
	import { ReactFocusOnProps } from 'react-focus-on/dist/es5/types';
	import { ElementTarget } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type FocusTarget = ElementTarget;
	export type EuiFocusTrapProps = Omit<ReactFocusOnProps, 'enabled' | 'style' | 'className' | 'css' | 'gapMode' | 'crossFrame' | 'scrollLock' | 'noIsolation' | 'returnFocus'> & {
	    className?: CommonProps['className'];
	    css?: CommonProps['css'];
	    style?: CSSProperties;
	    /**
	     * @default false
	     */
	    disabled?: boolean;
	    /**
	     * Whether `onClickOutside` should be called on mouseup instead of mousedown.
	     * This flag can be used to prevent conflicts with outside toggle buttons by delaying the closing click callback.
	     */
	    closeOnMouseup?: boolean;
	    /**
	     * Clicking outside the trap area will disable the trap
	     * @default false
	     */
	    clickOutsideDisables?: boolean;
	    /**
	     * Reference to element that will get focus when the trap is initiated
	     */
	    initialFocus?: FocusTarget;
	    /**
	     * if `scrollLock` is set to true, the body's scrollbar width will be preserved on lock
	     * via the `gapMode` CSS property. Depending on your custom CSS, you may prefer to use
	     * `margin` instead of `padding`.
	     * @default padding
	     */
	    gapMode?: 'padding' | 'margin';
	    /**
	     * Configures focus trapping between iframes.
	     * By default, EuiFocusTrap allows focus to leave iframes and move to elements outside of it.
	     * Set to `true` if you want focus to remain trapped within the iframe.
	     * @default false
	     */
	    crossFrame?: ReactFocusOnProps['crossFrame'];
	    /**
	     * @default false
	     */
	    scrollLock?: ReactFocusOnProps['scrollLock'];
	    /**
	     * @default true
	     */
	    noIsolation?: ReactFocusOnProps['noIsolation'];
	    /**
	     * @default true
	     */
	    returnFocus?: ReactFocusOnProps['returnFocus'];
	};
	export const EuiFocusTrap: FunctionComponent<EuiFocusTrapProps>;

}
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/observer/mutation_observer/mutation_observer' {
	import { ReactNode, FunctionComponent } from 'react';
	export interface EuiMutationObserverProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: (ref: (e: HTMLElement | null) => void) => ReactNode;
	    onMutation: MutationCallback;
	    observerOptions?: MutationObserverInit;
	}
	export const EuiMutationObserver: FunctionComponent<EuiMutationObserverProps>;
	export const useMutationObserver: (container: Element | null, callback: MutationCallback, observerOptions?: MutationObserverInit) => void;

}
declare module '@elastic/eui/src/components/observer/mutation_observer' {
	export type { EuiMutationObserverProps } from '@elastic/eui/src/components/observer/mutation_observer/mutation_observer';
	export { EuiMutationObserver, useMutationObserver } from '@elastic/eui/src/components/observer/mutation_observer/mutation_observer';

}
declare module '@elastic/eui/src/components/outside_click_detector/outside_click_detector' {
	import { MouseEvent as ReactMouseEvent, ReactElement } from 'react';
	export interface EuiEvent extends Event {
	    euiGeneratedBy: string[];
	}
	export interface EuiOutsideClickDetectorProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactElement<any>;
	    onOutsideClick: (event: Event) => void;
	    isDisabled?: boolean;
	    onMouseDown?: (event: ReactMouseEvent) => void;
	    onMouseUp?: (event: ReactMouseEvent) => void;
	    onTouchStart?: (event: ReactMouseEvent) => void;
	    onTouchEnd?: (event: ReactMouseEvent) => void;
	}
	export const EuiOutsideClickDetector: import("react").ForwardRefExoticComponent<EuiOutsideClickDetectorProps & import("react").RefAttributes<HTMLElement>>;

}
declare module '@elastic/eui/src/components/outside_click_detector' {
	export type { EuiOutsideClickDetectorProps } from '@elastic/eui/src/components/outside_click_detector/outside_click_detector';
	export { EuiOutsideClickDetector } from '@elastic/eui/src/components/outside_click_detector/outside_click_detector';

}
declare module '@elastic/eui/src/components/popover/popover_arrow/_popover_arrow.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPopoverArrowStyles: (euiThemeContext: UseEuiTheme) => {
	    top: import("@emotion/react").SerializedStyles;
	    bottom: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    euiPopoverArrowWrapper: import("@emotion/react").SerializedStyles;
	    euiPopoverArrow: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/popover/popover_arrow/_popover_arrow' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const POSITIONS: readonly ["top", "left", "right", "bottom"];
	export type EuiPopoverArrowPositions = (typeof POSITIONS)[number];
	export type EuiPopoverArrowProps = HTMLAttributes<HTMLDivElement> & CommonProps & {
	    position: EuiPopoverArrowPositions;
	};
	export const EuiPopoverArrow: FunctionComponent<EuiPopoverArrowProps>;

}
declare module '@elastic/eui/src/components/popover/popover_arrow' {
	export type { EuiPopoverArrowProps, EuiPopoverArrowPositions, } from '@elastic/eui/src/components/popover/popover_arrow/_popover_arrow';
	export { EuiPopoverArrow } from '@elastic/eui/src/components/popover/popover_arrow/_popover_arrow';

}
declare module '@elastic/eui/src/components/popover/popover.styles' {
	export const euiPopoverStyles: () => {
	    euiPopover: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/popover/popover_panel/_popover_panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const openAnimationTiming = "slow";
	/**
	 * 1. Can expand further, but it looks weird if it's smaller than the originating button.
	 * 2. Animation happens on the panel. But don't animate position when using the attached mode like for inputs
	 * 3. Make sure the panel stays within the window.
	 * 4. Make the popover lighter on dark mode (too hard to distinguish from plain bgs otherwise), and set a CSS var for the arrow to use
	 */
	export const euiPopoverPanelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPopover__panel: import("@emotion/react").SerializedStyles;
	    isOpen: import("@emotion/react").SerializedStyles;
	    light: import("@emotion/react").SerializedStyles;
	    dark: import("@emotion/react").SerializedStyles;
	    hasTransform: {
	        hasTransform: import("@emotion/react").SerializedStyles;
	        top: import("@emotion/react").SerializedStyles;
	        bottom: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    isAttached: {
	        isAttached: import("@emotion/react").SerializedStyles;
	        top: import("@emotion/react").SerializedStyles;
	        bottom: import("@emotion/react").SerializedStyles;
	        readonly left: import("@emotion/react").SerializedStyles;
	        readonly right: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/popover/popover_panel/_popover_panel' {
	import React, { FunctionComponent } from 'react';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { _EuiPanelDivlike } from '@elastic/eui/src/components/panel/panel';
	import { EuiPopoverArrowPositions } from '@elastic/eui/src/components/popover/popover_arrow';
	export const EuiPopoverPanelContext: React.Context<{
	    paddingSize: EuiPaddingSize;
	}>;
	export type EuiPopoverPanelProps = _EuiPanelDivlike;
	type EuiPopoverPanelInternalProps = {
	    isOpen?: boolean;
	    isAttached?: boolean;
	    position?: EuiPopoverArrowPositions | null;
	};
	/**
	 * *INTERNAL ONLY*
	 * Purely for re-use of styling
	 */
	export const EuiPopoverPanel: FunctionComponent<EuiPopoverPanelProps & EuiPopoverPanelInternalProps>;
	export {};

}
declare module '@elastic/eui/src/components/popover/popover_panel' {
	export { EuiPopoverPanel } from '@elastic/eui/src/components/popover/popover_panel/_popover_panel';

}
declare module '@elastic/eui/src/components/popover/popover' {
	import React, { Component, KeyboardEvent, CSSProperties, HTMLAttributes, ReactNode, Ref, RefCallback, PropsWithChildren, ContextType } from 'react';
	import { type FocusableElement } from 'tabbable';
	import { CommonProps, NoArgCallback } from '@elastic/eui/src/components/common';
	import { FocusTarget, EuiFocusTrapProps } from '@elastic/eui/src/components/focus_trap';
	import { EuiPopoverPosition } from '@elastic/eui/src/services/popover';
	import { EuiPopoverArrowPositions } from '@elastic/eui/src/components/popover/popover_arrow';
	import { EuiPopoverPanelProps } from '@elastic/eui/src/components/popover/popover_panel/_popover_panel';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { EuiComponentDefaultsContext } from '@elastic/eui/src/components/provider/component_defaults';
	export const popoverAnchorPosition: readonly ["upCenter", "upLeft", "upRight", "downCenter", "downLeft", "downRight", "leftCenter", "leftUp", "leftDown", "rightCenter", "rightUp", "rightDown"];
	export type PopoverAnchorPosition = (typeof popoverAnchorPosition)[number];
	export interface EuiPopoverProps extends PropsWithChildren, CommonProps {
	    /**
	     * Alignment of the popover and arrow relative to the button
	     * @default downLeft
	     */
	    anchorPosition?: PopoverAnchorPosition;
	    /**
	     * Style and position alteration for arrow-less attachment.
	     * Intended for use with inputs as anchors, e.g. EuiInputPopover
	     */
	    attachToAnchor?: boolean;
	    /**
	     * Triggering element for which to align the popover to
	     */
	    button: NonNullable<ReactNode>;
	    /**
	     * Callback to handle hiding of the popover
	     */
	    closePopover: NoArgCallback<void>;
	    /**
	     * Restrict the popover's position within this element
	     */
	    container?: HTMLElement;
	    /**
	     * CSS display type for both the popover and anchor
	     */
	    display?: CSSProperties['display'];
	    /**
	     * Object of props passed to EuiFocusTrap
	     */
	    focusTrapProps?: Partial<EuiFocusTrapProps>;
	    /**
	     * Show arrow indicating to originating button
	     * @default false
	     */
	    hasArrow?: boolean;
	    /**
	     * Specifies what element should initially have focus; Can be a DOM
	     * node, or a selector string (which will be passed to
	     * document.querySelector() to find the DOM node), or a function that
	     * returns a DOM node.
	     *
	     * If not passed, initial focus defaults to the popover panel.
	     */
	    initialFocus?: FocusTarget;
	    /**
	     * Passed directly to EuiPortal for DOM positioning. Both properties are
	     * required if prop is specified
	     */
	    insert?: {
	        sibling: HTMLElement;
	        position: 'before' | 'after';
	    };
	    /**
	     * Visibility state of the popover
	     */
	    isOpen?: boolean;
	    /**
	     * Traps tab focus within the popover contents
	     */
	    ownFocus?: boolean;
	    /**
	     * Custom class added to the EuiPanel containing the popover contents
	     */
	    panelClassName?: string;
	    /**
	     * EuiPanel padding on all sides
	     */
	    panelPaddingSize?: EuiPaddingSize;
	    /**
	     * Standard DOM `style` attribute. Passed to the EuiPanel
	     */
	    panelStyle?: CSSProperties;
	    /**
	     * Object of props passed to EuiPanel. See {@link EuiPopoverPanelProps}
	     */
	    panelProps?: Omit<EuiPopoverPanelProps, 'style' | 'hasShadow' | 'hasBorder' | 'color'>;
	    panelRef?: RefCallback<HTMLElement | null>;
	    /**
	     * Optional screen reader instructions to announce upon popover open,
	     * in addition to EUI's default popover instructions for Escape on close.
	     * Useful for popovers that may have additional keyboard capabilities such as
	     * arrow navigation.
	     */
	    popoverScreenReaderText?: string | ReactNode;
	    popoverRef?: Ref<HTMLDivElement>;
	    /**
	     * When `true`, the popover's position is re-calculated when the user
	     * scrolls, this supports having fixed-position popover anchors. When nesting
	     * an `EuiPopover` in a scrollable container, `repositionOnScroll` should be `true`
	     */
	    repositionOnScroll?: boolean;
	    /**
	     * By default, popovers will attempt to position themselves along the initial
	     * axis specified. If there is not enough room either vertically or horizontally
	     * however, the popover will attempt to reposition itself along the secondary
	     * cross axis if there is room there instead.
	     *
	     * If you do not want this repositioning to occur (and it is acceptable for
	     * the popover to appear offscreen), set this to false to disable this behavior.
	     *
	     * @default true
	     */
	    repositionToCrossAxis?: boolean;
	    /**
	     * By default, popover content inherits the z-index of the anchor
	     * component; pass `zIndex` to override
	     */
	    zIndex?: number;
	    /**
	     * Distance away from the anchor that the popover will render
	     * @default 4 (0 when `hasArrow=true`)
	     */
	    offset?: number;
	    /**
	     * Minimum distance between the popover and the bounding container;
	     * Pass an array of 4 values to adjust each side differently: `[top, right, bottom, left]`
	     * @default 16
	     */
	    buffer?: number | [number, number, number, number];
	    /**
	     * Element to pass as the child element of the arrow;
	     * Use case is typically limited to an accompanying `EuiBeacon`
	     */
	    arrowChildren?: ReactNode;
	    /**
	     * Provide a name to the popover panel
	     */
	    'aria-label'?: string;
	    /**
	     * Alternative option to `aria-label` that takes an `id`.
	     * Usually takes the `id` of the popover title
	     */
	    'aria-labelledby'?: string;
	    /**
	     * Function callback for when the popover positon changes
	     */
	    onPositionChange?: (position: EuiPopoverPosition) => void;
	}
	export function getPopoverPositionFromAnchorPosition(anchorPosition: PopoverAnchorPosition): EuiPopoverPosition;
	export function getPopoverAlignFromAnchorPosition(anchorPosition: PopoverAnchorPosition): EuiPopoverPosition;
	export type Props = EuiPopoverProps & HTMLAttributes<HTMLDivElement>;
	interface State {
	    prevProps: {
	        isOpen?: boolean;
	    };
	    suppressingPopover?: boolean;
	    isClosing: boolean;
	    isOpening: boolean;
	    popoverStyles: CSSProperties;
	    arrowStyles?: CSSProperties;
	    arrowPosition: EuiPopoverArrowPositions | null;
	    openPosition: any;
	    isOpenStable: boolean;
	}
	type PropsWithDefaults = Props & {
	    anchorPosition: PopoverAnchorPosition;
	    hasArrow: boolean;
	    isOpen: boolean;
	    ownFocus: boolean;
	    panelPaddingSize: EuiPaddingSize;
	};
	export class EuiPopover extends Component<Props, State> {
	    static contextType: React.Context<import ("@elastic/eui/src/components/provider/component_defaults").EuiComponentDefaults>;
	    context: ContextType<typeof EuiComponentDefaultsContext>;
	    private repositionOnScroll;
	    static defaultProps: Partial<PropsWithDefaults>;
	    static getDerivedStateFromProps(nextProps: Props, prevState: State): Partial<State> | null;
	    private repositionTimeout;
	    private strandedFocusTimeout;
	    private closingTransitionTimeout;
	    private closingTransitionAnimationFrame;
	    private button;
	    private panel;
	    private idGenerator;
	    private panelId;
	    private descriptionId;
	    constructor(props: Props);
	    closePopover: () => void;
	    onEscapeKey: (event: Event) => void;
	    getFocusableToggleButton: () => FocusableElement | undefined;
	    handleStrandedFocus: () => void;
	    onKeyDown: (event: KeyboardEvent) => void;
	    onClickOutside: (event: Event) => void;
	    onOpenPopover: () => void;
	    /**
	     * Updates ARIA attributes on the popover trigger button
	     * Only applies ARIA when the trigger is button-like (semantic <button> or role="button").
	     * Avoids adding incorrect ARIA on inputs or other non-button elements.
	     */
	    private updateTriggerButtonAriaAttributes;
	    componentDidMount(): void;
	    componentDidUpdate(prevProps: Props): void;
	    componentWillUnmount(): void;
	    onMutation: (records: MutationRecord[]) => void;
	    positionPopover: (allowEnforcePosition: boolean) => void;
	    positionPopoverFixed: () => void;
	    positionPopoverFluid: () => void;
	    panelRef: (node: HTMLElement | null) => void;
	    popoverRef: (node: HTMLDivElement | null) => void;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/popover/input_popover' {
	import React, { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover/popover';
	export interface _EuiInputPopoverProps extends Omit<EuiPopoverProps, 'button' | 'buttonRef' | 'anchorPosition'> {
	    /**
	     * Alignment of the popover relative to the input
	     */
	    anchorPosition?: 'downLeft' | 'downRight' | 'downCenter';
	    disableFocusTrap?: boolean;
	    /**
	     * Allows automatically closing the input popover on page scroll
	     */
	    closeOnScroll?: boolean;
	    fullWidth?: boolean;
	    input: EuiPopoverProps['button'];
	    inputRef?: EuiPopoverProps['popoverRef'];
	    onPanelResize?: (width: number) => void;
	    /**
	     * By default, **EuiInputPopovers** inherit the same width as the passed input element.
	     * However, if the input width is too small, you can pass a minimum panel width
	     * (that should be based on the popover content).
	     */
	    panelMinWidth?: number;
	}
	export type EuiInputPopoverProps = CommonProps & HTMLAttributes<HTMLDivElement> & _EuiInputPopoverProps;
	export const EuiInputPopoverWidthContext: React.Context<number>;
	export const EuiInputPopover: FunctionComponent<EuiInputPopoverProps>;

}
declare module '@elastic/eui/src/components/popover/popover_title.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPopoverTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPopoverTitle: import("@emotion/react").SerializedStyles;
	    panelPaddingSizes: {
	        none: import("@emotion/react").SerializedStyles;
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/popover/popover_title' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiPopoverTitleProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps & {
	    /**
	     * Customize the all around padding of the popover title.
	     * Leave `undefined` to inherit from the `panelPaddingSize` of the containing EuiPopover
	     */
	    paddingSize?: EuiPaddingSize;
	}>;
	export const EuiPopoverTitle: EuiPopoverTitleProps;

}
declare module '@elastic/eui/src/components/popover/popover_footer.styles' {
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPopoverFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPopoverFooter: import("@emotion/react").SerializedStyles;
	    panelPaddingSizes: {
	        none: import("@emotion/react").SerializedStyles;
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	};
	export const panelPaddingOffset: (euiThemeContext: UseEuiTheme, size: EuiPaddingSize) => string;

}
declare module '@elastic/eui/src/components/popover/popover_footer' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiPopoverFooterProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps & {
	    /**
	     * Customize the all around padding of the popover footer.
	     * Leave `undefined` to inherit from the `panelPaddingSize` of the containing EuiPopover
	     */
	    paddingSize?: EuiPaddingSize;
	}>;
	export const EuiPopoverFooter: EuiPopoverFooterProps;

}
declare module '@elastic/eui/src/components/popover/wrapping_popover' {
	import React from 'react';
	import { Props as EuiPopoverProps } from '@elastic/eui/src/components/popover/popover';
	export interface EuiWrappingPopoverProps extends Omit<EuiPopoverProps, 'button'> {
	    button: HTMLElement;
	}
	/**
	 * Injects the EuiPopover next to the button via EuiPortal
	 * then the button element is moved into the popover dom.
	 * On unmount, the button is moved back to its original location.
	 */
	export function EuiWrappingPopover(props: EuiWrappingPopoverProps): React.JSX.Element;

}
declare module '@elastic/eui/src/components/popover' {
	export type { EuiInputPopoverProps } from '@elastic/eui/src/components/popover/input_popover';
	export { EuiInputPopover } from '@elastic/eui/src/components/popover/input_popover';
	export type { EuiPopoverProps, PopoverAnchorPosition } from '@elastic/eui/src/components/popover/popover';
	export { EuiPopover } from '@elastic/eui/src/components/popover/popover';
	export type { EuiPopoverTitleProps } from '@elastic/eui/src/components/popover/popover_title';
	export { EuiPopoverTitle } from '@elastic/eui/src/components/popover/popover_title';
	export type { EuiPopoverFooterProps } from '@elastic/eui/src/components/popover/popover_footer';
	export { EuiPopoverFooter } from '@elastic/eui/src/components/popover/popover_footer';
	export type { EuiWrappingPopoverProps } from '@elastic/eui/src/components/popover/wrapping_popover';
	export { EuiWrappingPopover } from '@elastic/eui/src/components/popover/wrapping_popover';

}
declare module '@elastic/eui/src/components/form/super_select/super_select_item' {
	import React, { ReactNode } from 'react';
	import { type EuiListItemLayoutProps } from '@elastic/eui/src/components/list_item_layout';
	export interface EuiSuperSelectOption<T> {
	    value: NonNullable<T>;
	    inputDisplay?: ReactNode;
	    dropdownDisplay?: ReactNode;
	    disabled?: boolean;
	    'data-test-subj'?: string;
	}
	type EuiSuperSelectItemProps = EuiListItemLayoutProps & {};
	export const EuiSuperSelectItem: React.ForwardRefExoticComponent<EuiSuperSelectItemProps & React.RefAttributes<HTMLElement>>;
	export {};

}
declare module '@elastic/eui/src/components/form/super_select/super_select.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSuperSelectStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiSuperSelect__listbox: import("@emotion/react").SerializedStyles;
	};
	export const euiSuperSelectControlStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSuperSelect__control: import("@emotion/react").SerializedStyles;
	    open: import("@emotion/react").SerializedStyles;
	    invalid: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    readOnly: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    formWidth: string;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	    euiSuperSelect__placeholder: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/form/super_select/super_select_control' {
	import { Ref, FunctionComponent, ButtonHTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	import { type EuiSuperSelectOption } from '@elastic/eui/src/components/form/super_select/super_select_item';
	export interface EuiSuperSelectControlProps<T> extends CommonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'placeholder'> {
	    buttonRef?: Ref<HTMLButtonElement>;
	    /**
	     * @default false
	     */
	    compressed?: boolean;
	    /**
	     * Expand to fill 100% of the parent.
	     * Defaults to `fullWidth` prop of `<EuiForm>`.
	     * @default false
	     */
	    fullWidth?: boolean;
	    /**
	     * @default false
	     */
	    isInvalid?: boolean;
	    /**
	     * @default false
	     */
	    isLoading?: boolean;
	    readOnly?: boolean;
	    name?: string;
	    placeholder?: ReactNode;
	    value?: T;
	    options?: Array<EuiSuperSelectOption<T>>;
	    /**
	     * Creates an input group with element(s) coming before input.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	}
	export const EuiSuperSelectControl: <T = string>(props: EuiSuperSelectControlProps<T> & {
	    isDropdownOpen?: boolean;
	}) => ReturnType<FunctionComponent<EuiSuperSelectControlProps<T>>>;

}
declare module '@elastic/eui/src/components/form/super_select/super_select' {
	import React, { Component, FocusEvent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { type EuiInputPopoverProps } from '@elastic/eui/src/components/popover';
	import { type EuiSuperSelectControlProps } from '@elastic/eui/src/components/form/super_select/super_select_control';
	import { type EuiSuperSelectOption } from '@elastic/eui/src/components/form/super_select/super_select_item'; enum ShiftDirection {
	    BACK = "back",
	    FORWARD = "forward"
	}
	export type EuiSuperSelectProps<T = string> = CommonProps & Omit<EuiSuperSelectControlProps<T>, 'onChange' | 'onClick' | 'onFocus' | 'onBlur' | 'options' | 'value'> & {
	    /**
	     * Pass an array of options that must at least include:
	     * `value`: storing unique value of item,
	     * `inputDisplay`: what shows inside the form input when selected
	     * `dropdownDisplay` (optional): what shows for the item in the dropdown
	     */
	    options: Array<EuiSuperSelectOption<T>>;
	    valueOfSelected?: NonNullable<T>;
	    /**
	     * Placeholder to display when the current selected value is empty.
	     */
	    placeholder?: ReactNode;
	    /**
	     * Classes for the context menu item
	     */
	    itemClassName?: string;
	    /**
	     * You must pass an `onChange` function to handle the update of the value
	     */
	    onChange?: (value: T) => void;
	    onFocus?: (event?: FocusEvent) => void;
	    onBlur?: (event?: FocusEvent) => void;
	    /**
	     * Controls whether the options are shown. Default: false
	     */
	    isOpen?: boolean;
	    /**
	     * Optional props to pass to the underlying [EuiInputPopover](/#/layout/popover#popover-attached-to-input-element).
	     * Allows fine-grained control of the popover dropdown menu, including
	     * `repositionOnScroll` for EuiSuperSelects used within scrollable containers,
	     * and customizing popover panel styling.
	     *
	     * Does not accept a nested `popoverProps.isOpen` property - use the top level
	     * `isOpen` API instead.
	     */
	    popoverProps?: Partial<CommonProps & Omit<EuiInputPopoverProps, 'isOpen'>>;
	};
	export class EuiSuperSelect<T = string> extends Component<EuiSuperSelectProps<T>> {
	    static defaultProps: {
	        fullWidth: boolean;
	        compressed: boolean;
	        isInvalid: boolean;
	        isLoading: boolean;
	    };
	    private itemNodes;
	    private _isMounted;
	    private controlButtonRef;
	    describedById: string;
	    state: {
	        isPopoverOpen: boolean;
	        currentIndex: number;
	    };
	    componentDidMount(): void;
	    componentWillUnmount(): void;
	    setItemNode: (node: HTMLButtonElement | null, index: number) => void;
	    openPopover: () => void;
	    closePopover: () => void;
	    itemClicked: (value: T) => void;
	    onSelectKeyDown: (event: React.KeyboardEvent<HTMLButtonElement>) => void;
	    onItemKeyDown: (event: React.KeyboardEvent<HTMLButtonElement>) => void;
	    focusItemAt(index: number): void;
	    shiftFocus(direction: ShiftDirection): void;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/form/super_select' {
	export type { EuiSuperSelectProps } from '@elastic/eui/src/components/form/super_select/super_select';
	export { EuiSuperSelect } from '@elastic/eui/src/components/form/super_select/super_select';
	export type { EuiSuperSelectOption } from '@elastic/eui/src/components/form/super_select/super_select_item';
	export type { EuiSuperSelectControlProps } from '@elastic/eui/src/components/form/super_select/super_select_control';
	export { EuiSuperSelectControl } from '@elastic/eui/src/components/form/super_select/super_select_control';

}
declare module '@elastic/eui/src/components/color_picker/utils' {
	import chroma, { ColorSpaces } from 'chroma-js';
	import type { PaletteColorStop } from '@elastic/eui/src/components/color_picker/color_palette_picker';
	export const getEventPosition: (location: {
	    x: number;
	    y: number;
	}, container: HTMLElement) => {
	    left: number;
	    top: number;
	    width: number;
	    height: number;
	};
	export const HEX_FALLBACK = "";
	export const HSV_FALLBACK: ColorSpaces['hsv'];
	export const RGB_FALLBACK: ColorSpaces['rgba'];
	export const RGB_JOIN = ", ";
	export const parseColor: (input?: string | null) => string | number[] | null;
	export const chromaValid: (color: string | number[]) => boolean;
	export const getChromaColor: (input?: string | null, allowOpacity?: boolean) => chroma.Color | null;
	export const getLinearGradient: (palette: string[] | PaletteColorStop[]) => string;
	export const getFixedLinearGradient: (palette: string[] | PaletteColorStop[]) => {
	    color: string;
	    width: string;
	}[];

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_fixed.styles' {
	export const euiColorPaletteDisplayFixed__bleedArea: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_fixed' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiColorPaletteDisplayShared } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display';
	export interface EuiColorPaletteDisplayFixedProps extends HTMLAttributes<HTMLSpanElement>, CommonProps, EuiColorPaletteDisplayShared {
	}
	export const EuiColorPaletteDisplayFixed: FunctionComponent<EuiColorPaletteDisplayFixedProps>;

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_gradient' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiColorPaletteDisplayShared } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display';
	export interface EuiColorPaletteDisplayGradientProps extends HTMLAttributes<HTMLSpanElement>, CommonProps, EuiColorPaletteDisplayShared {
	}
	export const EuiColorPaletteDisplayGradient: FunctionComponent<EuiColorPaletteDisplayGradientProps>;

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiColorPaletteDisplayStyles: (euiThemeContext: UseEuiTheme) => {
	    euiColorPaletteDisplay: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display' {
	import { FunctionComponent } from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	import type { PaletteColorStop } from '@elastic/eui/src/components/color_picker/color_palette_picker';
	import { EuiColorPaletteDisplayFixedProps } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_fixed';
	import { EuiColorPaletteDisplayGradientProps } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_gradient';
	export const SIZES: readonly ["xs", "s", "m"];
	export type EuiColorPaletteDisplaySize = (typeof SIZES)[number];
	export interface EuiColorPaletteDisplayShared {
	    /**
	     * Array of color `strings` or an array of {@link PaletteColorStop}. The stops must be numbers in an ordered range.
	     */
	    palette: string[] | PaletteColorStop[];
	}
	interface DisplayGradient extends EuiColorPaletteDisplayGradientProps {
	    /**
	     *   Specify the type of palette.
	     *  `gradient`: each color fades into the next.
	     */
	    type: 'gradient';
	}
	interface DisplayFixed extends EuiColorPaletteDisplayFixedProps {
	    /**
	     *  `fixed`: individual color blocks.
	     */
	    type?: 'fixed';
	}
	export type EuiColorPaletteDisplayProps = {
	    /**
	     * Height of the palette display
	     */
	    size?: EuiColorPaletteDisplaySize;
	} & ExclusiveUnion<DisplayFixed, DisplayGradient>;
	export const EuiColorPaletteDisplay: FunctionComponent<EuiColorPaletteDisplayProps>;
	export {};

}
declare module '@elastic/eui/src/components/color_picker/color_palette_display' {
	export type { EuiColorPaletteDisplayProps } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display';
	export { EuiColorPaletteDisplay } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display';
	export type { EuiColorPaletteDisplayFixedProps } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_fixed';
	export { EuiColorPaletteDisplayFixed } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_fixed';
	export type { EuiColorPaletteDisplayGradientProps } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_gradient';
	export { EuiColorPaletteDisplayGradient } from '@elastic/eui/src/components/color_picker/color_palette_display/color_palette_display_gradient';

}
declare module '@elastic/eui/src/components/color_picker/color_palette_picker/color_palette_picker' {
	import { FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { type EuiSuperSelectProps } from '@elastic/eui/src/components/form/super_select';
	export interface PaletteColorStop {
	    stop: number;
	    color: string;
	}
	export interface EuiColorPalettePickerPaletteTextProps extends CommonProps {
	    /**
	     *  For storing unique value of item
	     */
	    value: string;
	    /**
	     *  The name of your palette
	     */
	    title: string;
	    /**
	     * Node appended to right of title - disallowed for text-only options
	     */
	    append?: never;
	    /**
	     * `text`: a text only option (a title is required).
	     */
	    type: 'text';
	    /**
	     * Array of color `strings` or an array of {@link PaletteColorStop}. The stops must be numbers in an ordered range.
	     */
	    palette?: string[] | PaletteColorStop[];
	}
	export interface EuiColorPalettePickerPaletteFixedProps extends CommonProps {
	    /**
	     *  For storing unique value of item
	     */
	    value: string;
	    /**
	     *  The name of your palette
	     */
	    title?: string;
	    /**
	     * Node appended to right of title
	     */
	    append?: ReactNode;
	    /**
	     * `fixed`: individual color blocks
	     */
	    type: 'fixed';
	    /**
	     * Array of color `strings` or an array of {@link PaletteColorStop}. The stops must be numbers in an ordered range.
	     */
	    palette: string[] | PaletteColorStop[];
	}
	export interface EuiColorPalettePickerPaletteGradientProps extends CommonProps {
	    /**
	     *  For storing unique value of item
	     */
	    value: string;
	    /**
	     *  The name of your palette
	     */
	    title?: string;
	    /**
	     * Node appended to right of title
	     */
	    append?: ReactNode;
	    /**
	     * `gradient`: each color fades into the next
	     */
	    type: 'gradient';
	    /**
	     * Array of color `strings` or an array of {@link PaletteColorStop}. The stops must be numbers in an ordered range.
	     */
	    palette: string[] | PaletteColorStop[];
	}
	export type EuiColorPalettePickerPaletteProps = EuiColorPalettePickerPaletteTextProps | EuiColorPalettePickerPaletteFixedProps | EuiColorPalettePickerPaletteGradientProps;
	export type EuiColorPalettePickerProps<T extends string> = CommonProps & Omit<EuiSuperSelectProps<T>, 'options' | 'itemLayoutAlign' | 'hasDividers'> & {
	    /**
	     *  Specify what should be displayed after a selection: a `palette` or `title`
	     */
	    selectionDisplay?: 'palette' | 'title';
	    /**
	     * An array of one of the following objects: {@link EuiColorPalettePickerPaletteText}, {@link EuiColorPalettePickerPaletteFixed}, {@link EuiColorPalettePickerPaletteGradient}
	     */
	    palettes: EuiColorPalettePickerPaletteProps[];
	};
	export const EuiColorPalettePicker: FunctionComponent<EuiColorPalettePickerProps<string>>;

}
declare module '@elastic/eui/src/components/color_picker/color_palette_picker' {
	export type { EuiColorPalettePickerProps, EuiColorPalettePickerPaletteTextProps, EuiColorPalettePickerPaletteFixedProps, EuiColorPalettePickerPaletteGradientProps, EuiColorPalettePickerPaletteProps, PaletteColorStop, } from '@elastic/eui/src/components/color_picker/color_palette_picker/color_palette_picker';
	export { EuiColorPalettePicker } from '@elastic/eui/src/components/color_picker/color_palette_picker/color_palette_picker';

}
declare module '@elastic/eui/src/services/color/stepped_gradient' {
	import { PaletteColorStop } from '@elastic/eui/src/components/color_picker/color_palette_picker';
	export const getSteppedGradient: (colors: PaletteColorStop[], steps: number) => string[];

}
declare module '@elastic/eui/src/services/color/manipulation' {
	import { EuiThemeColorModeStandard } from '@elastic/eui/src/services/theme';
	/**
	 * Makes a color more transparent.
	 * @param color - Color to manipulate
	 * @param alpha - alpha channel value. From 0-1.
	 */
	export const transparentize: (color: string, alpha: number) => string;
	/**
	 * Mixes a provided color with white.
	 * @param color - Color to mix with white
	 * @param ratio - Mix weight. From 0-1. Larger value indicates more white.
	 */
	export const tint: (color: string, ratio: number) => string;
	/**
	 * Mixes a provided color with black.
	 * @param color - Color to mix with black
	 * @param ratio - Mix weight. From 0-1. Larger value indicates more black.
	 */
	export const shade: (color: string, ratio: number) => string;
	/**
	 * Returns the tinted color for light mode and shaded color for dark mode
	 * @param color - Color to mix with white
	 * @param ratio - Mix weight. From 0-1. Larger value indicates more white.
	 * @param colorMode - Light or dark only
	 */
	export const tintOrShade: (color: string, ratio: number, colorMode: EuiThemeColorModeStandard) => string;
	/**
	 * Returns the shaded color for light mode and tinted color for dark mode
	 * @param color - Color to mix with white
	 * @param ratio - Mix weight. From 0-1. Larger value indicates more white.
	 * @param colorMode - Light or dark only
	 */
	export const shadeOrTint: (color: string, ratio: number, colorMode: EuiThemeColorModeStandard) => string;
	/**
	 * Increases the saturation of a color by manipulating the hsl saturation.
	 * @param color - Color to manipulate
	 * @param amount - Amount to change in absolute terms. 0-1.
	 */
	export const saturate: (color: string, amount: number) => string;
	/**
	 * Decreases the saturation of a color by manipulating the hsl saturation.
	 * @param color - Color to manipulate
	 * @param amount - Amount to change in absolute terms. 0-1.
	 */
	export const desaturate: (color: string, amount: number) => string;
	/**
	 * Returns the lightness value of a color. 0-100
	 * @param color
	 */
	export const lightness: (color: string) => number;
	/**
	 * Returns the darken value of a color. 0-100
	 * @param color - Color to manipulate
	 * @param amount - Amount to change in absolute terms. 0-1.
	 */
	export const darken: (color: string, amount: number) => string;
	/**
	 * Returns the brighten value of a color. 0-100
	 * @param color - Color to manipulate
	 * @param amount - Amount to change in absolute terms. 0-1.
	 */
	export const brighten: (color: string, amount: number) => string;

}
declare module '@elastic/eui/src/services/color/contrast' {
	export const getColorContrast: (textColor: string, backgroundColor: string) => number;
	export const wcagContrastMin = 4.5;
	/**
	 * Creates a new color that meets or exceeds WCAG level AA
	 * @param foreground - Color to manipulate
	 * @param ratio - Amount to change in absolute terms. 0-10.
	 * *
	 * @param themeOrBackground - Color to use as the contrast basis or just pass EuiTheme
	 */
	export const makeHighContrastColor: (_foreground: string, ratio?: number) => (themeOrBackground: string | {
	    colors: {
	        body: string;
	    };
	    [key: string]: any;
	}) => string;
	/**
	 * Creates a new color with increased contrast
	 * Disabled content only needs a contrast of at least 2 because there is no interaction available
	 * @param foreground - Color to manipulate
	 * @param ratio - Amount to change in absolute terms. 0-10.
	 * *
	 * @param themeOrBackground - Color to use as the contrast basis
	 */
	export const makeDisabledContrastColor: (color: string, ratio?: number) => (themeOrBackground: string | {
	    colors: {
	        body: string;
	    };
	    [key: string]: any;
	}) => string;
	export const warnIfContrastBelowMin: (textColor: string, backgroundColor: string, min?: number) => void;

}
declare module '@elastic/eui/src/services/color' {
	export { isColorDark } from '@elastic/eui/src/services/color/is_color_dark';
	export { isValidHex } from '@elastic/eui/src/services/color/is_valid_hex';
	export { hexToHsv } from '@elastic/eui/src/services/color/hex_to_hsv';
	export { hexToRgb } from '@elastic/eui/src/services/color/hex_to_rgb';
	export { hsvToHex } from '@elastic/eui/src/services/color/hsv_to_hex';
	export { hsvToRgb } from '@elastic/eui/src/services/color/hsv_to_rgb';
	export { rgbToHex } from '@elastic/eui/src/services/color/rgb_to_hex';
	export { rgbToHsv } from '@elastic/eui/src/services/color/rgb_to_hsv';
	export { calculateContrast, calculateLuminance, } from '@elastic/eui/src/services/color/luminance_and_contrast';
	export { VISUALIZATION_COLORS, DEFAULT_VISUALIZATION_COLOR, } from '@elastic/eui/src/services/color/visualization_colors';
	export { EUI_VIS_COLOR_STORE } from '@elastic/eui/src/services/color/vis_color_store';
	export { colorPalette } from '@elastic/eui/src/services/color/color_palette';
	export { euiPaletteColorBlind, euiPaletteColorBlindBehindText, euiPaletteForStatus, euiPaletteForTemperature, euiPaletteComplementary, euiPaletteRed, euiPaletteGreen, euiPaletteSkyBlue, euiPaletteYellow, euiPaletteOrange, euiPaletteCool, euiPaletteWarm, euiPaletteGray, type EuiPaletteColorBlindProps, type EuiPaletteRotationProps, type EuiPaletteCommonProps, } from '@elastic/eui/src/services/color/eui_palettes';
	export * from '@elastic/eui/src/services/color/eui_palettes_hooks';
	export type { rgbDef, HSV, RGB } from '@elastic/eui/src/services/color/color_types';
	export { getSteppedGradient } from '@elastic/eui/src/services/color/stepped_gradient';
	export * from '@elastic/eui/src/services/color/manipulation';
	export * from '@elastic/eui/src/services/color/contrast';

}
declare module '@elastic/eui/src/services/theme/provider' {
	import React, { PropsWithChildren, HTMLAttributes } from 'react';
	import type { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiThemeColorMode, EuiThemeHighContrastModeProp, EuiThemeSystem, EuiThemeModifications } from '@elastic/eui/src/services/theme/types';
	export interface EuiThemeProviderProps<T> extends PropsWithChildren {
	    theme?: EuiThemeSystem<T>;
	    colorMode?: EuiThemeColorMode;
	    highContrastMode?: EuiThemeHighContrastModeProp;
	    modify?: EuiThemeModifications<T>;
	    children: any;
	    /**
	     * Nested theme providers will receive a wrapping `span` tag in order to correctly
	     * set the default text `color` that all nested children will inherit.
	     *
	     * If an extra wrapper is not desired, pass `{ cloneElement: true }`.
	     * This requires a **single** child component that the correct color class can be passed to.
	     *
	     * The parent level `EuiProvider`/`EuiThemeProvider` will **not** render a wrapper element, as
	     * the default inherited text color will be set on the page `body`.
	     */
	    wrapperProps?: HTMLAttributes<HTMLElement> & CommonProps & {
	        cloneElement?: boolean;
	    };
	}
	export const EuiThemeProvider: <T extends {} = {}>({ theme: _system, colorMode: _colorMode, highContrastMode: _highContrastMode, modify: _modifications, children, wrapperProps, }: EuiThemeProviderProps<T>) => React.JSX.Element;

}
declare module '@elastic/eui/src/services/theme/theme_variant' {
	import { EuiThemeVariantFlags, UseEuiTheme } from '@elastic/eui-theme-common';
	export const isEuiThemeRefreshVariant: ({ euiTheme }: UseEuiTheme, flag: keyof EuiThemeVariantFlags) => boolean;
	/**
	 * Util to retrieve visual variant for UI elements
	 * Note: Temporary only - will be removed once the visual refresh is completed.
	 */
	export const useEuiThemeRefreshVariant: (flag: keyof EuiThemeVariantFlags) => boolean;

}
declare module '@elastic/eui/src/services/theme' {
	export { EuiSystemContext, EuiThemeContext, EuiNestedThemeContext, EuiModificationsContext, EuiColorModeContext, EuiHighContrastModeContext, } from '@elastic/eui/src/services/theme/context';
	export type { UseEuiTheme, WithEuiThemeProps } from '@elastic/eui/src/services/theme/hooks';
	export { useEuiTheme, withEuiTheme, RenderWithEuiTheme, useEuiThemeCSSVariables, useIsDarkMode, } from '@elastic/eui/src/services/theme/hooks';
	export type { EuiThemeProviderProps } from '@elastic/eui/src/services/theme/provider';
	export { EuiThemeProvider } from '@elastic/eui/src/services/theme/provider';
	export { useEuiMemoizedStyles, withEuiStylesMemoizer, type WithEuiStylesMemoizerProps, RenderWithEuiStylesMemoizer, } from '@elastic/eui/src/services/theme/style_memoization';
	export { getEuiDevProviderWarning, setEuiDevProviderWarning } from '@elastic/eui/src/services/theme/warning';
	export { buildTheme, computed, isInverseColorMode, getColorMode, getComputed, getOn, mergeDeep, setOn, Computed, } from '@elastic/eui/src/services/theme/utils';
	export type { ComputedThemeShape, EuiThemeColorMode, EuiThemeColorModeStandard, EuiThemeHighContrastMode, EuiThemeHighContrastModeProp, EuiThemeComputed, EuiThemeModifications, EuiThemeShape, EuiThemeSystem, } from '@elastic/eui/src/services/theme/types';
	export { COLOR_MODES_STANDARD } from '@elastic/eui/src/services/theme/types';
	export * from '@elastic/eui/src/services/theme/theme_variant';

}
declare module '@elastic/eui/src/services/breakpoint/is_within_hooks' {
	import { _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling/variables/breakpoint';
	/**
	 * Given an array of breakpoint keys, this hook returns true or false
	 * if the breakpoint size of the current window width falls within
	 * any of the named breakpoints.
	 *
	 * @param {EuiThemeBreakpoint[]} sizes An array of named EUI breakpoints
	 * @param {boolean} isResponsive Some components have the option to turn off responsive behavior.
	 *   Since hooks can't be called conditionally, it's easier to pass the condition into the hook
	 * @returns {boolean} Returns `true` if current breakpoint name is included in `sizes`
	 */
	export const useIsWithinBreakpoints: (sizes: _EuiThemeBreakpoint[], isResponsive?: boolean) => boolean;
	/**
	 * Given a max breakpoint key, this hook returns true if the breakpoint size
	 * of the current window width falls within the max breakpoint or any below,
	 * and false otherwise
	 *
	 * @param {EuiThemeBreakpoint} max The named max breakpoint to check against
	 * @returns {boolean} Will return `false` if it can't find a value for the `max` breakpoint
	 */
	export function useIsWithinMaxBreakpoint(max: _EuiThemeBreakpoint): boolean;
	/**
	 * Given a min breakpoint key, this hook returns true if the breakpoint size
	 * of the current window width falls within the min breakpoint or any above,
	 * and false otherwise
	 *
	 * @param {EuiThemeBreakpoint} min The named min breakpoint to check against
	 * @returns {boolean} Will return `false` if it can't find a value for the `min` breakpoint
	 */
	export function useIsWithinMinBreakpoint(min: _EuiThemeBreakpoint): boolean;

}
declare module '@elastic/eui/src/services/breakpoint' {
	export type { _EuiThemeBreakpoint as EuiBreakpointSize } from '@elastic/eui/src/global_styling/variables/breakpoint';
	export * from '@elastic/eui/src/services/breakpoint/current_breakpoint';
	export * from '@elastic/eui/src/services/breakpoint/current_breakpoint_hook';
	export * from '@elastic/eui/src/services/breakpoint/is_within_hooks';

}
declare module '@elastic/eui/src/services/color_picker/color_picker' {
	interface colorStopsType {
	    stop: number;
	    color: string;
	}
	/**
	 * @deprecated
	 */
	export const useColorStopsState: (useRandomColor?: boolean, initialColorStops?: colorStopsType[]) => (string | colorStopsType[] | ((colorStops: colorStopsType[]) => void))[];
	export type EuiSetColorMethod = (text: string, { hex, isValid }: {
	    hex: string;
	    isValid: boolean;
	}) => void;
	export const useColorPickerState: (initialColor?: string) => [color: string, setColor: EuiSetColorMethod, errors: string[] | null];
	export {};

}
declare module '@elastic/eui/src/services/color_picker' {
	export type { EuiSetColorMethod } from '@elastic/eui/src/services/color_picker/color_picker';
	export { useColorPickerState, useColorStopsState } from '@elastic/eui/src/services/color_picker/color_picker';

}
declare module '@elastic/eui/src/services/console/warn_once' {
	export const warnOnce: (id: string, message: string) => void;

}
declare module '@elastic/eui/src/services/console' {
	export * from '@elastic/eui/src/services/console/warn_once';

}
declare module '@elastic/eui/src/services/container_query/match_container' {
	/**
	 * Listen for changes on a container query.
	 * Just like `window.matchMedia`.
	 *
	 * @example
	 * ```js
	 * const cql = matchContainer(element, '(width > 42rem)');
	 * cql.addEventListener('change', ({ matches }) {
	 *   // ..
	 * })
	 * ```
	 *
	 * @param element
	 * @param containerQueryString e.g. (width > 42rem)
	 * @returns ContainerQueryList
	 */
	export function matchContainer(element: HTMLElement, containerQueryString: string): ContainerQueryList;
	/**
	 * `change` event dispatched by instances of {@link ContainerQueryList}
	 * whenever the value of `matches` changes
	 */
	export class ContainerQueryListChangeEvent extends Event {
	    /** Whether the container query matches */
	    readonly matches: boolean;
	    /** A string representation of the container query list e.g. "(width > 1000px)" */
	    readonly container: string;
	    constructor(matches: boolean, container: string);
	}
	/**
	 * A hacky implementation of a possible native `ContainerQueryList`
	 * based on the teetotum/match-container polyfill:
	 * - based on a API proposal in W3C CSS WG {@link https://github.com/w3c/csswg-drafts/issues/6205})
	 * - mimicking MediaQueryList {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryList}
	 *
	 * Not meant to be used directly, but rather call `matchContainer`.
	 *
	 * It works by listening on a `transitionrun` event on the element,
	 * that gets triggered by a container query changing a custom property.
	 * Setting `transition-behavior: allow-discrete` is what makes it possible
	 * to have a CSS `transition` for a custom property.
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/transition-behavior}
	 */
	export class ContainerQueryList extends EventTarget {
	    #private;
	    private element;
	    private styleSheet;
	    private markerAttributeName;
	    private sentinelPropertyName;
	    private computedStyle;
	    private transitionRunListener;
	    /** Whether the container query matches */
	    get matches(): boolean;
	    /**
	     * A string representation of the container query list e.g. "(width > 1000px)"
	     * (the name is weird but it is so for consistency with mediaQueryList.media)
	     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaQueryList/media}
	     * */
	    readonly container: string;
	    constructor(element: HTMLElement, containerQueryString: string);
	    /**
	     * The marker attribute is `data-container-query-observer-{UUID}`,
	     * it will be used as a selector in the container query,
	     * in the global CSS that's being added below.
	     */
	    private applyMarkerAttribute;
	    /**
	     * Create a CSS custom property with values either `--true` or `--false`,
	     * and add container query targetting the element.
	     * Whenever the container query matches, the custom property will be `--true`.
	     * This styles are added globaly via `document.adoptedStyleSheets`.
	     */
	    private createStyleSheet;
	    /**
	     * This is the key to the hack:
	     * - a `transition` style is added for the custom property
	     * - the `transitionrun` event will fire whenever the custom property value changes
	     *   because of the container query
	     * - we get the value from computed styles
	     * - the `matches` value is updated and
	     * - a ContainerQueryListChangeEvent event is dispatched
	     */
	    private setupTransitionListener;
	    dispose(): void;
	}

}
declare module '@elastic/eui/src/services/container_query/container_query_hook' {
	/**
	 * React hook that subscribes to CSS container query changes.
	 *
	 * For this to work:
	 * - a proper container (an element with e.g. `container-type: inline-size`) is needed, and
	 * - the container MUST to be a parent of the element being observed
	 *
	 * @param containerCondition - A CSS `<container-condition>` string, e.g. `(width > 400px)` or `(min-width: 600px)`
	 * @param name - Optional container name, e.g. `sidebar`
	 * @returns An object containing:
	 *   - `ref`: A ref to attach to the container element
	 *   - `matches`: `true` if the container matches the condition, `false` otherwise
	 *
	 * @example
	 * ```tsx
	 * const { ref, matches } = useEuiContainerQuery('(width > 400px)');
	 * return <div ref={ref}>{matches ? 'Wide' : 'Narrow'}</div>;
	 * ```
	 *
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@container | MDN: @container}
	 * @beta
	 */
	export function useEuiContainerQuery<T extends HTMLElement = HTMLElement>(containerCondition: string, name?: string): {
	    ref: import("react").MutableRefObject<T | null>;
	    matches: boolean;
	};

}
declare module '@elastic/eui/src/services/copy/copy_to_clipboard' {
	export function copyToClipboard(text: string): boolean;

}
declare module '@elastic/eui/src/services/copy/tabular_copy' {
	import React, { PropsWithChildren } from 'react';
	/**
	 * Clipboard text cleaning logic
	 */
	export const CHARS: {
	    NEWLINE: string;
	    TAB: string;
	    TABULAR_CONTENT_BOUND: string;
	    NO_COPY_BOUND: string;
	};
	export const noCopyBoundsRegex: RegExp;
	export const onTabularCopy: (event: ClipboardEvent | React.ClipboardEvent) => void;
	export const tabularCopyMarkers: {
	    hiddenTab: React.JSX.Element;
	    hiddenNewline: React.JSX.Element;
	    hiddenWrapperBoundary: React.JSX.Element;
	    hiddenNoCopyBoundary: React.JSX.Element;
	};
	/**
	 * Wrapper setup around table/grid tabular content we want to override/clean up on copy
	 */
	export const OverrideCopiedTabularContent: ({ children, }: PropsWithChildren) => React.JSX.Element;

}
declare module '@elastic/eui/src/services/copy' {
	export { copyToClipboard } from '@elastic/eui/src/services/copy/copy_to_clipboard';
	export { tabularCopyMarkers, noCopyBoundsRegex, OverrideCopiedTabularContent, } from '@elastic/eui/src/services/copy/tabular_copy';

}
declare module '@elastic/eui/src/services/findElement' {
	/**
	 * A DOM node, a selector string (which will be passed to
	 * `document.querySelector()` to find the DOM node), or a function that
	 * returns a DOM node.
	 */
	export type ElementTarget = HTMLElement | string | (() => HTMLElement);
	export const findElementBySelectorOrRef: (elementTarget?: ElementTarget) => HTMLElement | null;

}
declare module '@elastic/eui/src/services/focus_trap/focus_trap_pub_sub' {
	type Listener = () => void;
	/**
	 * A lightweight, global PubSub service for loose coupling of components
	 * that need to interact with the same focus trap.
	 *
	 * This allows a component (like `EuiPopover`) to be rendered in a React Portal
	 * and still be included in the focus trap of another component (like `EuiFlyout`)
	 * without either component needing a direct reference to the other.
	 *
	 * How it works:
	 *
	 * 1. A container component (e.g., `EuiFlyout`) `subscribe`s to this service on mount.
	 * 2. An ephemeral component (e.g., `EuiPopover`) calls `publish` when its state
	 *    changes in a way that affects the DOM (e.g., opening, closing, unmounting).
	 * 3. The container component's subscribed callback fires, causing it to re-query
	 *    the DOM for any elements it should include in its focus trap.
	 */
	export const focusTrapPubSub: {
	    subscribe: (listener: Listener) => () => void;
	    unsubscribe: (listener: Listener) => void;
	    publish: () => void;
	};
	export {};

}
declare module '@elastic/eui/src/services/focus_trap' {
	export { focusTrapPubSub } from '@elastic/eui/src/services/focus_trap/focus_trap_pub_sub';

}
declare module '@elastic/eui/src/services/format/format_boolean' {
	export const formatBoolean: (value: boolean, { yes, no, nil }?: {
	    yes?: string | undefined;
	    no?: string | undefined;
	    nil?: string | undefined;
	}) => string;

}
declare module '@elastic/eui/src/services/format/format_date' {
	import moment from 'moment';
	type CalendarOptions = moment.CalendarSpec & {
	    refTime?: moment.MomentInput;
	};
	export const dateFormatAliases: {
	    date: string;
	    longDate: string;
	    shortDate: string;
	    dateTime: string;
	    longDateTime: string;
	    shortDateTime: string;
	    dobShort: string;
	    dobLong: string;
	    iso8601: string;
	    calendar: (value: moment.MomentInput, options?: CalendarOptions) => string;
	    calendarDateTime: (value: moment.MomentInput, options: moment.CalendarSpec) => string;
	    calendarDate: (value: moment.MomentInput, options: moment.CalendarSpec) => string;
	};
	type DateFormat = keyof typeof dateFormatAliases;
	interface FormatDateConfig {
	    format: DateFormat;
	    nil: string;
	    options: any;
	}
	export const formatDate: (value?: moment.MomentInput, dateFormatKeyOrConfig?: DateFormat | string | Partial<FormatDateConfig>) => string;
	export {};

}
declare module '@elastic/eui/src/services/format/format_number' {
	interface FormatNumberConfig {
	    format: string;
	    nil: string;
	    round: boolean;
	}
	export const formatNumber: (value?: number | null, numberFormatOrConfig?: string | Partial<FormatNumberConfig>) => string;
	export {};

}
declare module '@elastic/eui/src/services/format/format_text' {
	interface FormatTextOptions {
	    nil: string;
	}
	export const formatText: (value?: any, options?: Partial<FormatTextOptions>) => any;
	export {};

}
declare module '@elastic/eui/src/services/format/format_auto' {
	export const formatAuto: (value: any) => string;

}
declare module '@elastic/eui/src/services/format' {
	export { formatAuto } from '@elastic/eui/src/services/format/format_auto';
	export { formatBoolean } from '@elastic/eui/src/services/format/format_boolean';
	export { formatDate, dateFormatAliases } from '@elastic/eui/src/services/format/format_date';
	export { formatNumber } from '@elastic/eui/src/services/format/format_number';
	export { formatText } from '@elastic/eui/src/services/format/format_text';

}
declare module '@elastic/eui/src/services/paging/pager' {
	export class Pager {
	    currentPageIndex: number;
	    firstItemIndex: number;
	    itemsPerPage: number;
	    lastItemIndex: number;
	    totalItems: number;
	    totalPages: number;
	    constructor(totalItems: number, itemsPerPage: number, initialPageIndex?: number);
	    setTotalItems: (totalItems: number) => void;
	    setItemsPerPage: (itemsPerPage: number) => void;
	    isPageable: () => boolean;
	    getTotalPages: () => number;
	    getCurrentPageIndex: () => number;
	    getFirstItemIndex: () => number;
	    getLastItemIndex: () => number;
	    hasNextPage: () => boolean;
	    hasPreviousPage: () => boolean;
	    goToNextPage: () => void;
	    goToPreviousPage: () => void;
	    goToPageIndex: (pageIndex: number) => void;
	    update: () => void;
	}

}
declare module '@elastic/eui/src/services/paging' {
	export { Pager } from '@elastic/eui/src/services/paging/pager';

}
declare module '@elastic/eui/src/services/security/get_secure_rel_for_target' {
	/**
	 * Secures outbound links. For more info:
	 * https://www.jitbit.com/alexblog/256-targetblank---the-most-underestimated-vulnerability-ever/
	 */
	export const getSecureRelForTarget: ({ target, rel, }: {
	    href?: string;
	    target?: "_blank" | "_self" | "_parent" | "_top" | string;
	    rel?: string;
	}) => string;

}
declare module '@elastic/eui/src/services/security' {
	export { getSecureRelForTarget } from '@elastic/eui/src/services/security/get_secure_rel_for_target';

}
declare module '@elastic/eui/src/services/sort/sortable_properties' {
	import { Primitive } from '@elastic/eui/src/services/sort/comparators';
	export interface SortableProperty<T> {
	    name: string;
	    getValue: (obj: T) => Primitive;
	    isAscending: boolean;
	}
	/**
	 * @typedef {Object} SortableProperty
	 * @property {string} sortableProperty.name - Name of the property.
	 * @property {function} sortableProperty.getValue - A function that takes in an object and returns a value to sort
	 * by.
	 * @property {boolean} sortableProperty.isAscending - The direction of the last sort by this property. Used to preserve
	 * past sort orders.
	 */
	/**
	 * Stores sort information for a set of SortableProperties, including which property is currently being sorted on, as
	 * well as the last sort order for each property.
	 */
	export class SortableProperties<T> {
	    sortableProperties: Array<SortableProperty<T>>;
	    currentSortedProperty: SortableProperty<T>;
	    /**
	     * @param {Array<SortableProperty>} sortableProperties - a set of sortable properties.
	     * @param {string} initialSortablePropertyName - Which sort property should be sorted on by default.
	     */
	    constructor(sortableProperties: Array<SortableProperty<T>>, initialSortablePropertyName: string);
	    /**
	     * @returns {SortableProperty} The current property that is being sorted on. Undefined if no sort order is applied.
	     */
	    getSortedProperty(): SortableProperty<T>;
	    /**
	     * Sorts the items passed in and returns a newly sorted array.
	     * @param items {Array.<Object>}
	     * @returns {Array.<Object>} sorted array of items, based off the sort properties.
	     */
	    sortItems(items: T[]): T[];
	    /**
	     * Returns the SortProperty with the given name, if found.
	     * @param {String} propertyName
	     * @returns {SortableProperty|undefined}
	     */
	    getSortablePropertyByName(propertyName: string): SortableProperty<T> | undefined;
	    /**
	     * Updates the sort property, potentially flipping the sort order based on whether the same
	     * property was already being sorted.
	     * @param propertyName {String}
	     */
	    sortOn(propertyName: string): void;
	    /**
	     * @returns {boolean} True if the current sortable property is sorted in ascending order.
	     */
	    isCurrentSortAscending(): boolean;
	    /**
	     * @param {string} propertyName
	     * @returns {boolean} True if the given sort property is sorted in ascending order.
	     */
	    isAscendingByName(propertyName: string): boolean;
	    /**
	     * Flips the current sorted property sort order.
	     */
	    flipCurrentSortOrder(): void;
	}

}
declare module '@elastic/eui/src/services/sort/property_sort' {
	import PropTypes from 'prop-types';
	import { Direction } from '@elastic/eui/src/services/sort/sort_direction';
	export const PropertySortType: PropTypes.Requireable<PropTypes.InferProps<{
	    field: PropTypes.Validator<string>;
	    direction: PropTypes.Validator<NonNullable<"desc" | "asc">>;
	}>>;
	export interface PropertySort {
	    field: string;
	    direction: Direction;
	}

}
declare module '@elastic/eui/src/services/sort' {
	export { SortableProperties } from '@elastic/eui/src/services/sort/sortable_properties';
	export type { Direction } from '@elastic/eui/src/services/sort/sort_direction';
	export { SortDirectionType, SortDirection } from '@elastic/eui/src/services/sort/sort_direction';
	export type { PropertySort } from '@elastic/eui/src/services/sort/property_sort';
	export { PropertySortType } from '@elastic/eui/src/services/sort/property_sort';
	export { Comparators } from '@elastic/eui/src/services/sort/comparators';

}
declare module '@elastic/eui/src/services/string/to_initials' {
	export const MAX_INITIALS = 2;
	/**
	 * This function calculates the initials/acronym for a given name.
	 * It defaults to only 2 characters and will take the first character (of each word).
	 * If only one word is supplied for the name, it will only pass back the first letter of the word,
	 * unless forced to 2 letters by setting `initialsLength` to `2`.
	 * It will pass back the characters with the same casing as the original string
	 * unless otherwise specified.
	 *
	 * @param {string} name The full name of the item to turn into initials
	 * @param {number} initialsLength (Optional) How many characters to show (max 2 allowed)
	 * @param {string} initials (Optional) Custom initials (max 2 characters)
	 */
	export function toInitials(name: string, initialsLength?: 1 | 2, initials?: string): string;

}
declare module '@elastic/eui/src/services/string/to_case' {
	/**
	 * This function returns the same string with the first letter of the first word capitalized.
	 *
	 * @param {string} string The input string
	 */
	export function toSentenceCase(string: string): string;

}
declare module '@elastic/eui/src/services/string/slugify' {
	/**
	 * Lowercases input and replaces spaces with hyphens:
	 * e.g. 'GridView Example' -> 'gridview-example'
	 *
	 * @param {string} string The starting string
	 * @returns {string} Lowercase, dashed version of the starting staring
	 */
	export function slugify(str: string): string;

}
declare module '@elastic/eui/src/services/string' {
	export { toInitials } from '@elastic/eui/src/services/string/to_initials';
	export { toSentenceCase } from '@elastic/eui/src/services/string/to_case';
	export { slugify } from '@elastic/eui/src/services/string/slugify';

}
declare module '@elastic/eui/src/services/transition/transition' {
	export const getTransitionTimings: (element: Element) => {
	    durationMatch: number;
	    delayMatch: number;
	};
	export const getWaitDuration: (records: MutationRecord[]) => number;
	export const performOnFrame: (waitDuration: number, toPerform: () => void) => void;
	export const getDurationAndPerformOnFrame: (records: MutationRecord[], toPerform: () => void) => void;

}
declare module '@elastic/eui/src/services/transition' {
	export { getDurationAndPerformOnFrame, getTransitionTimings, getWaitDuration, performOnFrame, } from '@elastic/eui/src/services/transition/transition';

}
declare module '@elastic/eui/src/services/window_event/hooks' {
	type EuiEventHandler<EventName extends keyof WindowEventMap> = (this: Window, event: WindowEventMap[EventName]) => any;
	export const useEuiWindowEvent: <EventName extends keyof WindowEventMap>(event: EventName, handler: EuiEventHandler<EventName>) => null;
	export {};

}
declare module '@elastic/eui/src/services/window_event/window_event' {
	type EventNames = keyof WindowEventMap;
	interface Props<Ev extends EventNames> {
	    event: Ev;
	    handler: (this: Window, ev: WindowEventMap[Ev]) => any;
	}
	export const EuiWindowEvent: <E extends EventNames>({ event, handler, }: Props<E>) => null;
	export {};

}
declare module '@elastic/eui/src/services/window_event' {
	export { EuiWindowEvent } from '@elastic/eui/src/services/window_event/window_event';
	export { useEuiWindowEvent } from '@elastic/eui/src/services/window_event/hooks';

}
declare module '@elastic/eui/src/services' {
	import * as keys from '@elastic/eui/src/services/keys';
	export { htmlIdGenerator, useGeneratedHtmlId } from '@elastic/eui/src/services/accessibility';
	export { CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT } from '@elastic/eui/src/services/alignment';
	export type { HorizontalAlignment } from '@elastic/eui/src/services/alignment';
	export { CurrentEuiBreakpointContext, CurrentEuiBreakpointProvider, useCurrentEuiBreakpoint, useIsWithinBreakpoints, useIsWithinMaxBreakpoint, useIsWithinMinBreakpoint, } from '@elastic/eui/src/services/breakpoint';
	export type { EuiBreakpointSize } from '@elastic/eui/src/services/breakpoint';
	export { CanvasTextUtils, type CanvasTextParams } from '@elastic/eui/src/services/canvas';
	export { brighten, calculateContrast, calculateLuminance, colorPalette, darken, DEFAULT_VISUALIZATION_COLOR, desaturate, euiPaletteColorBlind, euiPaletteColorBlindBehindText, euiPaletteComplementary, euiPaletteCool, euiPaletteForStatus, euiPaletteForTemperature, euiPaletteGray, euiPaletteRed, euiPaletteGreen, euiPaletteSkyBlue, euiPaletteYellow, euiPaletteOrange, euiPaletteWarm, getSteppedGradient, hexToHsv, hexToRgb, hsvToHex, hsvToRgb, isColorDark, isValidHex, lightness, makeDisabledContrastColor, makeHighContrastColor, rgbToHex, rgbToHsv, saturate, shade, shadeOrTint, tint, tintOrShade, transparentize, VISUALIZATION_COLORS, EUI_VIS_COLOR_STORE, wcagContrastMin, type EuiPaletteColorBlindProps, type EuiPaletteRotationProps, type EuiPaletteCommonProps, } from '@elastic/eui/src/services/color';
	export type { HSV } from '@elastic/eui/src/services/color';
	export * from '@elastic/eui/src/services/color/eui_palettes_hooks';
	export { useColorPickerState, useColorStopsState } from '@elastic/eui/src/services/color_picker';
	export type { EuiSetColorMethod } from '@elastic/eui/src/services/color_picker';
	export * from '@elastic/eui/src/services/console';
	export { useEuiContainerQuery } from '@elastic/eui/src/services/container_query/container_query_hook';
	export * from '@elastic/eui/src/services/copy';
	export * from '@elastic/eui/src/services/emotion';
	export * from '@elastic/eui/src/services/findElement';
	export { focusTrapPubSub } from '@elastic/eui/src/services/focus_trap';
	export { dateFormatAliases, formatAuto, formatBoolean, formatDate, formatNumber, formatText, } from '@elastic/eui/src/services/format';
	export { useDependentState, useCombinedRefs, setMultipleRefs, useForceRender, useLatest, useDeepEqual, isMouseEvent, useMouseMove, useUpdateEffect, useEuiDisabledElement, type EuiDisabledProps, } from '@elastic/eui/src/services/hooks';
	export { isEvenlyDivisibleBy, isWithinRange } from '@elastic/eui/src/services/number';
	export { Pager } from '@elastic/eui/src/services/paging';
	export { calculatePopoverPosition, findPopoverPosition } from '@elastic/eui/src/services/popover';
	export { getSecureRelForTarget } from '@elastic/eui/src/services/security';
	export { Comparators, PropertySortType, SortableProperties, SortDirection, SortDirectionType, } from '@elastic/eui/src/services/sort';
	export type { Direction, PropertySort } from '@elastic/eui/src/services/sort';
	export { slugify, toInitials, toSentenceCase } from '@elastic/eui/src/services/string';
	export * from '@elastic/eui/src/services/theme';
	export { throttle } from '@elastic/eui/src/services/throttle';
	export { getDurationAndPerformOnFrame, getTransitionTimings, getWaitDuration, performOnFrame, } from '@elastic/eui/src/services/transition';
	export { EuiWindowEvent, useEuiWindowEvent } from '@elastic/eui/src/services/window_event';
	export { keys };

}
declare module '@elastic/eui/src/components/accessibility/screen_reader_only/screen_reader_only' {
	import { ReactElement, FunctionComponent } from 'react';
	export interface EuiScreenReaderOnlyProps {
	    /**
	     * ReactElement to render as this component's content
	     */
	    children: ReactElement;
	    /**
	     * For keyboard navigation, force content to display visually upon focus/focus-within.
	     */
	    showOnFocus?: boolean;
	    className?: string;
	}
	export const EuiScreenReaderOnly: FunctionComponent<EuiScreenReaderOnlyProps>;

}
declare module '@elastic/eui/src/components/accessibility/screen_reader_only' {
	export type { EuiScreenReaderOnlyProps } from '@elastic/eui/src/components/accessibility/screen_reader_only/screen_reader_only';
	export { EuiScreenReaderOnly } from '@elastic/eui/src/components/accessibility/screen_reader_only/screen_reader_only';
	export { euiScreenReaderOnly } from '@elastic/eui/src/components/accessibility/screen_reader_only/screen_reader_only.styles';

}
declare module '@elastic/eui/src/components/accessibility/screen_reader_live/screen_reader_live' {
	import { AriaAttributes, HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	export interface EuiScreenReaderLiveProps {
	    /**
	     * Whether to make screen readers aware of the content
	     */
	    isActive?: boolean;
	    /**
	     * Content for screen readers to announce
	     */
	    children?: ReactNode;
	    /**
	     * `role` attribute for both live regions.
	     *
	     * https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions#roles_with_implicit_live_region_attributes
	     *
	     * @default 'status'
	     */
	    role?: HTMLAttributes<HTMLDivElement>['role'];
	    /**
	     * `aria-live` attribute for both live regions
	     *
	     * @default 'polite'
	     */
	    'aria-live'?: AriaAttributes['aria-live'];
	    /**
	     * On `children`/text change, the region will auto-focus itself, causing screen readers
	     * to automatically read out the text content. This prop should primarily be used for
	     * navigation or page changes, where programmatically resetting focus location back to
	     * a certain part of the page is desired.
	     *
	     * @default false
	     */
	    focusRegionOnTextChange?: boolean;
	}
	export const EuiScreenReaderLive: FunctionComponent<EuiScreenReaderLiveProps>;

}
declare module '@elastic/eui/src/components/accessibility/screen_reader_live' {
	export { EuiScreenReaderLive } from '@elastic/eui/src/components/accessibility/screen_reader_live/screen_reader_live';
	export type { EuiScreenReaderLiveProps } from '@elastic/eui/src/components/accessibility/screen_reader_live/screen_reader_live';

}
declare module '@elastic/eui/src/components/accessibility/skip_link/skip_link.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSkipLinkStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiSkipLink: import("@emotion/react").SerializedStyles;
	    absolute: import("@emotion/react").SerializedStyles;
	    fixed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/accessibility/skip_link/skip_link' {
	import { FunctionComponent, Ref } from 'react';
	import { EuiButtonProps } from '@elastic/eui/src/components/button/button';
	import { PropsForAnchor } from '@elastic/eui/src/components/common';
	export const POSITIONS: readonly ["static", "fixed", "absolute"];
	type Positions = (typeof POSITIONS)[number];
	interface EuiSkipLinkInterface extends EuiButtonProps {
	    /**
	     * Change the display position of the element when focused.
	     * If 'fixed', the link will be fixed to the top left of the viewport
	     */
	    position?: Positions;
	    /**
	     * Typically an anchor id (e.g. `a11yMainContent`), the value provided
	     * will be prepended with a hash `#` and used as the link `href`
	     */
	    destinationId: string;
	    /**
	     * If no destination ID element exists or can be found, you may provide a query selector
	     * string to fall back to.
	     *
	     * For complex applications with potentially variable layouts per page, an array of
	     * query selectors can be passed, e.g. `['main', '[role=main]', '.appWrapper']`, which
	     * prioritizes looking for multiple fallbacks based on array order.
	     * @default main
	     */
	    fallbackDestination?: string | string[];
	    /**
	     * If default HTML anchor link behavior is not desired (e.g. for SPAs with hash routing),
	     * setting this flag to true will manually scroll to and focus the destination element
	     * without changing the browser URL's hash
	     */
	    overrideLinkBehavior?: boolean;
	    /**
	     * When position is fixed, this is forced to `0`
	     */
	    tabIndex?: number;
	}
	export type EuiSkipLinkProps = PropsForAnchor<EuiSkipLinkInterface, {
	    buttonRef?: Ref<HTMLAnchorElement>;
	}>;
	export const EuiSkipLink: FunctionComponent<EuiSkipLinkProps>;
	export {};

}
declare module '@elastic/eui/src/components/accessibility/skip_link' {
	export type { EuiSkipLinkProps } from '@elastic/eui/src/components/accessibility/skip_link/skip_link';
	export { EuiSkipLink } from '@elastic/eui/src/components/accessibility/skip_link/skip_link';

}
declare module '@elastic/eui/src/components/accessibility' {
	export { EuiScreenReaderLive } from '@elastic/eui/src/components/accessibility/screen_reader_live';
	export type { EuiScreenReaderLiveProps } from '@elastic/eui/src/components/accessibility/screen_reader_live';
	export { EuiScreenReaderOnly, euiScreenReaderOnly } from '@elastic/eui/src/components/accessibility/screen_reader_only';
	export type { EuiScreenReaderOnlyProps } from '@elastic/eui/src/components/accessibility/screen_reader_only';
	export { EuiSkipLink } from '@elastic/eui/src/components/accessibility/skip_link';
	export type { EuiSkipLinkProps } from '@elastic/eui/src/components/accessibility/skip_link';
	export { type EuiLiveAnnouncerProps, EuiLiveAnnouncer } from '@elastic/eui/src/components/accessibility/live_announcer';

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger/accordion_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAccordionButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiAccordion__button: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    arrowLeft: import("@emotion/react").SerializedStyles;
	    arrowRight: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger/accordion_button' {
	import { FunctionComponent, PropsWithChildren, HTMLAttributes } from 'react';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	type _EuiAccordionButtonProps = PropsWithChildren & HTMLAttributes<HTMLElement> & Required<Pick<EuiAccordionProps, 'buttonElement'>> & Pick<EuiAccordionProps, 'buttonClassName' | 'buttonProps' | 'buttonContentClassName' | 'isDisabled' | 'arrowDisplay'>;
	export const EuiAccordionButton: FunctionComponent<_EuiAccordionButtonProps>;
	export {};

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger/accordion_arrow.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAccordionArrowStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiAccordion__arrow: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    isClosed: import("@emotion/react").SerializedStyles;
	    isOpen: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger/accordion_arrow' {
	import { FunctionComponent } from 'react';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	type _EuiAccordionArrowProps = Partial<EuiButtonIconPropsForButton> & Pick<EuiAccordionProps, 'arrowDisplay' | 'arrowProps'> & {
	    isOpen: boolean;
	};
	export const EuiAccordionArrow: FunctionComponent<_EuiAccordionArrowProps>;
	export {};

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger/accordion_trigger' {
	import { FunctionComponent, MouseEventHandler } from 'react';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	type _EuiAccordionTriggerProps = Pick<EuiAccordionProps, 'arrowDisplay' | 'arrowProps' | 'buttonElement' | 'buttonClassName' | 'buttonProps' | 'buttonContent' | 'buttonContentClassName' | 'extraAction' | 'isDisabled'> & {
	    isOpen: boolean;
	    ariaControlsId: string;
	    buttonId: string;
	    onToggle: MouseEventHandler;
	};
	export const EuiAccordionTrigger: FunctionComponent<_EuiAccordionTriggerProps>;
	export {};

}
declare module '@elastic/eui/src/components/accordion/accordion_trigger' {
	export { EuiAccordionTrigger } from '@elastic/eui/src/components/accordion/accordion_trigger/accordion_trigger';

}
declare module '@elastic/eui/src/components/accordion/accordion_children/accordion_children_loading' {
	import { FunctionComponent } from 'react';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	type _EuiAccordionChildrenLoadingProps = Pick<EuiAccordionProps, 'isLoadingMessage'>;
	export const EuiAccordionChildrenLoading: FunctionComponent<_EuiAccordionChildrenLoadingProps>;
	export {};

}
declare module '@elastic/eui/src/components/accordion/accordion_children/accordion_children.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAccordionChildrenStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiAccordion__children: import("@emotion/react").SerializedStyles;
	    isLoading: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};
	export const euiAccordionChildWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiAccordion__childWrapper: import("@emotion/react").SerializedStyles;
	    noTransition: import("@emotion/react").SerializedStyles;
	    isClosed: import("@emotion/react").SerializedStyles;
	    isOpen: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/accordion/accordion_children/accordion_children' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	type _EuiAccordionChildrenProps = HTMLAttributes<HTMLDivElement> & Pick<EuiAccordionProps, 'role' | 'children' | 'paddingSize' | 'initialIsOpen' | 'isLoading' | 'isLoadingMessage'> & {
	    isOpen: boolean;
	};
	export const EuiAccordionChildren: FunctionComponent<_EuiAccordionChildrenProps>;
	export {};

}
declare module '@elastic/eui/src/components/accordion/accordion_children' {
	export { EuiAccordionChildren } from '@elastic/eui/src/components/accordion/accordion_children/accordion_children';

}
declare module '@elastic/eui/src/components/accordion/accordion.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAccordionStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiAccordion: import("@emotion/react").SerializedStyles;
	    borders: {
	        borders: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	        all: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/accordion/accordion' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import type { EuiButtonIconProps } from '@elastic/eui/src/components/button';
	export const PADDING_SIZES: readonly ["none", "xs", "s", "m", "l", "xl"];
	export type EuiAccordionPaddingSize = (typeof PADDING_SIZES)[number];
	export type EuiAccordionProps = CommonProps & Omit<HTMLAttributes<HTMLElement>, 'id' | 'role'> & {
	    id: string;
	    /**
	     * Applied to the entire .euiAccordion wrapper.
	     * When using `fieldset`, it will enforce `buttonElement = legend` as well.
	     */
	    element?: 'div' | 'fieldset';
	    /**
	     * Defaults to the [group role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/group_role).
	     *
	     * If your accordion contains significant enough content to be a document
	     * [landmark role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/region_role#accessibility_concerns), consider using the `region` role instead.
	     * @default group
	     */
	    role?: HTMLAttributes<HTMLElement>['role'];
	    /**
	     * Class that will apply to the trigger for the accordion.
	     */
	    buttonClassName?: string;
	    /**
	     * Apply more props to the triggering button.
	     *
	     * Includes optional `paddingSize` prop which allows sizes of `s`, `m`, or `l`.
	     * Note: Padding will not be present on the side closest to the accordion arrow.
	     */
	    buttonProps?: CommonProps & HTMLAttributes<HTMLElement> & {
	        paddingSize?: 's' | 'm' | 'l';
	    };
	    /**
	     * Class that will apply to the trigger content for the accordion.
	     */
	    buttonContentClassName?: string;
	    /**
	     * The content of the clickable trigger
	     */
	    buttonContent?: ReactNode;
	    /**
	     * Applied to the main button receiving the `onToggle` event.
	     * Anything other than the default `button` does not support removing the arrow display (for accessibility of focus).
	     */
	    buttonElement?: 'div' | 'legend' | 'button';
	    /**
	     * Extra props to pass to the EuiButtonIcon containing the arrow.
	     */
	    arrowProps?: Partial<Omit<EuiButtonIconProps, 'iconType' | 'onClick' | 'aria-labelledby'>>;
	    /**
	     * Will appear right aligned against the button. Useful for separate actions like deletions.
	     */
	    extraAction?: ReactNode;
	    /**
	     * The accordion will start in the open state.
	     */
	    initialIsOpen?: boolean;
	    /**
	     * Optional callback method called on open and close with a single `isOpen` parameter
	     */
	    onToggle?: (isOpen: boolean) => void;
	    /**
	     * The padding around the exposed accordion content.
	     */
	    paddingSize?: EuiAccordionPaddingSize;
	    /**
	     * Placement of the arrow indicator, or 'none' to hide it.
	     */
	    arrowDisplay?: 'left' | 'right' | 'none';
	    /**
	     * Optional border styling. Defaults to 'none'.
	     */
	    borders?: 'horizontal' | 'all' | 'none';
	    /**
	     * Control the opening of accordion via prop
	     */
	    forceState?: 'closed' | 'open';
	    /**
	     * Change `extraAction` and children into a loading spinner
	     */
	    isLoading?: boolean;
	    /**
	     * Choose whether the loading message replaces the content. Customize the message by passing a node
	     */
	    isLoadingMessage?: boolean | ReactNode;
	    /**
	     * Disable the open/close interaction and visually subdues the trigger
	     */
	    isDisabled?: boolean;
	};
	export const EuiAccordion: FunctionComponent<EuiAccordionProps>;

}
declare module '@elastic/eui/src/components/accordion' {
	export type { EuiAccordionProps } from '@elastic/eui/src/components/accordion/accordion';
	export { EuiAccordion } from '@elastic/eui/src/components/accordion/accordion';

}
declare module '@elastic/eui/src/components/aspect_ratio/aspect_ratio' {
	import { FunctionComponent, HTMLAttributes, ReactElement, CSSProperties } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiAspectRatioProps = HTMLAttributes<HTMLDivElement> & CommonProps & {
	    /**
	     * Aspect ratio height. For example 9 would be widescreen video.
	     */
	    height: number;
	    /**
	     * Aspect ratio width. For example 16 would be widescreen video.
	     */
	    width: number;
	    /**
	     * The maximum width you want the child to stretch to.
	     */
	    maxWidth?: CSSProperties['width'];
	    children: ReactElement<any>;
	};
	export const EuiAspectRatio: FunctionComponent<EuiAspectRatioProps>;

}
declare module '@elastic/eui/src/components/aspect_ratio' {
	export type { EuiAspectRatioProps } from '@elastic/eui/src/components/aspect_ratio/aspect_ratio';
	export { EuiAspectRatio } from '@elastic/eui/src/components/aspect_ratio/aspect_ratio';

}
declare module '@elastic/eui/src/components/auto_sizer/auto_sizer' {
	import type { ComponentProps } from 'react';
	import type { Size, HorizontalSize, VerticalSize } from 'react-virtualized-auto-sizer';
	export type EuiAutoSizerProps = ComponentProps<typeof AutoSizer>;
	export type EuiAutoSize = Size;
	export type EuiAutoSizeHorizontal = HorizontalSize;
	export type EuiAutoSizeVertical = VerticalSize;
	import AutoSizer from 'react-virtualized-auto-sizer';
	export class EuiAutoSizer extends AutoSizer {
	}

}
declare module '@elastic/eui/src/components/auto_sizer' {
	export * from '@elastic/eui/src/components/auto_sizer/auto_sizer';

}
declare module '@elastic/eui/src/components/avatar/avatar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAvatarStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiAvatar: import("@emotion/react").SerializedStyles;
	    plain: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    user: import("@emotion/react").SerializedStyles;
	    space: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    capitalize: import("@emotion/react").SerializedStyles;
	    uppercase: import("@emotion/react").SerializedStyles;
	    lowercase: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	    tooltip: {
	        user: import("@emotion/react").SerializedStyles;
	        space: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/avatar/avatar' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { IconType, IconSize, IconColor } from '@elastic/eui/src/components/icon';
	export const SIZES: readonly ["s", "m", "l", "xl"];
	export type EuiAvatarSize = (typeof SIZES)[number];
	export const TYPES: readonly ["space", "user"];
	export type EuiAvatarType = (typeof TYPES)[number];
	export const CASING: readonly ["capitalize", "uppercase", "lowercase", "none"];
	export type EuiAvatarCasing = (typeof CASING)[number];
	/**
	 * The avatar can only display one type of content,
	 * initials, or image, or iconType
	 */
	type _EuiAvatarContent = ExclusiveUnion<ExclusiveUnion<{
	    /**
	     * Custom initials (max 2 characters).
	     * By default will take the first character (of each word).
	     */
	    initials?: string;
	    /**
	     * Specify how many characters to show (1 or 2).
	     * By default, will show based on number of words (max first 2).
	     */
	    initialsLength?: 1 | 2;
	}, {
	    /**
	     * Path to an image to display instead of initials
	     */
	    imageUrl: string;
	}>, {
	    /**
	     * Any EUI glyph, logo or custom icon to display instead of initials
	     */
	    iconType: IconType;
	    /**
	     * Manually change icon size
	     */
	    iconSize?: IconSize;
	    /**
	     * Manually change icon color
	     */
	    iconColor?: IconColor | null;
	}>;
	export type EuiAvatarProps = Omit<HTMLAttributes<HTMLDivElement>, 'color'> & CommonProps & _EuiAvatarContent & {
	    /**
	     * Full name of the avatar. Used as the accessible label (`aria-label`),
	     * tooltip content and used to derive initials when `initials` is not provided.
	     */
	    name: string;
	    /**
	     * Accepts hex values like `#FFFFFF`, `#000` otherwise a viz palette color will be assigned.
	     * Or pass `'plain'` for an empty shade, `'subdued'` for a light gray shade or `null` to remove entirely and the text/icon color will `inherit`
	     */
	    color?: string | 'plain' | 'subdued' | null;
	    /**
	     * The type of avatar mainly controlling the shape.
	     * `user` = circle
	     * `space` = rounded square
	     */
	    type?: EuiAvatarType;
	    size?: EuiAvatarSize;
	    /**
	     * Sets the letter casing of the displayed initials.
	     * Defaults to `uppercase` for `type="user"` avatars.
	     * Defaults to `none` (uses the existing casing of the passed `name` or `initials`) for `type="space"` avatars.
	     * @default uppercase
	     */
	    casing?: EuiAvatarCasing;
	    /**
	     * Grays out the avatar to simulate being disabled
	     */
	    isDisabled?: boolean;
	};
	export const EuiAvatar: FunctionComponent<EuiAvatarProps>;
	export const checkValidColor: (color: EuiAvatarProps["color"]) => void;
	export {};

}
declare module '@elastic/eui/src/components/avatar' {
	export type { EuiAvatarProps } from '@elastic/eui/src/components/avatar/avatar';
	export { EuiAvatar, checkValidColor } from '@elastic/eui/src/components/avatar/avatar';

}
declare module '@elastic/eui/src/components/badge/color_utils' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBadgeColors: (euiThemeContext: UseEuiTheme) => {
	    fill: {
	        primary: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        neutral: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        success: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        warning: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        risk: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        danger: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        accent: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        default: {
	            backgroundHover: string;
	            backgroundActive: string;
	            borderColor: string;
	            backgroundColor: string;
	            color: string;
	        };
	    };
	    base: {
	        primary: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        neutral: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        success: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        warning: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        risk: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        danger: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        accent: {
	            color: string;
	            backgroundColor: string;
	            borderColor: string;
	            backgroundHover: string;
	            backgroundActive: string;
	        };
	        default: {
	            backgroundHover: string;
	            backgroundActive: string;
	            borderColor: string;
	            backgroundColor: string;
	            color: string;
	        };
	    };
	    disabled: {
	        borderColor: string;
	        color: string;
	        backgroundColor: string;
	        backgroundHover: string;
	        backgroundActive: string;
	    };
	    hollow: {
	        backgroundHover: string;
	        backgroundActive: string;
	        borderColor: string;
	        backgroundColor: string;
	        color: string;
	    };
	    subdued: {
	        borderColor: string;
	        backgroundColor: string;
	        color: string;
	    };
	    accentText: {
	        borderColor: string;
	        backgroundColor: string;
	        color: string;
	    };
	};
	export const getBadgeColors: (euiThemeContext: UseEuiTheme, backgroundColor: string) => {
	    backgroundColor: string;
	    color: string;
	};
	export const getTextColor: ({ euiTheme }: UseEuiTheme, bgColor: string) => string;
	/**
	 * Generates the background hover and active colors for custom interactive badges by mixing
	 * the background color with black or white depending on the background color luminance.
	 * @returns { backgroundHover: string, backgroundActive: string }
	 */
	export const getCustomInteractiveColors: ({ euiTheme }: UseEuiTheme, bgColor: string) => {
	    backgroundHover: string;
	    backgroundActive: string;
	};
	export const getIsValidColor: (color?: string) => boolean;

}
declare module '@elastic/eui/src/components/badge/badge.styles' {
	import { SerializedStyles } from '@emotion/react';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBadgeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBadge: SerializedStyles;
	    iconOnly: SerializedStyles;
	    readonly clickable: {
	        fill: SerializedStyles;
	        base: SerializedStyles;
	        hollow: SerializedStyles;
	        custom: SerializedStyles;
	    };
	    readonly iconClickable: {
	        fill: SerializedStyles;
	        base: SerializedStyles;
	        hollow: SerializedStyles;
	        custom: SerializedStyles;
	    };
	    colors: {
	        fill: {
	            default: SerializedStyles;
	            hollow: SerializedStyles;
	            primary: SerializedStyles;
	            accent: SerializedStyles;
	            neutral: SerializedStyles;
	            success: SerializedStyles;
	            warning: SerializedStyles;
	            risk: SerializedStyles;
	            danger: SerializedStyles;
	        };
	        base: {
	            default: SerializedStyles;
	            hollow: SerializedStyles;
	            primary: SerializedStyles;
	            accent: SerializedStyles;
	            neutral: SerializedStyles;
	            success: SerializedStyles;
	            warning: SerializedStyles;
	            risk: SerializedStyles;
	            danger: SerializedStyles;
	        };
	    };
	    disabled: SerializedStyles;
	    euiBadge__content: SerializedStyles;
	    text: {
	        euiBadge__text: SerializedStyles;
	        clickable: SerializedStyles;
	    };
	    icon: {
	        euiBadge__icon: SerializedStyles;
	        right: SerializedStyles;
	        left: SerializedStyles;
	    };
	    iconButton: {
	        euiBadge__iconButton: SerializedStyles;
	        right: SerializedStyles;
	        left: SerializedStyles;
	    };
	    euiBadge__childButton: SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/badge/badge' {
	import { AriaAttributes, FunctionComponent, HTMLAttributes, MouseEventHandler } from 'react';
	import { CommonProps, ExclusiveUnion, PropsOf } from '@elastic/eui/src/components/common';
	import { EuiIcon, IconType } from '@elastic/eui/src/components/icon';
	export const ICON_SIDES: readonly ["left", "right"];
	type IconSide = (typeof ICON_SIDES)[number];
	export const COLORS: readonly ["default", "hollow", "primary", "accent", "neutral", "success", "warning", "risk", "danger"];
	export type BadgeColor = (typeof COLORS)[number];
	type WithButtonProps = {
	    /**
	     * Will apply an onclick to the badge itself
	     */
	    onClick: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Aria label applied to the onClick button
	     */
	    onClickAriaLabel: AriaAttributes['aria-label'];
	} & Omit<HTMLAttributes<HTMLButtonElement>, 'onClick' | 'color'>;
	type WithAnchorProps = {
	    href: string;
	    target?: string;
	    rel?: string;
	} & Omit<HTMLAttributes<HTMLAnchorElement>, 'href' | 'color' | 'onClick'>;
	type WithSpanProps = Omit<HTMLAttributes<HTMLSpanElement>, 'onClick' | 'color'>;
	interface WithIconOnClick {
	    /**
	     * Will apply an onclick to icon within the badge
	     */
	    iconOnClick: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Aria label applied to the iconOnClick button
	     */
	    iconOnClickAriaLabel: AriaAttributes['aria-label'];
	}
	export type EuiBadgeProps = {
	    /**
	     * Accepts any string from our icon library
	     */
	    iconType?: IconType;
	    /**
	     * The side of the badge the icon should sit
	     */
	    iconSide?: IconSide;
	    /**
	     * Accepts either our palette colors (primary, success ..etc) or a hex value `#FFFFFF`, `#000`.
	     */
	    color?: BadgeColor | string;
	    /**
	     * Whether the badge should use filled (more intense) colors.
	     * It has no effect when a non-named color is passed to the `color` prop.
	     * @default false
	     */
	    fill?: boolean;
	    /**
	     * Will override any color passed through the `color` prop.
	     */
	    isDisabled?: boolean;
	    /**
	     * Props passed to the close button.
	     */
	    closeButtonProps?: Partial<PropsOf<typeof EuiIcon>>;
	} & CommonProps & ExclusiveUnion<WithIconOnClick, {}> & ExclusiveUnion<ExclusiveUnion<WithButtonProps, WithAnchorProps>, WithSpanProps>;
	export const EuiBadge: FunctionComponent<EuiBadgeProps>;
	export {};

}
declare module '@elastic/eui/src/components/badge/beta_badge/beta_badge.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBetaBadgeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBetaBadge: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    hollow: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    badgeSizes: {
	        default: {
	            m: string;
	            s: string;
	        };
	        circle: {
	            m: string;
	            s: string;
	        };
	    };
	    euiBetaBadge__icon: import("@emotion/react").SerializedStyles;
	    baseline: import("@emotion/react").SerializedStyles;
	    middle: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/badge/beta_badge/beta_badge' {
	import { AriaAttributes, FunctionComponent, HTMLAttributes, MouseEventHandler, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiToolTipProps, ToolTipPositions } from '@elastic/eui/src/components/tool_tip';
	import { IconType } from '@elastic/eui/src/components/icon';
	export const COLORS: readonly ["accent", "subdued", "hollow", "warning"];
	export type BetaBadgeColor = (typeof COLORS)[number];
	export const SIZES: readonly ["s", "m"];
	export type BetaBadgeSize = (typeof SIZES)[number];
	export const ALIGNMENTS: readonly ["baseline", "middle"];
	export type BetaBadgeAlignment = (typeof ALIGNMENTS)[number];
	type WithButtonProps = {
	    /**
	     * Will apply an onclick to the badge itself
	     */
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Aria label applied to the onClick button
	     */
	    onClickAriaLabel?: AriaAttributes['aria-label'];
	} & Omit<HTMLAttributes<HTMLButtonElement>, 'onClick' | 'color'>;
	type WithAnchorProps = {
	    href: string;
	    target?: string;
	    rel?: string;
	} & Omit<HTMLAttributes<HTMLAnchorElement>, 'href' | 'color' | 'onClick'>;
	type WithSpanProps = Omit<HTMLAttributes<HTMLSpanElement>, 'onClick' | 'color' | 'title'>;
	type LabelAsNode = ExclusiveUnion<{
	    title: string;
	    tooltipContent?: ReactNode;
	}, {
	    tooltipContent: ReactNode;
	    title?: string;
	}> & {
	    label: ReactNode;
	};
	type LabelAsString = {
	    /**
	     * One word label like "Beta" or "Lab"
	     */
	    label: string;
	};
	type BadgeProps = {
	    /**
	     * Supply an icon type if the badge should just be an icon
	     */
	    iconType?: IconType;
	    /**
	     * One word label like "Beta" or "Lab"
	     */
	    label: ReactNode;
	    /**
	     * Content for the tooltip
	     */
	    tooltipContent?: ReactNode;
	    /**
	     * Custom position of the tooltip
	     */
	    tooltipPosition?: ToolTipPositions;
	    /**
	     * Passes onto the span wrapping the badge
	     */
	    anchorProps?: EuiToolTipProps['anchorProps'];
	    /**
	     * Optional title will be supplied as tooltip title or title attribute
	     * otherwise the label will be used
	     */
	    title?: string;
	    /**
	     * Accepts accent, subdued, hollow and warning.
	     */
	    color?: BetaBadgeColor;
	    size?: BetaBadgeSize;
	    /**
	     * Sets the `vertical-align` CSS property
	     */
	    alignment?: BetaBadgeAlignment;
	} & ExclusiveUnion<LabelAsNode, LabelAsString>;
	export type EuiBetaBadgeProps = CommonProps & ExclusiveUnion<ExclusiveUnion<WithButtonProps, WithAnchorProps>, WithSpanProps> & BadgeProps;
	export const EuiBetaBadge: FunctionComponent<EuiBetaBadgeProps>;
	export {};

}
declare module '@elastic/eui/src/components/badge/beta_badge' {
	export type { EuiBetaBadgeProps } from '@elastic/eui/src/components/badge/beta_badge/beta_badge';
	export { EuiBetaBadge } from '@elastic/eui/src/components/badge/beta_badge/beta_badge';

}
declare module '@elastic/eui/src/components/badge/notification_badge/badge_notification.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiNotificationBadgeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiNotificationBadge: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/badge/notification_badge/badge_notification' {
	import { HTMLAttributes, ReactNode, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const COLORS: readonly ["accent", "subdued", "success"];
	export type BadgeNotificationColor = (typeof COLORS)[number];
	export const SIZES: readonly ["s", "m"];
	export type BadgeNotificationSize = (typeof SIZES)[number];
	export interface EuiNotificationBadgeProps extends CommonProps, Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    size?: BadgeNotificationSize;
	    color?: BadgeNotificationColor;
	}
	export const EuiNotificationBadge: FunctionComponent<EuiNotificationBadgeProps>;

}
declare module '@elastic/eui/src/components/badge/notification_badge' {
	export type { EuiNotificationBadgeProps } from '@elastic/eui/src/components/badge/notification_badge/badge_notification';
	export { EuiNotificationBadge } from '@elastic/eui/src/components/badge/notification_badge/badge_notification';

}
declare module '@elastic/eui/src/components/badge/badge_group/badge_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBadgeGroupStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiBadgeGroup: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/badge/badge_group/badge_group' {
	import React, { ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const GUTTER_SIZES: readonly ["none", "xs", "s"];
	type BadgeGroupGutterSize = (typeof GUTTER_SIZES)[number];
	export interface EuiBadgeGroupProps {
	    /**
	     * Space between badges
	     */
	    gutterSize?: BadgeGroupGutterSize;
	    /**
	     * Should be a list of `EuiBadge`s, but can also be any other element
	     */
	    children?: ReactNode;
	}
	export const EuiBadgeGroup: React.ForwardRefExoticComponent<CommonProps & React.HTMLAttributes<HTMLDivElement> & EuiBadgeGroupProps & React.RefAttributes<HTMLDivElement>>;
	export {};

}
declare module '@elastic/eui/src/components/badge/badge_group' {
	export type { EuiBadgeGroupProps } from '@elastic/eui/src/components/badge/badge_group/badge_group';
	export { EuiBadgeGroup } from '@elastic/eui/src/components/badge/badge_group/badge_group';

}
declare module '@elastic/eui/src/components/badge' {
	export type { EuiBadgeProps } from '@elastic/eui/src/components/badge/badge';
	export { EuiBadge } from '@elastic/eui/src/components/badge/badge';
	export type { EuiBetaBadgeProps } from '@elastic/eui/src/components/badge/beta_badge';
	export { EuiBetaBadge } from '@elastic/eui/src/components/badge/beta_badge';
	export { EuiNotificationBadge } from '@elastic/eui/src/components/badge/notification_badge';
	export type { EuiBadgeGroupProps } from '@elastic/eui/src/components/badge/badge_group';
	export { EuiBadgeGroup } from '@elastic/eui/src/components/badge/badge_group';

}
declare module '@elastic/eui/src/components/banner/banner.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export type EuiBannerSize = 's' | 'm';
	export const euiBannerStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiBanner: import("@emotion/react").SerializedStyles;
	    container: import("@emotion/react").SerializedStyles;
	    media: import("@emotion/react").SerializedStyles;
	    body: import("@emotion/react").SerializedStyles;
	    content: import("@emotion/react").SerializedStyles;
	    title: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	    actions: import("@emotion/react").SerializedStyles;
	    hasDismiss: import("@emotion/react").SerializedStyles;
	    dismiss: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/banner/banner' {
	import React, { ReactNode } from 'react';
	import { CommonProps, DistributiveOmit } from '@elastic/eui/src/components/common';
	import { EuiButtonEmptyProps, EuiButtonIconProps } from '@elastic/eui/src/components/button';
	import { Props as EuiButtonProps } from '@elastic/eui/src/components/button/button';
	import { EuiBannerSize } from '@elastic/eui/src/components/banner/banner.styles';
	export type EuiBannerActionPrimaryProps = DistributiveOmit<EuiButtonProps, 'color' | 'size'>;
	export type EuiBannerActionSecondaryProps = DistributiveOmit<EuiButtonEmptyProps, 'color' | 'size' | 'flush'>;
	export type EuiBannerProps = CommonProps & {
	    /** Heading shown at the top. */
	    title: string;
	    /**
	     * HTML element used to render the title.
	     * @default 'h2'
	     */
	    headingElement?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
	    /** Supporting copy rendered below the title. */
	    text?: ReactNode;
	    /** Extra content rendered directly below `text`. */
	    children?: ReactNode;
	    /** Illustration slot. Wrapped in a square (1:1) container. */
	    media: ReactNode;
	    /**
	     * Visual size variant.
	     * @default 'm'
	     */
	    size?: EuiBannerSize;
	    /**
	     * Defines the announcement background color.
	     * @default 'highlighted'
	     */
	    color?: 'highlighted' | 'plain';
	    /** Optional action buttons. */
	    actionProps?: {
	        /** Primary call-to-action, rendered as an `EuiButton`. */
	        primary?: EuiBannerActionPrimaryProps;
	        /** Secondary action, rendered as an `EuiButtonEmpty`. Is only rendered when a primary action is available. */
	        secondary?: EuiBannerActionSecondaryProps;
	    };
	    /**
	     * When provided, a dismiss button is rendered in the top-right corner and
	     * this callback fires when the user activates it.
	     */
	    onDismiss?: () => void;
	    /** Extra props spread onto the dismiss `EuiButtonIcon`. */
	    dismissButtonProps?: Omit<EuiButtonIconProps, 'onClick' | 'iconType' | 'color'>;
	    /**
	     * When set to `true`, the content is announced by screen readers on mount.
	     * Use only when the announcement is immediately relevant, e.g. as feedback to user actions.
	     * Avoid using on initial page load as it may create noise for assistive technology users.
	     *
	     * @default false
	     */
	    announceOnMount?: boolean;
	};
	export const EuiBanner: React.ForwardRefExoticComponent<CommonProps & {
	    /** Heading shown at the top. */
	    title: string;
	    /**
	     * HTML element used to render the title.
	     * @default 'h2'
	     */
	    headingElement?: "h2" | "h3" | "h4" | "h5" | "h6";
	    /** Supporting copy rendered below the title. */
	    text?: ReactNode;
	    /** Extra content rendered directly below `text`. */
	    children?: ReactNode;
	    /** Illustration slot. Wrapped in a square (1:1) container. */
	    media: ReactNode;
	    /**
	     * Visual size variant.
	     * @default 'm'
	     */
	    size?: EuiBannerSize;
	    /**
	     * Defines the announcement background color.
	     * @default 'highlighted'
	     */
	    color?: "highlighted" | "plain";
	    /** Optional action buttons. */
	    actionProps?: {
	        /** Primary call-to-action, rendered as an `EuiButton`. */
	        primary?: EuiBannerActionPrimaryProps;
	        /** Secondary action, rendered as an `EuiButtonEmpty`. Is only rendered when a primary action is available. */
	        secondary?: EuiBannerActionSecondaryProps;
	    };
	    /**
	     * When provided, a dismiss button is rendered in the top-right corner and
	     * this callback fires when the user activates it.
	     */
	    onDismiss?: () => void;
	    /** Extra props spread onto the dismiss `EuiButtonIcon`. */
	    dismissButtonProps?: Omit<EuiButtonIconProps, "onClick" | "iconType" | "color">;
	    /**
	     * When set to `true`, the content is announced by screen readers on mount.
	     * Use only when the announcement is immediately relevant, e.g. as feedback to user actions.
	     * Avoid using on initial page load as it may create noise for assistive technology users.
	     *
	     * @default false
	     */
	    announceOnMount?: boolean;
	} & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/banner' {
	export { EuiBanner } from '@elastic/eui/src/components/banner/banner';
	export type { EuiBannerProps } from '@elastic/eui/src/components/banner/banner';

}
declare module '@elastic/eui/src/components/beacon/beacon.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBeaconStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBeacon: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/beacon/beacon' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const COLORS: readonly ["subdued", "primary", "success", "accent", "danger", "warning"];
	export type EuiBeaconColor = (typeof COLORS)[number];
	export type EuiBeaconProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'color'> & CommonProps & {
	    /**
	     * Height and width of the center circle. Value is passed directly to the `style` attribute
	     */
	    size?: number | string;
	    /**
	     * Any of the named color palette options.
	     */
	    color?: EuiBeaconColor;
	};
	export const EuiBeacon: FunctionComponent<EuiBeaconProps>;

}
declare module '@elastic/eui/src/components/beacon' {
	export type { EuiBeaconProps } from '@elastic/eui/src/components/beacon/beacon';
	export { EuiBeacon } from '@elastic/eui/src/components/beacon/beacon';

}
declare module '@elastic/eui/src/components/bottom_bar/bottom_bar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBottomBarStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBottomBar: import("@emotion/react").SerializedStyles;
	    static: import("@emotion/react").SerializedStyles;
	    fixed: import("@emotion/react").SerializedStyles;
	    sticky: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    none: string;
	};

}
declare module '@elastic/eui/src/components/bottom_bar/bottom_bar' {
	import React, { CSSProperties, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiPortalProps } from '@elastic/eui/src/components/portal';
	export const PADDING_SIZES: readonly ["none", "s", "m", "l"];
	type BottomBarPaddingSize = (typeof PADDING_SIZES)[number];
	export const POSITIONS: readonly ["static", "fixed", "sticky"];
	export type _BottomBarPosition = (typeof POSITIONS)[number];
	type _BottomBarExclusivePositions = ExclusiveUnion<{
	    position?: 'fixed';
	    /**
	     * Whether to wrap in an EuiPortal which appends the component to the body element.
	     * Only works if `position` is `fixed`.
	     */
	    usePortal?: boolean | EuiPortalProps;
	    /**
	     * Whether the component should apply padding on the document body element to afford for its own displacement height.
	     * Only works if `usePortal` is true and `position` is `fixed`.
	     */
	    affordForDisplacement?: boolean;
	}, {
	    /**
	     * How to position the bottom bar against its parent.
	     */
	    position: 'static' | 'sticky';
	}>;
	export type EuiBottomBarProps = CommonProps & HTMLAttributes<HTMLElement> & _BottomBarExclusivePositions & {
	    /**
	     * Padding applied to the bar. Default is 'm'.
	     */
	    paddingSize?: BottomBarPaddingSize;
	    /**
	     * Optional class applied to the body element on mount.
	     */
	    bodyClassName?: string;
	    /**
	     * Customize the screen reader heading that helps users find this control.
	     *
	     * @default Page level controls
	     */
	    landmarkHeading?: string;
	    /**
	     * Starting vertical position when `fixed` position.
	     * Offset from the top of the window when `sticky` position.
	     * Has no affect on `static` positions.
	     */
	    top?: CSSProperties['top'];
	    /**
	     * Ending horizontal position when `fixed` position.
	     * Has no affect on `static` or `sticky` positions.
	     */
	    right?: CSSProperties['right'];
	    /**
	     * Starting vertical position when `fixed` position.
	     * Offset from the bottom of the window when `sticky` position.
	     * Has no affect on `static` positions.
	     */
	    bottom?: CSSProperties['bottom'];
	    /**
	     * Starting horizontal position when `fixed` position.
	     * Has no affect on `static` or `sticky` positions.
	     */
	    left?: CSSProperties['left'];
	};
	export const EuiBottomBar: React.ForwardRefExoticComponent<EuiBottomBarProps & React.RefAttributes<HTMLElement>>;
	export {};

}
declare module '@elastic/eui/src/components/bottom_bar' {
	export type { EuiBottomBarProps } from '@elastic/eui/src/components/bottom_bar/bottom_bar';
	export { EuiBottomBar } from '@elastic/eui/src/components/bottom_bar/bottom_bar';

}
declare module '@elastic/eui/src/components/link/link' {
	import React, { AnchorHTMLAttributes, ButtonHTMLAttributes, MouseEventHandler } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export type EuiLinkType = 'button' | 'reset' | 'submit';
	export const COLORS: readonly ["primary", "subdued", "success", "accent", "danger", "warning", "text", "ghost"];
	export type EuiLinkColor = (typeof COLORS)[number];
	export interface LinkButtonProps {
	    type?: EuiLinkType;
	    /**
	     * Any of our named colors.
	     */
	    color?: EuiLinkColor;
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	}
	export interface EuiLinkButtonProps extends CommonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'color' | 'onClick'>, LinkButtonProps {
	}
	export interface LinkAnchorProps {
	    type?: EuiLinkType;
	    /**
	     * Any of our named colors.
	     */
	    color?: EuiLinkColor;
	    /**
	     * Set to true to show an icon indicating that it is an external link;
	     * Defaults to true if `target="_blank"`
	     */
	    external?: boolean;
	}
	export interface EuiLinkAnchorProps extends CommonProps, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'type' | 'color' | 'onClick'>, LinkAnchorProps {
	    onClick?: MouseEventHandler<HTMLAnchorElement>;
	}
	export type EuiLinkProps = ExclusiveUnion<EuiLinkButtonProps, EuiLinkAnchorProps>; const EuiLink: React.ForwardRefExoticComponent<((import ("@elastic/eui/src/components/common").DisambiguateSet<EuiLinkButtonProps, EuiLinkAnchorProps> & EuiLinkAnchorProps) | (import ("@elastic/eui/src/components/common").DisambiguateSet<EuiLinkAnchorProps, EuiLinkButtonProps> & EuiLinkButtonProps)) & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
	export { EuiLink };

}
declare module '@elastic/eui/src/components/link' {
	export type { EuiLinkColor, EuiLinkProps, EuiLinkType, EuiLinkAnchorProps, EuiLinkButtonProps, } from '@elastic/eui/src/components/link/link';
	export { EuiLink } from '@elastic/eui/src/components/link/link';

}
declare module '@elastic/eui/src/components/breadcrumbs/types' {
	import type { ReactNode, HTMLAttributes, AriaAttributes, MouseEventHandler } from 'react';
	import type { EuiBreakpointSize } from '@elastic/eui/src/services';
	import type { CommonProps } from '@elastic/eui/src/components/common';
	import type { EuiLinkColor } from '@elastic/eui/src/components/link';
	import type { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	/**
	 * Consumer facing type exports
	 */
	export type EuiBreadcrumbResponsiveMaxCount = {
	    [key in EuiBreakpointSize]?: number;
	};
	export type EuiBreadcrumbsProps = CommonProps & {
	    /**
	     * Hides extra (above the max) breadcrumbs under a collapsed item as the window gets smaller.
	     * Pass a custom {@link EuiBreadcrumbResponsiveMaxCount} object to change the number of breadcrumbs to show at the particular breakpoints.
	     *
	     * Pass `false` to turn this behavior off.
	     *
	     * Default: `{ xs: 1, s: 2, m: 4 }`
	     */
	    responsive?: boolean | EuiBreadcrumbResponsiveMaxCount;
	    /**
	     * Forces all breadcrumbs to single line and
	     * truncates each breadcrumb to a particular width,
	     * except for the last item
	     */
	    truncate?: boolean;
	    /**
	     * Collapses the inner items past the maximum set here
	     * into a single ellipses item.
	     * Omitting or passing a `0` value will show all breadcrumbs.
	     */
	    max?: number | null;
	    /**
	     * The array of individual {@link EuiBreadcrumb} items
	     */
	    breadcrumbs: EuiBreadcrumbProps[];
	    /**
	     * Determines breadcrumbs appearance, with `page` being the default styling.
	     * Application breadcrumbs should only be once per page, in (e.g.) EuiHeader
	     */
	    type?: 'page' | 'application';
	    /**
	     * Whether the last breadcrumb should be semantically highlighted as the
	     * current page. (improves accessibility for screen readers users)
	     * Defaults to true.
	     */
	    lastBreadcrumbIsCurrentPage?: boolean;
	};
	export type EuiBreadcrumbProps = Omit<HTMLAttributes<HTMLElement>, 'color' | 'aria-current'> & CommonProps & {
	    href?: string;
	    rel?: string;
	    onClick?: MouseEventHandler<HTMLAnchorElement>;
	    /**
	     * Visible label of the breadcrumb
	     */
	    text: ReactNode;
	    /**
	     * Force a max-width on the breadcrumb text
	     */
	    truncate?: boolean;
	    /**
	     * @deprecated - if a custom color is wanted, use the `css` prop to pass custom css
	     */
	    color?: EuiLinkColor;
	    /**
	     * Override the existing `aria-current` which defaults to `page` for the last breadcrumb
	     */
	    'aria-current'?: AriaAttributes['aria-current'];
	    /**
	     * Creates a breadcrumb that toggles a popover dialog. Takes any rendered node(s),
	     * or a render function that will pass callback allowing you to close the
	     * breadcrumb popover from within your popover content.
	     *
	     * If passed, both `href` and `onClick` will be ignored - the breadcrumb's
	     * click behavior should only trigger a popover.
	     */
	    popoverContent?: ReactNode | ((closePopover: () => void) => ReactNode);
	    /**
	     * Allows customizing the popover if necessary. Accepts any props that
	     * [EuiPopover](/#/layout/popover) accepts, except for props that control state.
	     */
	    popoverProps?: Omit<EuiPopoverProps, 'button' | 'closePopover' | 'isOpen'>;
	};
	/**
	 * Internal props set by parent EuiBreadcrumbs only
	 */
	export type _EuiBreadcrumbProps = {
	    type: NonNullable<EuiBreadcrumbsProps['type']>;
	    isFirstBreadcrumb?: boolean;
	    isLastBreadcrumb?: boolean;
	    isOnlyBreadcrumb?: boolean;
	    highlightLastBreadcrumb?: boolean;
	    truncateLastBreadcrumb?: boolean;
	};

}
declare module '@elastic/eui/src/components/breadcrumbs/_breadcrumb_content.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Styles cast to inner <a>, <button>, <span> elements
	 */
	export const euiBreadcrumbContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBreadcrumb__content: import("@emotion/react").SerializedStyles;
	    isTruncated: import("@emotion/react").SerializedStyles;
	    isTruncatedLast: import("@emotion/react").SerializedStyles;
	    isInteractive: import("@emotion/react").SerializedStyles;
	    page: import("@emotion/react").SerializedStyles;
	    application: import("@emotion/react").SerializedStyles;
	    applicationStyles: {
	        onlyChild: import("@emotion/react").SerializedStyles;
	        firstChild: import("@emotion/react").SerializedStyles;
	        intermediateChild: string;
	        lastChild: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiBreadcrumbPopoverStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiBreadcrumb__popoverButton: import("@emotion/react").SerializedStyles;
	    euiBreadcrumb__popoverTruncation: import("@emotion/react").SerializedStyles;
	    popoverWrapper: {
	        euiBreadcrumb__popoverWrapper: import("@emotion/react").SerializedStyles;
	        page: import("@emotion/react").SerializedStyles;
	        application: null;
	    };
	};

}
declare module '@elastic/eui/src/components/breadcrumbs/_breadcrumb_content' {
	import { FunctionComponent } from 'react';
	import type { EuiBreadcrumbProps, _EuiBreadcrumbProps } from '@elastic/eui/src/components/breadcrumbs/types';
	export const EuiBreadcrumbContent: FunctionComponent<EuiBreadcrumbProps & _EuiBreadcrumbProps>;

}
declare module '@elastic/eui/src/components/breadcrumbs/breadcrumb.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Styles cast to <li> element
	 */
	export const euiBreadcrumbStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBreadcrumb: import("@emotion/react").SerializedStyles;
	    isTruncated: import("@emotion/react").SerializedStyles;
	    isCollapsed: import("@emotion/react").SerializedStyles;
	    page: import("@emotion/react").SerializedStyles;
	    application: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/breadcrumbs/breadcrumb' {
	import { FunctionComponent, HTMLAttributes, PropsWithChildren } from 'react';
	import type { EuiBreadcrumbProps, _EuiBreadcrumbProps } from '@elastic/eui/src/components/breadcrumbs/types';
	export const EuiBreadcrumb: FunctionComponent<HTMLAttributes<HTMLLIElement> & Pick<_EuiBreadcrumbProps, 'type'> & Pick<EuiBreadcrumbProps, 'truncate'>>;
	export const EuiBreadcrumbCollapsed: FunctionComponent<PropsWithChildren & Pick<_EuiBreadcrumbProps, 'type' | 'isFirstBreadcrumb'>>;

}
declare module '@elastic/eui/src/components/breadcrumbs/breadcrumbs.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBreadcrumbsListStyles: (euiThemeContext: UseEuiTheme) => {
	    euiBreadcrumbs__list: import("@emotion/react").SerializedStyles;
	    isTruncated: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/breadcrumbs/breadcrumbs' {
	import { FunctionComponent } from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	import type { EuiBreadcrumbsProps, EuiBreadcrumbProps } from '@elastic/eui/src/components/breadcrumbs/types';
	export const EuiBreadcrumbs: FunctionComponent<EuiBreadcrumbsProps>;
	export const useResponsiveMax: (responsive: EuiBreadcrumbsProps["responsive"], max: EuiBreadcrumbsProps["max"]) => number | null | undefined;
	type _EuiBreadcrumbCollapsedObj = {
	    isCollapsedButton: true;
	    overflowBreadcrumbs: EuiBreadcrumbProps[];
	};
	type _EuiBreadcrumbsObjs = Array<ExclusiveUnion<EuiBreadcrumbProps, _EuiBreadcrumbCollapsedObj>>;
	export const limitBreadcrumbs: (breadcrumbs: EuiBreadcrumbsProps["breadcrumbs"], max: number) => _EuiBreadcrumbsObjs;
	export {};

}
declare module '@elastic/eui/src/components/breadcrumbs' {
	export type { EuiBreadcrumbProps as EuiBreadcrumb, EuiBreadcrumbsProps, EuiBreadcrumbResponsiveMaxCount, } from '@elastic/eui/src/components/breadcrumbs/types';
	export { EuiBreadcrumbs } from '@elastic/eui/src/components/breadcrumbs/breadcrumbs';

}
declare module '@elastic/eui/src/components/card/card_select/card_select.styles' {
	export const euiCardSelectStyles: () => {
	    euiCardSelect: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/card/card_select/card_select' {
	import { FunctionComponent } from 'react';
	import { Props } from '@elastic/eui/src/components/button/button';
	export type EuiCardSelectProps = Props;
	export const EuiCardSelect: FunctionComponent<EuiCardSelectProps>;
	export function euiCardSelectableColor(color: Props['color'], isSelected: boolean | undefined): Props['color'];

}
declare module '@elastic/eui/src/components/card/card_select' {
	export type { EuiCardSelectProps } from '@elastic/eui/src/components/card/card_select/card_select';
	export { EuiCardSelect, euiCardSelectableColor } from '@elastic/eui/src/components/card/card_select/card_select';

}
declare module '@elastic/eui/src/components/card/card.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { EuiCardProps } from '@elastic/eui/src/components/card/card';
	/**
	 * 1. Footer is always at the bottom.
	 * 3. Horizontal layouts should always top left align no matter the textAlign prop
	 * 4. Ensures the contents always stretch no matter the flex layout
	 */
	export const euiCardStyles: (euiThemeContext: UseEuiTheme, paddingSize: EuiCardProps["paddingSize"]) => {
	    card: {
	        euiCard: import("@emotion/react").SerializedStyles;
	        aligned: {
	            center: import("@emotion/react").SerializedStyles;
	            left: import("@emotion/react").SerializedStyles;
	            right: import("@emotion/react").SerializedStyles;
	        };
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	    main: {
	        euiCard__main: import("@emotion/react").SerializedStyles;
	        layout: {
	            vertical: import("@emotion/react").SerializedStyles;
	            horizontal: import("@emotion/react").SerializedStyles;
	        };
	    };
	    content: {
	        euiCard__content: import("@emotion/react").SerializedStyles;
	        layout: {
	            vertical: import("@emotion/react").SerializedStyles;
	            horizontal: import("@emotion/react").SerializedStyles;
	        };
	    };
	    euiCard__children: import("@emotion/react").SerializedStyles;
	    euiCard__description: import("@emotion/react").SerializedStyles;
	    euiCard__footer: import("@emotion/react").SerializedStyles;
	    top: {
	        euiCard__top: import("@emotion/react").SerializedStyles;
	        layout: {
	            vertical: import("@emotion/react").SerializedStyles;
	            horizontal: import("@emotion/react").SerializedStyles;
	        };
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	    image: {
	        euiCard__image: import("@emotion/react").SerializedStyles;
	        transparent: import("@emotion/react").SerializedStyles;
	    };
	    icon: {
	        euiCard__icon: import("@emotion/react").SerializedStyles;
	        withImage: import("@emotion/react").SerializedStyles;
	        layout: {
	            vertical: import("@emotion/react").SerializedStyles;
	            horizontal: import("@emotion/react").SerializedStyles;
	        };
	    };
	};
	export const euiCardTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCard__text: import("@emotion/react").SerializedStyles;
	    interactive: import("@emotion/react").SerializedStyles;
	    aligned: {
	        center: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	        right: import("@emotion/react").SerializedStyles;
	    };
	    disabled: import("@emotion/react").SerializedStyles;
	};
	export const euiCardBetaBadgeStyles: (euiThemeContext: UseEuiTheme, paddingSize: EuiCardProps["paddingSize"]) => {
	    hasBetaBadge: import("@emotion/react").SerializedStyles;
	    euiCard__betaBadgeAnchor: import("@emotion/react").SerializedStyles;
	    euiCard__betaBadge: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/card/card' {
	import React, { FunctionComponent, ReactElement, ReactNode, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiBetaBadgeProps } from '@elastic/eui/src/components/badge/beta_badge';
	import { EuiIconProps } from '@elastic/eui/src/components/icon';
	import { EuiPanelProps } from '@elastic/eui/src/components/panel';
	import { EuiCardSelectProps } from '@elastic/eui/src/components/card/card_select';
	export const ALIGNMENTS: readonly ["left", "center", "right"];
	type CardAlignment = (typeof ALIGNMENTS)[number];
	/**
	 * Certain props are only allowed when the layout is vertical
	 */
	type EuiCardPropsLayout = ExclusiveUnion<{
	    layout?: 'vertical';
	    /**
	     * Changes alignment of the title and description
	     */
	    textAlign?: CardAlignment;
	    /**
	     * Accepts any combination of elements
	     */
	    footer?: ReactNode;
	    /**
	     * Accepts a url in string form or ReactElement for a custom image component
	     */
	    image?: string | ReactElement;
	}, {
	    /**
	     * Change to "horizontal" if you need the icon to be left of the content.
	     * Horizontal layouts cannot be used in conjunction with `image`, `footer`, or `textAlign`.
	     */
	    layout: 'horizontal';
	}>;
	export type EuiCardProps = Omit<CommonProps, 'aria-label'> & Omit<HTMLAttributes<HTMLDivElement>, 'color' | 'title' | 'onClick'> & EuiCardPropsLayout & {
	    /**
	     * Cards are required to have at least a title and a description and/or children
	     */
	    title: NonNullable<ReactNode>;
	    /**
	     * Determines the title's heading element
	     */
	    titleElement?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span' | 'p';
	    /**
	     * Determines the title's size, matching that of EuiTitle.
	     * Though, card titles can't be too large or small relative to the description text.
	     */
	    titleSize?: 's' | 'xs';
	    /**
	     * Placed within a small EuiText `<p>` tag
	     */
	    description?: NonNullable<ReactNode>;
	    /**
	     * Accepts an `<EuiIcon>` node or `null`
	     */
	    icon?: ReactElement<EuiIconProps> | null;
	    /**
	     * Custom children
	     */
	    children?: ReactNode;
	    /**
	     * Use only if you want to forego a button in the footer and make the whole card clickable
	     */
	    onClick?: React.MouseEventHandler<HTMLButtonElement> | React.MouseEventHandler<HTMLAnchorElement>;
	    isDisabled?: boolean;
	    href?: string;
	    target?: string;
	    rel?: string;
	    /**
	     * Adds a badge to top of the card to label it as "Beta" or other non-GA state.
	     * Accepts all the props of [EuiBetaBadge](#/display/badge#beta-badge-type), where `label` is required.
	     */
	    betaBadgeProps?: EuiBetaBadgeProps;
	    /**
	     * Matches to the color property of EuiPanel. If defined, removes any border & shadow.
	     * Leave as `undefined` to display as a default panel.
	     * Selectable cards will always display as a default panel.
	     */
	    display?: EuiPanelProps['color'];
	    /**
	     * Padding applied around the content of the card
	     */
	    paddingSize?: EuiPanelProps['paddingSize'];
	    /**
	     * Adds a button to the bottom of the card to allow for in-place selection
	     */
	    selectable?: EuiCardSelectProps;
	    /**
	     * Use a border style of card instead of shadow
	     */
	    hasBorder?: EuiPanelProps['hasBorder'];
	};
	export const EuiCard: FunctionComponent<EuiCardProps>;
	export {};

}
declare module '@elastic/eui/src/components/card/checkable_card/checkable_card.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCheckableCardStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCheckableCard: import("@emotion/react").SerializedStyles;
	    isChecked: import("@emotion/react").SerializedStyles;
	    label: {
	        euiCheckableCard__label: import("@emotion/react").SerializedStyles;
	        isDisabled: import("@emotion/react").SerializedStyles;
	    };
	    euiCheckableCard__children: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/card/checkable_card/checkable_card' {
	import { FunctionComponent, ReactNode } from 'react';
	import { EuiRadioProps, EuiCheckboxProps } from '@elastic/eui/src/components/form';
	import { _EuiSplitPanelOuterProps } from '@elastic/eui/src/components/panel/split_panel';
	interface EuiCheckableCardBaseProps {
	    id: string;
	    label: ReactNode;
	    hasShadow?: _EuiSplitPanelOuterProps['hasShadow'];
	    hasBorder?: _EuiSplitPanelOuterProps['hasBorder'];
	}
	interface EuiCheckableCardAsRadioProps extends Omit<EuiRadioProps, 'compressed'> {
	    /**
	     * Whether the control is a radio button or checkbox
	     */
	    checkableType?: 'radio';
	}
	interface EuiCheckableCardAsCheckboxProps extends Omit<EuiCheckboxProps, 'compressed'> {
	    checkableType: 'checkbox';
	}
	export type EuiCheckableCardProps = Omit<EuiCheckableCardAsCheckboxProps | EuiCheckableCardAsRadioProps, 'label' | 'id'> & EuiCheckableCardBaseProps;
	export const EuiCheckableCard: FunctionComponent<EuiCheckableCardProps>;
	export {};

}
declare module '@elastic/eui/src/components/card/checkable_card' {
	export type { EuiCheckableCardProps } from '@elastic/eui/src/components/card/checkable_card/checkable_card';
	export { EuiCheckableCard } from '@elastic/eui/src/components/card/checkable_card/checkable_card';

}
declare module '@elastic/eui/src/components/card' {
	export type { EuiCardProps } from '@elastic/eui/src/components/card/card';
	export { EuiCard } from '@elastic/eui/src/components/card/card';
	export type { EuiCheckableCardProps } from '@elastic/eui/src/components/card/checkable_card';
	export { EuiCheckableCard } from '@elastic/eui/src/components/card/checkable_card';

}
declare module '@elastic/eui/src/components/code/code_block_annotations.style' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeBlockAnnotationsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlockAnnotation: import("@emotion/react").SerializedStyles;
	    euiCodeBlockAnnotation__buttonIcon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/code/code_block_annotations' {
	import { FunctionComponent, PropsWithChildren, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type LineAnnotationMap = Record<number, ReactNode>;
	type EuiCodeBlockAnnotationProps = PropsWithChildren & CommonProps & {
	    lineNumber: number;
	};
	export const EuiCodeBlockAnnotation: FunctionComponent<EuiCodeBlockAnnotationProps>;
	export {};

}
declare module '@elastic/eui/src/components/code/code_block_line.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeBlockLineStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlock__line: string;
	    hasLineNumbers: string;
	    lineText: {
	        euiCodeBlock__lineText: string;
	        isHighlighted: string;
	    };
	    lineNumber: {
	        euiCodeBlock__lineNumberWrapper: string;
	        euiCodeBlock__lineNumber: string;
	    };
	};

}
declare module '@elastic/eui/src/components/code/utils' {
	import { ReactElement, ReactNode, HTMLAttributes } from 'react';
	import { AST, RefractorNode } from 'refractor';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import { LineAnnotationMap } from '@elastic/eui/src/components/code/code_block_annotations';
	/**
	 * Utils shared between EuiCode and EuiCodeBlock
	 */
	export type EuiCodeSharedProps = CommonProps & HTMLAttributes<HTMLElement> & {
	    /**
	     * Sets the syntax highlighting for a specific language
	     * @see [https://prismjs.com/#supported-languages](https://prismjs.com/#supported-languages) for options
	     */
	    language?: string;
	    transparentBackground?: boolean;
	};
	export const SUPPORTED_LANGUAGES: string[];
	export const DEFAULT_LANGUAGE = "text";
	/**
	 * Platform-agnostic new line regex that safely matches all standard
	 * line termination conventions:
	 * - LF: Unix-based platforms and JS-native sources like text areas
	 * - CRLF: Windows
	 * - CR: Mac Classic; to support files saved a long time ago
	 */
	export const NEW_LINE_REGEX: RegExp;
	/**
	 * Platform-agnostic global new line regex that safely matches all standard
	 * line termination conventions.
	 * See [NEW_LINE_REGEX]{@link NEW_LINE_REGEX} for more details.
	 */
	export const NEW_LINE_REGEX_GLOBAL: RegExp;
	export const checkSupportedLanguage: (language: string) => string;
	export const getHtmlContent: (data: RefractorNode[], children: ReactNode) => ReactElement[] | ReactNode;
	export const isAstElement: (node: RefractorNode) => node is AST.Element;
	export const nodeToHtml: (node: RefractorNode, idx: number, nodes: RefractorNode[], depth?: number) => ReactElement;
	interface LineNumbersConfig {
	    start: number;
	    show: boolean;
	    highlight?: string;
	    annotations?: LineAnnotationMap;
	}
	export const parseLineRanges: (ranges: string) => number[];
	export const highlightByLine: (children: string, language: string, data: LineNumbersConfig, euiTheme: UseEuiTheme) => RefractorNode[];
	export {};

}
declare module '@elastic/eui/src/components/code/code.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCode: import("@emotion/react").SerializedStyles;
	    transparentBackground: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/code/code' {
	import { FunctionComponent } from 'react';
	import { EuiCodeSharedProps } from '@elastic/eui/src/components/code/utils';
	export type EuiCodeProps = EuiCodeSharedProps;
	export const EuiCode: FunctionComponent<EuiCodeProps>;

}
declare module '@elastic/eui/src/components/code/code_block_overflow' {
	import { CSSProperties } from 'react';
	/**
	 * Overflow logic - returns overflow-related state/logic/utils
	 *
	 * Detects whether the code block overflows and returns a tabIndex of 0 if so,
	 * which allows keyboard users to use the up/down arrow keys to scroll through
	 * the container.
	 */
	export const useOverflow: ({ overflowHeight, }: {
	    overflowHeight?: number | string;
	}) => {
	    setWrapperRef: import("react").Dispatch<import("react").SetStateAction<Element | null>>;
	    tabIndex: 0 | -1;
	    overflowHeightStyles: CSSProperties;
	};

}
declare module '@elastic/eui/src/components/copy/copy' {
	import React, { Component, ReactElement, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export interface EuiCopyProps extends CommonProps {
	    /**
	     * Text that will be copied to clipboard when copy function is executed.
	     */
	    textToCopy: string;
	    /**
	     * Tooltip message displayed before copy function is called.
	     */
	    beforeMessage?: ReactNode;
	    /**
	     * Tooltip message displayed after copy function is called that lets the user know that
	     * 'textToCopy' has been copied to the clipboard.
	     */
	    afterMessage?: ReactNode;
	    /**
	     * Function that must return a component. First argument is 'copy' function.
	     * Use your own logic to create the component that users interact with when triggering copy.
	     */
	    children(copy: () => void): ReactElement;
	    /**
	     * Optional props to pass to the EuiToolTip component.
	     */
	    tooltipProps?: Partial<Omit<EuiToolTipProps, 'children' | 'content' | 'onMouseOut'>>;
	}
	interface EuiCopyState {
	    tooltipText: ReactNode;
	    isCopied: boolean;
	}
	export class EuiCopy extends Component<EuiCopyProps, EuiCopyState> {
	    static defaultProps: {
	        afterMessage: string;
	    };
	    private tooltipRef;
	    constructor(props: EuiCopyProps);
	    copy: () => void;
	    resetTooltipText: () => void;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/copy' {
	export type { EuiCopyProps } from '@elastic/eui/src/components/copy/copy';
	export { EuiCopy } from '@elastic/eui/src/components/copy/copy';

}
declare module '@elastic/eui/src/components/code/code_block_copy' {
	import React, { ReactNode } from 'react';
	/**
	 * Hook that returns copy-related state/logic/utils
	 */
	export const useCopy: ({ copyAriaLabel, isCopyable, isVirtualized, children, }: {
	    copyAriaLabel?: string;
	    isCopyable: boolean;
	    isVirtualized: boolean;
	    children: ReactNode;
	}) => {
	    innerTextRef: (node: HTMLElement | Element | null | undefined) => void;
	    copyButton: React.JSX.Element | null;
	};

}
declare module '@elastic/eui/src/components/code/code_block.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeBlockStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlock: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    transparentBackground: import("@emotion/react").SerializedStyles;
	    isFullScreen: import("@emotion/react").SerializedStyles;
	    hasControls: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	    hasBothControls: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiCodeBlockPreStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlock__pre: import("@emotion/react").SerializedStyles;
	    padding: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        xl: import("@emotion/react").SerializedStyles;
	    };
	    whiteSpace: {
	        pre: {
	            pre: import("@emotion/react").SerializedStyles;
	            controlsOffset: {
	                none: import("@emotion/react").SerializedStyles;
	                s: import("@emotion/react").SerializedStyles;
	                m: import("@emotion/react").SerializedStyles;
	                l: import("@emotion/react").SerializedStyles;
	                xl: import("@emotion/react").SerializedStyles;
	            };
	        };
	        preWrap: {
	            preWrap: import("@emotion/react").SerializedStyles;
	            controlsOffset: {
	                none: import("@emotion/react").SerializedStyles;
	                s: import("@emotion/react").SerializedStyles;
	                m: import("@emotion/react").SerializedStyles;
	                l: import("@emotion/react").SerializedStyles;
	                xl: import("@emotion/react").SerializedStyles;
	            };
	        };
	    };
	};
	export const euiCodeBlockCodeStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlock__code: import("@emotion/react").SerializedStyles;
	    isVirtualized: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/delay_render/delay_render' {
	import { Component, PropsWithChildren } from 'react';
	export interface EuiDelayRenderProps extends PropsWithChildren {
	    delay: number;
	}
	interface EuiDelayRenderState {
	    toggle: boolean;
	}
	export class EuiDelayRender extends Component<EuiDelayRenderProps, EuiDelayRenderState> {
	    static defaultProps: {
	        delay: number;
	    };
	    private delayID;
	    private toBeDelayed;
	    constructor(props: EuiDelayRenderProps);
	    shouldUpdate(): void;
	    startDelaying: () => void;
	    stopDelaying: () => void;
	    componentDidMount(): void;
	    shouldComponentUpdate(): boolean;
	    componentWillUnmount(): void;
	    componentDidUpdate(): void;
	    render(): import("react").ReactNode;
	}
	export {};

}
declare module '@elastic/eui/src/components/delay_render' {
	export type { EuiDelayRenderProps } from '@elastic/eui/src/components/delay_render/delay_render';
	export { EuiDelayRender } from '@elastic/eui/src/components/delay_render/delay_render';

}
declare module '@elastic/eui/src/components/code/code_block_full_screen' {
	import React, { FunctionComponent, KeyboardEvent, PropsWithChildren } from 'react';
	/**
	 * Hook that returns fullscreen-related state/logic/utils
	 */
	export const useFullScreen: ({ overflowHeight, }: {
	    overflowHeight?: number | string;
	}) => {
	    fullScreenButton: React.JSX.Element | null;
	    isFullScreen: boolean;
	    onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
	};
	/**
	 * Portalled full screen wrapper
	 */
	export const EuiCodeBlockFullScreenWrapper: FunctionComponent<PropsWithChildren & {
	    onClose: (event: React.KeyboardEvent<HTMLElement>) => void;
	}>;

}
declare module '@elastic/eui/src/components/code/code_block_controls.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCodeBlockControlsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCodeBlock__controls: import("@emotion/react").SerializedStyles;
	    offset: {
	        none: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/code/code_block_controls' {
	import { FC, ReactNode } from 'react';
	import type { EuiCodeBlockPaddingSize } from '@elastic/eui/src/components/code/code_block';
	export const EuiCodeBlockControls: FC<{
	    controls: ReactNode[];
	    paddingSize: EuiCodeBlockPaddingSize;
	}>;

}
declare module '@elastic/eui/src/components/code/code_block_virtualized' {
	import React, { HTMLAttributes, ReactNode } from 'react';
	import { RefractorNode } from 'refractor';
	export const EuiCodeBlockVirtualized: ({ data, label, rowHeight, overflowHeight, preProps, codeProps, }: {
	    data: RefractorNode[];
	    label: ReactNode;
	    rowHeight: number;
	    overflowHeight?: number | string;
	    preProps: HTMLAttributes<HTMLPreElement>;
	    codeProps: HTMLAttributes<HTMLElement>;
	}) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/code/code_block' {
	import { FunctionComponent } from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiCodeSharedProps } from '@elastic/eui/src/components/code/utils';
	import { LineAnnotationMap } from '@elastic/eui/src/components/code/code_block_annotations';
	export const FONT_SIZES: readonly ["s", "m", "l"];
	export type EuiCodeBlockFontSize = (typeof FONT_SIZES)[number];
	export const PADDING_SIZES: readonly ["none", "s", "m", "l"];
	export type EuiCodeBlockPaddingSize = (typeof PADDING_SIZES)[number];
	type VirtualizedOptionProps = ExclusiveUnion<{
	    isVirtualized: true;
	    overflowHeight: number | string;
	    whiteSpace?: 'pre';
	}, {
	    isVirtualized?: false;
	    overflowHeight?: number | string;
	    whiteSpace?: 'pre' | 'pre-wrap';
	}>;
	interface LineNumbersConfig {
	    start?: number;
	    highlight?: string;
	    annotations?: LineAnnotationMap;
	}
	export type EuiCodeBlockProps = EuiCodeSharedProps & {
	    paddingSize?: EuiCodeBlockPaddingSize;
	    fontSize?: EuiCodeBlockFontSize;
	    /**
	     * Specify how `white-space` inside the element is handled.
	     * `pre` respects line breaks/white space but doesn't force them to wrap the line
	     * `pre-wrap` respects line breaks/white space but does force them to wrap the line when necessary.
	     */
	    whiteSpace?: 'pre' | 'pre-wrap';
	    /**
	     * Displays an icon button to copy the code snippet to the clipboard.
	     */
	    isCopyable?: boolean;
	    /**
	     * Customizes the aria-label for the copy button.
	     *
	     * @default 'Copy'
	     */
	    copyAriaLabel?: string;
	    /**
	     * Displays line numbers.
	     * Optionally accepts a configuration object for setting the starting number,
	     * visually highlighting ranges, or annotating specific lines:
	     * `{ start: 100, highlight: '1, 5-10, 20-30, 40', annotations: { 6: 'A special note about this line' } }`
	     */
	    lineNumbers?: boolean | LineNumbersConfig;
	    /**
	     * Sets the maximum container height.
	     * Accepts a pixel value (`300`) or a percentage (`'100%'`)
	     * Ensure the container has calcuable height when using a percentage
	     */
	    overflowHeight?: number | string;
	    /**
	     * Renders code block lines virtually.
	     * Useful for improving load times of large code blocks.
	     *
	     * When using this configuration, `overflowHeight` is required and
	     * `whiteSpace` can only be `pre`.
	     */
	    isVirtualized?: boolean;
	} & VirtualizedOptionProps;
	export const EuiCodeBlock: FunctionComponent<EuiCodeBlockProps>;
	export {};

}
declare module '@elastic/eui/src/components/code' {
	export type { EuiCodeProps } from '@elastic/eui/src/components/code/code';
	export { EuiCode } from '@elastic/eui/src/components/code/code';
	export type { EuiCodeBlockProps } from '@elastic/eui/src/components/code/code_block';
	export { EuiCodeBlock } from '@elastic/eui/src/components/code/code_block';

}
declare module '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group/collapsible_nav_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavGroupStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCollapsibleNavGroup: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	    light: import("@emotion/react").SerializedStyles;
	    dark: import("@emotion/react").SerializedStyles;
	    isCollapsible: import("@emotion/react").SerializedStyles;
	    notCollapsible: import("@emotion/react").SerializedStyles;
	    childrenWrapper: {
	        euiCollapsibleNavGroup__children: import("@emotion/react").SerializedStyles;
	        withHeading: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group/collapsible_nav_group' {
	import { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion';
	import { IconType, IconSize, EuiIconProps } from '@elastic/eui/src/components/icon';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	export const BACKGROUNDS: readonly ["none", "light", "dark"];
	type Background = (typeof BACKGROUNDS)[number];
	export interface EuiCollapsibleNavGroupInterface extends CommonProps {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Sits left of the `title` and only when `title` is present
	     */
	    iconType?: IconType;
	    /**
	     * Change the size of the icon in the `title`
	     */
	    iconSize?: IconSize;
	    /**
	     * Further extend the props applied to EuiIcon
	     */
	    iconProps?: Omit<EuiIconProps, 'type' | 'size'>;
	    /**
	     * Optionally provide an id, otherwise one will be created
	     */
	    id?: string;
	    /**
	     * Adds a background color to the entire group,
	     * applying the correct text color to the `title` only
	     */
	    background?: Background;
	    /**
	     * Determines the title's heading element
	     */
	    titleElement?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span';
	    /**
	     * Title sizing equivalent to EuiTitle, but only `s` and smaller
	     */
	    titleSize?: Exclude<EuiTitleProps['size'], 'l' | 'm'>;
	}
	type GroupAsAccordion = EuiCollapsibleNavGroupInterface & Omit<EuiAccordionProps, 'id' | 'title'> & {
	    /**
	     * If `true`, wraps children in the body of an accordion,
	     * requiring the prop `title` to be used as the button.
	     * When `false`, simply renders a div without any accordion functionality.
	     */
	    isCollapsible: true;
	    /**
	     * The title gets wrapped in the appropriate heading level
	     * with the option to add an iconType
	     */
	    title: ReactNode;
	};
	type GroupAsDiv = EuiCollapsibleNavGroupInterface & {
	    /**
	     * If `true`, wraps children in the body of an accordion,
	     * requiring the prop `title` to be used as the button.
	     * When `false`, simply renders a div without any accordion functionality.
	     */
	    isCollapsible?: false;
	    /**
	     * The title gets wrapped in the appropriate heading level
	     * with the option to add an iconType
	     */
	    title?: ReactNode;
	} & Omit<HTMLAttributes<HTMLDivElement>, 'title'>;
	export type EuiCollapsibleNavGroupProps = ExclusiveUnion<GroupAsAccordion, GroupAsDiv>;
	export const EuiCollapsibleNavGroup: FunctionComponent<EuiCollapsibleNavGroupProps>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group' {
	export type { EuiCollapsibleNavGroupProps } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group/collapsible_nav_group';
	export { EuiCollapsibleNavGroup } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group/collapsible_nav_group';

}
declare module '@elastic/eui/src/components/collapsible_nav/collapsible_nav.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCollapsibleNav: import("@emotion/react").SerializedStyles;
	    push: import("@emotion/react").SerializedStyles;
	    overlay: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav/collapsible_nav' {
	import { FunctionComponent, ReactElement, ReactNode } from 'react';
	import { EuiFlyoutProps } from '@elastic/eui/src/components/flyout';
	export type EuiCollapsibleNavProps = Omit<EuiFlyoutProps<'nav' | 'div'>, 'type' | 'pushBreakpoint'> & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Shows the navigation flyout
	     */
	    isOpen?: boolean;
	    /**
	     * Keeps navigation flyout visible and push `<body>` content via padding
	     */
	    isDocked?: boolean;
	    /**
	     * Named breakpoint (`xs` through `xl`) for customizing the minimum window width to enable docking
	     */
	    dockedBreakpoint?: EuiFlyoutProps['pushMinBreakpoint'];
	    /**
	     * Button for controlling visible state of the nav
	     */
	    button?: ReactElement;
	    /**
	     * Keeps the display of toggle button when in docked state
	     */
	    showButtonIfDocked?: boolean;
	};
	export const EuiCollapsibleNav: FunctionComponent<EuiCollapsibleNavProps>;

}
declare module '@elastic/eui/src/components/collapsible_nav' {
	export type { EuiCollapsibleNavGroupProps } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group';
	export { EuiCollapsibleNavGroup } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav_group';
	export type { EuiCollapsibleNavProps } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav';
	export { EuiCollapsibleNav } from '@elastic/eui/src/components/collapsible_nav/collapsible_nav';

}
declare module '@elastic/eui/src/components/header/header.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderVariables: (euiThemeContext: UseEuiTheme) => {
	    height: string;
	    childHeight: string;
	    padding: string;
	};
	export const euiHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHeader: import("@emotion/react").SerializedStyles;
	    static: import("@emotion/react").SerializedStyles;
	    fixed: import("@emotion/react").SerializedStyles;
	    default: import("@emotion/react").SerializedStyles;
	    dark: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/context' {
	import { MouseEventHandler } from 'react';
	import { _EuiFlyoutSide } from '@elastic/eui/src/components/flyout/const';
	type _EuiCollapsibleNavContext = {
	    isCollapsed: boolean;
	    isPush: boolean;
	    isOverlayOpen: boolean;
	    side: _EuiFlyoutSide;
	    closePortals?: MouseEventHandler;
	};
	export const EuiCollapsibleNavContext: import("react").Context<_EuiCollapsibleNavContext>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_button/collapsible_nav_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavButtonWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNavButtonWrapper: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavButton: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_button/collapsible_nav_button' {
	import React from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button';
	export type EuiCollapsibleNavButtonProps = CommonProps & Partial<EuiButtonIconPropsForButton>;
	export const EuiCollapsibleNavButton: React.ForwardRefExoticComponent<CommonProps & Partial<EuiButtonIconPropsForButton> & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_button' {
	export { EuiCollapsibleNavButton } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_button/collapsible_nav_button';

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_body_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const hideScrollbars = "\n  scrollbar-width: none; /* Firefox */\n\n  &::-webkit-scrollbar {\n    display: none; /* Chrome, Edge, & Safari */\n  }\n";
	export const euiCollapsibleNavBodyStyles: {
	    euiCollapsibleNav__body: import("@emotion/react").SerializedStyles;
	    isPushCollapsed: import("@emotion/react").SerializedStyles;
	};
	export const euiCollapsibleNavFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNav__footer: import("@emotion/react").SerializedStyles;
	    euiFlyoutFooter__overflow: import("@emotion/react").SerializedStyles;
	    isPushCollapsed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_beta.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavBetaStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNavBeta: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    isPush: import("@emotion/react").SerializedStyles;
	    isPushCollapsed: import("@emotion/react").SerializedStyles;
	    isOverlayFullWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_body_footer' {
	import { EuiFlyoutBodyProps, EuiFlyoutFooterProps } from '@elastic/eui/src/components/flyout';
	/**
	 * These components are incredibly light wrappers around `EuiFlyoutBody`
	 * and `EuiFlyoutFooter` with collapsible nav-specific styling/considerations.
	 *
	 * Note: They are not intended to be used standalone outside of EuiCollapsibleNav
	 */
	export const EuiCollapsibleNavBody: EuiFlyoutBodyProps;
	export const EuiCollapsibleNavFooter: EuiFlyoutFooterProps;

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Style variables shared between accordion, link, and sub items
	 */
	export const euiCollapsibleNavItemVariables: (euiThemeContext: UseEuiTheme) => {
	    animation: string;
	    borderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    backgroundHoverColor: string;
	    backgroundSelectedColor: string;
	    color: string;
	    rightIconColor: string;
	    fontSize: import("react").CSSProperties["fontSize"];
	    lineHeight: import("react").CSSProperties["lineHeight"];
	    height: string;
	    padding: string;
	};
	/**
	 * Title styles
	 */
	export const euiCollapsibleNavItemTitleStyles: {
	    euiCollapsibleNavItem__title: import("@emotion/react").SerializedStyles;
	};
	/**
	 * Sub item groups
	 */
	export const euiCollapsibleNavSubItemsStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCollapsibleNavItem__items: import("@emotion/react").SerializedStyles;
	    isTopItem: import("@emotion/react").SerializedStyles;
	    isSubItem: import("@emotion/react").SerializedStyles;
	};
	/**
	 * Top-level item only styles
	 */
	export const euiCollapsibleNavTopItemStyles: ({ euiTheme: _euiTheme, }: UseEuiTheme) => {
	    euiCollapsibleNavTopItem: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsedNavButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsedNavButton: import("@emotion/react").SerializedStyles;
	    isSelected: import("@emotion/react").SerializedStyles;
	};
	export const euiCollapsedNavItemTooltipStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCollapsedNavItemTooltip: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    hidden: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_button' {
	import { FunctionComponent } from 'react';
	import { EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	export const EuiCollapsedNavButton: FunctionComponent<Omit<EuiCollapsibleNavItemProps, 'items' | 'isCollapsible' | 'accordionProps'> & {
	    hideToolTip?: boolean;
	}>;

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_popover.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsedNavPopoverStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsedNavPopover__panel: import("@emotion/react").SerializedStyles;
	    euiCollapsedNavPopover__title: import("@emotion/react").SerializedStyles;
	    euiCollapsedNavPopover__items: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_popover' {
	import { FunctionComponent } from 'react';
	import { type EuiPopoverProps } from '@elastic/eui/src/components/popover';
	import { EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	export const EuiCollapsedNavPopover: FunctionComponent<Omit<EuiCollapsibleNavItemProps, 'isCollapsible' | 'accordionProps' | 'href' | 'linkProps'> & Partial<EuiPopoverProps>>;

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_item' {
	import { FunctionComponent } from 'react';
	import { EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	/**
	 * The collapsed nav item state only shows on larger/non-mobile screens
	 * and collapses top-level link/accordion items to only rendering icons.
	 *
	 * Accordions turn into popovers, links turn into icon buttons
	 */
	export const EuiCollapsedNavItem: FunctionComponent<EuiCollapsibleNavItemProps>;

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed' {
	export { EuiCollapsedNavItem } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsed/collapsed_nav_item';

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_link.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavLinkStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNavLink: import("@emotion/react").SerializedStyles;
	    isSelected: import("@emotion/react").SerializedStyles;
	    isTopItem: {
	        isTopItem: import("@emotion/react").SerializedStyles;
	        isNotAccordion: import("@emotion/react").SerializedStyles;
	        isInteractive: import("@emotion/react").SerializedStyles;
	    };
	    isSubItem: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_link' {
	import { FunctionComponent, ReactNode } from 'react';
	import { EuiLinkProps } from '@elastic/eui/src/components/link';
	import type { _SharedEuiCollapsibleNavItemProps, _EuiCollapsibleNavItemDisplayProps, EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	type EuiCollapsibleNavLinkProps = Omit<EuiLinkProps, 'children'> & _SharedEuiCollapsibleNavItemProps & _EuiCollapsibleNavItemDisplayProps & Pick<EuiCollapsibleNavItemProps, 'href' | 'linkProps'> & {
	    children: ReactNode;
	    isInteractive?: boolean;
	    isNotAccordion?: boolean;
	};
	/**
	 * Internal nav link component.
	 *
	 * Can be rendered as a standalone nav item, or as part of an accordion header.
	 * Can also be rendered as top-level item (has a background hover) or as a
	 * sub-item (renders closer to plain text).
	 *
	 * In terms of DOM output, follows the same logic as EuiLink (renders either
	 * an `a` tag or a `button` if no valid link exists), and can also additionally
	 * rendered a plain `span` if the item is not interactive.
	 */
	export const EuiCollapsibleNavLink: FunctionComponent<EuiCollapsibleNavLinkProps>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_accordion.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavAccordionStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNavAccordion: import("@emotion/react").SerializedStyles;
	    isSelected: import("@emotion/react").SerializedStyles;
	    isTopItem: import("@emotion/react").SerializedStyles;
	    isSubItem: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavAccordion__arrow: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_accordion' {
	import { FunctionComponent, ReactNode } from 'react';
	import { type _SharedEuiCollapsibleNavItemProps, type _EuiCollapsibleNavItemDisplayProps, type EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	type EuiCollapsibleNavAccordionProps = _SharedEuiCollapsibleNavItemProps & _EuiCollapsibleNavItemDisplayProps & Pick<EuiCollapsibleNavItemProps, 'accordionProps'> & Required<Pick<EuiCollapsibleNavItemProps, 'items'>> & {
	    buttonContent: ReactNode;
	};
	/**
	 * Internal nav accordion component.
	 *
	 * Renders children as either a nav link or any number/nesting of more nav accordions.
	 * Triggering the open/closed state is handled only by the accordion `arrow` for
	 * UX consistency, as accordion/nav titles can be their own links to pages.
	 */
	export const EuiCollapsibleNavAccordion: FunctionComponent<EuiCollapsibleNavAccordionProps>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_group' {
	import { FunctionComponent, ReactNode } from 'react';
	import { type _SharedEuiCollapsibleNavItemProps, type _EuiCollapsibleNavItemDisplayProps, type EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	type EuiCollapsibleNavGroupProps = _SharedEuiCollapsibleNavItemProps & _EuiCollapsibleNavItemDisplayProps & Required<Pick<EuiCollapsibleNavItemProps, 'items'>> & {
	    header?: ReactNode;
	};
	/**
	 * Internal nav group. Should look the same as an open accordion,
	 * but not be toggle-able to close.
	 *
	 * Yes, I know this is the 3rd component in EUI named EuiCollapsibleNavGroup :|
	 * I'm waiting for serverless's design architecture to settle before untangling
	 * this pasghetti
	 */
	export const EuiCollapsibleNavGroup: FunctionComponent<EuiCollapsibleNavGroupProps>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item' {
	import { FunctionComponent, HTMLAttributes, MouseEventHandler, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { IconType, EuiIconProps } from '@elastic/eui/src/components/icon';
	import { EuiLinkProps } from '@elastic/eui/src/components/link';
	import { EuiAccordionProps } from '@elastic/eui/src/components/accordion';
	export type _SharedEuiCollapsibleNavItemProps = HTMLAttributes<HTMLElement> & CommonProps & {
	    /**
	     * Highlights whether an item is currently selected, e.g.
	     * if the user is on the same page as the nav link
	     */
	    isSelected?: boolean;
	};
	export type EuiCollapsibleNavItemProps = _SharedEuiCollapsibleNavItemProps & ExclusiveUnion<{
	    /**
	     * Required text to render as the nav item title
	     */
	    title: string;
	    /**
	     * Allows customizing the title element.
	     * Consider using a heading element for better accessibility.
	     * Defaults to an unsemantic `span` or `div`, depending on context.
	     */
	    titleElement?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span' | 'div';
	    /**
	     * Optional icon to render to the left of title content
	     */
	    icon?: IconType;
	    /**
	     * Optional props to pass to the title icon
	     */
	    iconProps?: Partial<EuiIconProps>;
	}, {}> & ExclusiveUnion<{
	    /**
	     * The nav item link.
	     *
	     * If not included, and no `onClick` is specified, the nav item
	     * will render as an non-interactive `<span>`.
	     *
	     * Should not be used together with `items`, as the title will
	     * trigger the accordion collapse/expand action instead of a link.
	     */
	    href?: string;
	    /**
	     * If a `href` is specified, use this prop to pass any prop that `EuiLink` accepts
	     */
	    linkProps?: Partial<EuiLinkProps>;
	}, {
	    /**
	     * Will render either an accordion or group of nested child item links.
	     *
	     * Accepts any {@link EuiCollapsibleNavItemProps}. Or, to render completely custom
	     * subitem content, pass an object with a `renderItem` callback.
	     */
	    items: EuiCollapsibleNavSubItemProps[];
	    /**
	     * If set to false, will (visually) render an always-open accordion that cannot
	     * be toggled closed. Ignored if `items` is not passed.
	     *
	     * @default true
	     */
	    isCollapsible?: boolean;
	    /**
	     * If `items` is specified, and `isCollapsible` is not set to false, you may
	     * use this prop to pass any prop that `EuiAccordion` accepts, including props
	     * that control the toggled state of the accordion (e.g. `initialIsOpen`, `forceState`)
	     */
	    accordionProps?: Partial<EuiAccordionProps>;
	}>;
	export type EuiCollapsibleNavCustomSubItem = {
	    renderItem: (options: {
	        /**
	         * When the side nav is collapsed on larger screens, the menu appears in an EuiPopover.
	         * When the sidenav is collapsed on smaller screens, the menu appears in an EuiFlyout.
	         *
	         * Use this handler to close either the portalled flyout or popover, depending on which is present.
	         * If the handler is not defined, it means there is no portal onscreen to close.
	         */
	        closePortals?: MouseEventHandler;
	    }) => ReactNode;
	};
	export type EuiCollapsibleNavSubItemProps = ExclusiveUnion<EuiCollapsibleNavItemProps, EuiCollapsibleNavCustomSubItem>;
	export type _EuiCollapsibleNavItemDisplayProps = {
	    /**
	     * Determines whether the item should render as a top-level nav item
	     * or a nested nav subitem. Set internally by EUI
	     */
	    isSubItem?: boolean;
	};
	/**
	 * Internal subcomponent for title display
	 */
	export const EuiCollapsibleNavItemTitle: FunctionComponent<Pick<EuiCollapsibleNavItemProps, 'title' | 'titleElement' | 'icon' | 'iconProps'>>;
	/**
	 * Sub-items can either be a totally custom rendered item,
	 * or they can simply be more links or accordions
	 */
	export const EuiCollapsibleNavSubItem: FunctionComponent<EuiCollapsibleNavSubItemProps>;
	/**
	 * Reuseable component for rendering a group of sub items
	 * Used by both `EuiCollapsibleNavGroup` and `EuiCollapsibleNavAccordion`
	 */
	type EuiCollapsibleNavSubItemsProps = HTMLAttributes<HTMLDivElement> & _EuiCollapsibleNavItemDisplayProps & {
	    items: EuiCollapsibleNavSubItemProps[];
	};
	export const EuiCollapsibleNavSubItems: FunctionComponent<EuiCollapsibleNavSubItemsProps>;
	/**
	 * The actual exported component
	 */
	export const EuiCollapsibleNavItem: FunctionComponent<EuiCollapsibleNavItemProps>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item' {
	export type { EuiCollapsibleNavItemProps, EuiCollapsibleNavSubItemProps, } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	export { EuiCollapsibleNavItem, EuiCollapsibleNavSubItem, } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/_kibana_solution/collapsible_nav_kibana_solution.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCollapsibleNavKibanaSolutionStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCollapsibleNavKibanaSolution: import("@emotion/react").SerializedStyles;
	    collapsed: import("@emotion/react").SerializedStyles;
	    uncollapsed: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavKibanaSolution__title: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavKibanaSolution__logo: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavKibanaSolution__switcherIcon: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavKibanaSolution__switcherPopover: import("@emotion/react").SerializedStyles;
	    euiCollapsibleNavKibanaSolution__secondaryItems: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/_kibana_solution/collapsible_nav_kibana_solution' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { type EuiListGroupItemProps } from '@elastic/eui/src/components/list_group';
	import { type EuiCollapsibleNavItemProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item/collapsible_nav_item';
	export type KibanaCollapsibleNavSolutionProps = HTMLAttributes<HTMLDivElement> & CommonProps & Required<Pick<EuiCollapsibleNavItemProps, 'title' | 'icon' | 'items'>> & {
	    solutions: EuiListGroupItemsModified;
	};
	/**
	 * This component should only ever be used as a **top-level component**.
	 * It also should **not** be used in the nav footer.
	 *
	 * This component is **very** specific to Kibana and is not meant to be a generic component.
	 */
	export const KibanaCollapsibleNavSolution: FunctionComponent<KibanaCollapsibleNavSolutionProps>;
	/**
	 * Tweak EuiListGroup's items API to match EuiCollapsibleNav's
	 * more closely (primarily label->title, iconType->icon),
	 * and also to allow passing secondary items in the same array
	 * (which will get rendered in a separate non-bordered group)
	 */
	type EuiListGroupItemsModified = Array<Omit<EuiListGroupItemProps, 'label' | 'iconType' | 'icon'> & {
	    title: string;
	    icon?: EuiListGroupItemProps['iconType'];
	    isSecondary?: boolean;
	}>;
	export {};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/_kibana_solution' {
	export { KibanaCollapsibleNavSolution } from '@elastic/eui/src/components/collapsible_nav_beta/_kibana_solution/collapsible_nav_kibana_solution';

}
declare module '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_beta' {
	import React, { HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFlyoutProps } from '@elastic/eui/src/components/flyout';
	export type EuiCollapsibleNavBetaProps = CommonProps & Omit<HTMLAttributes<HTMLElement>, 'onResize'> & Pick<EuiFlyoutProps, // Extend only specific flyout props - EuiCollapsibleNav is much less customizable than EuiFlyout
	// Extend only specific flyout props - EuiCollapsibleNav is much less customizable than EuiFlyout
	'side' | 'focusTrapProps' | 'includeFixedHeadersInFocusTrap'> & {
	    /**
	     * ReactNode(s) to render as navigation flyout content, typically `EuiCollapsibleNavBeta.Item`s.
	     * You will likely want to use `EuiCollapsibleNavBeta.Body` and `EuiCollapsibleNavBeta.Footer`
	     * for organization.
	     */
	    children?: ReactNode;
	    /**
	     * Whether the navigation flyout should default to initially collapsed or expanded.
	     * Used for **uncontrolled** state.
	     */
	    initialIsCollapsed?: boolean;
	    /**
	     * If defined, the navigation collapsed/expanded state is **controlled**
	     * by the consumer and `onCollapseToggle` must be passed as well.
	     * This prop supercedes `initialIsCollapsed`.
	     */
	    isCollapsed?: boolean;
	    /**
	     * Optional callback that fires when the user toggles the nav between
	     * collapsed and uncollapsed states
	     */
	    onCollapseToggle?: (isCollapsed: boolean) => void;
	    /**
	     * Defaults to 248px wide. The navigation width determines behavior at
	     * various responsive breakpoints.
	     *
	     * At larger screen sizes (at least 3x the width of the nav), the nav will
	     * be able to be toggled between a docked full width nav and a collapsed
	     * side bar that only shows the icon of each item.
	     *
	     * At under 3 times the width of the nav, the behavior will lose the collapsed
	     * side bar behavior, and switch from a docked flyout to an overlay flyout only.
	     *
	     * If the page is under 1.5 times the width of the nav, the overlay will
	     * take up the full width of the page.
	     */
	    width?: number;
	    /**
	     * Overlay flyouts are considered dialogs, and dialogs must have a label.
	     * By default, a label of `Site menu` will be applied.
	     *
	     * If your usage of this component is not actually for site-wide navigation,
	     * please set your own `aria-label` or `aria-labelledby`.
	     *
	     * @default 'Site menu'
	     */
	    'aria-label'?: string;
	};
	export const EuiCollapsibleNavBeta: React.FunctionComponent<EuiCollapsibleNavBetaProps> & {
	    Body: import ("@elastic/eui/src/components/flyout").EuiFlyoutBodyProps;
	    Footer: import ("@elastic/eui/src/components/flyout").EuiFlyoutFooterProps;
	    Item: React.FunctionComponent<import ("@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item").EuiCollapsibleNavItemProps>;
	    KibanaSolution: React.FunctionComponent<import ("@elastic/eui/src/components/collapsible_nav_beta/_kibana_solution/collapsible_nav_kibana_solution").KibanaCollapsibleNavSolutionProps>;
	};

}
declare module '@elastic/eui/src/components/collapsible_nav_beta' {
	/**
	 * NOTE: This is currently still a beta component, being exported for Kibana
	 * development usage. It is not yet fully documented or supported.
	 */
	export type { EuiCollapsibleNavBetaProps } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_beta';
	export { EuiCollapsibleNavBeta } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_beta';
	export type { EuiCollapsibleNavItemProps, EuiCollapsibleNavSubItemProps, } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item';
	export { EuiCollapsibleNavItem } from '@elastic/eui/src/components/collapsible_nav_beta/collapsible_nav_item';

}
declare module '@elastic/eui/src/components/color_picker/color_picker_swatch.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiColorPickerSwatchStyles: (euiThemeContext: UseEuiTheme) => {
	    euiColorPickerSwatch: import("@emotion/react").SerializedStyles;
	    tooltip: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/color_picker/color_picker_swatch' {
	import React, { ButtonHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export type EuiColorPickerSwatchProps = CommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color'> & {
	    color?: string;
	    /**
	     * renders a tooltip with the color value to provide a visual text alternative
	     * @default true
	     */
	    showToolTip?: boolean;
	    /** Additional props for the EuiToolTip when `showToolTip={true}` */
	    toolTipProps?: Omit<EuiToolTipProps, 'children' | 'position'> & {
	        position?: EuiToolTipProps['position'];
	    };
	};
	export const EuiColorPickerSwatch: React.ForwardRefExoticComponent<CommonProps & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "color"> & {
	    color?: string;
	    /**
	     * renders a tooltip with the color value to provide a visual text alternative
	     * @default true
	     */
	    showToolTip?: boolean;
	    /** Additional props for the EuiToolTip when `showToolTip={true}` */
	    toolTipProps?: Omit<EuiToolTipProps, "children" | "position"> & {
	        position?: EuiToolTipProps["position"];
	    };
	} & React.RefAttributes<HTMLButtonElement>>;

}
declare module '@elastic/eui/src/components/color_picker/hue.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHueStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHue: import("@emotion/react").SerializedStyles;
	    euiHue__tooltip: import("@emotion/react").SerializedStyles;
	    euiHue__range: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/color_picker/hue' {
	import { InputHTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiHueProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'> & CommonProps & {
	    hex?: string;
	    hue?: string | number;
	    onChange: (hue: number) => void;
	};
	export const EuiHue: FunctionComponent<EuiHueProps>;

}
declare module '@elastic/eui/src/components/color_picker/saturation.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSaturationStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSaturation: import("@emotion/react").SerializedStyles;
	    euiSaturation__lightness: import("@emotion/react").SerializedStyles;
	    euiSaturation__saturation: import("@emotion/react").SerializedStyles;
	    euiSaturation__tooltip: import("@emotion/react").SerializedStyles;
	    euiSaturation__indicator: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/color_picker/saturation' {
	import React, { HTMLAttributes } from 'react';
	import { ColorSpaces } from 'chroma-js';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type SaturationClientRect = Pick<DOMRect, 'left' | 'top' | 'width' | 'height'>;
	export type SaturationPosition = Pick<SaturationClientRect, 'left' | 'top'>;
	interface HTMLDivElementOverrides {
	    color?: ColorSpaces['hsv'];
	    onChange: (color: ColorSpaces['hsv']) => void;
	}
	export type EuiSaturationProps = Omit<HTMLAttributes<HTMLDivElement>, keyof HTMLDivElementOverrides> & CommonProps & HTMLDivElementOverrides & {
	    hex?: string;
	};
	export const EuiSaturation: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, keyof HTMLDivElementOverrides> & CommonProps & HTMLDivElementOverrides & {
	    hex?: string;
	} & React.RefAttributes<HTMLDivElement>>;
	export {};

}
declare module '@elastic/eui/src/components/color_picker/color_picker.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiColorPickerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiColorPicker: import("@emotion/react").SerializedStyles;
	    euiColorPicker__swatches: import("@emotion/react").SerializedStyles;
	    euiColorPicker__alphaRange: import("@emotion/react").SerializedStyles;
	    euiColorPicker__swatchInputIcon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/color_picker/color_picker' {
	import { FunctionComponent, HTMLAttributes, ReactElement } from 'react';
	import { ColorSpaces } from 'chroma-js';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form';
	type EuiColorPickerDisplay = 'default' | 'inline';
	type EuiColorPickerMode = 'default' | 'swatch' | 'picker' | 'secondaryInput';
	export interface EuiColorPickerOutput {
	    rgba: ColorSpaces['rgba'];
	    hex: string;
	    isValid: boolean;
	}
	interface HTMLDivElementOverrides {
	    /**
	     * hex (string)
	     * RGB (as comma separated string)
	     * RGBa (as comma separated string)
	     * Empty string will register as 'transparent'
	     */
	    color?: string | null;
	    onBlur?: () => void;
	    /**
	     * text (string, as entered or selected)
	     * hex (8-digit hex if alpha < 1, otherwise 6-digit hex)
	     * RGBa (as array; values of NaN if color is invalid)
	     * isValid (boolean signifying if the input text is a valid color)
	     */
	    onChange: (text: string, output: EuiColorPickerOutput) => void;
	    onFocus?: () => void;
	}
	export interface EuiColorPickerProps extends CommonProps, Omit<HTMLAttributes<HTMLDivElement>, keyof HTMLDivElementOverrides>, HTMLDivElementOverrides {
	    /**
	     *  Custom element to use instead of text input
	     */
	    button?: ReactElement;
	    /**
	     *  Use the compressed style for EuiFieldText
	     */
	    compressed?: boolean;
	    display?: EuiColorPickerDisplay;
	    disabled?: boolean;
	    fullWidth?: boolean;
	    id?: string;
	    /**
	     *  Custom validation flag
	     */
	    isInvalid?: boolean;
	    /**
	     * Choose between swatches with gradient picker (default), swatches only, gradient picker only, or secondary input only.
	     */
	    mode?: EuiColorPickerMode;
	    /**
	     *  Custom z-index for the popover
	     */
	    popoverZIndex?: number;
	    readOnly?: boolean;
	    /**
	     *  Array of hex strings (3 or 6 character) to use as swatch options. Defaults to EUI visualization colors
	     */
	    swatches?: string[];
	    /**
	     * Creates an input group with element(s) coming before input. It only shows when the `display` is set to `default`.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input. It only shows when the `display` is set to `default`.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * Whether to render the alpha channel (opacity) value range slider.
	     */
	    showAlpha?: boolean;
	    /**
	     * Will format the text input in the provided format when possible (hue and saturation selection)
	     * Exceptions: Manual text input and swatches will display as-authored
	     * Default is to display the last format entered by the user
	     */
	    format?: 'hex' | 'rgba';
	    /**
	     * Placement option for a secondary color value input.
	     */
	    secondaryInputDisplay?: 'top' | 'bottom' | 'none';
	    /**
	     * Add a button to the primary input to clear its value.
	     */
	    isClearable?: boolean;
	    /**
	     * Text to replace the default 'Transparent' placeholder for unset color values.
	     */
	    placeholder?: string;
	}
	export const EuiColorPicker: FunctionComponent<EuiColorPickerProps>;
	export {};

}
declare module '@elastic/eui/src/components/color_picker' {
	export type { EuiColorPickerProps } from '@elastic/eui/src/components/color_picker/color_picker';
	export { EuiColorPicker } from '@elastic/eui/src/components/color_picker/color_picker';
	export type { EuiColorPickerSwatchProps } from '@elastic/eui/src/components/color_picker/color_picker_swatch';
	export { EuiColorPickerSwatch } from '@elastic/eui/src/components/color_picker/color_picker_swatch';
	export type { EuiColorPalettePickerProps, EuiColorPalettePickerPaletteProps, } from '@elastic/eui/src/components/color_picker/color_palette_picker';
	export { EuiColorPalettePicker } from '@elastic/eui/src/components/color_picker/color_palette_picker';
	export type { EuiColorPaletteDisplayProps } from '@elastic/eui/src/components/color_picker/color_palette_display';
	export { EuiColorPaletteDisplay } from '@elastic/eui/src/components/color_picker/color_palette_display';

}
declare module '@elastic/eui/src/components/combo_box/types' {
	import { ButtonHTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import type { _EuiComboBoxProps } from '@elastic/eui/src/components/combo_box/combo_box';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export interface EuiComboBoxOptionOption<T = string | number | string[] | undefined> extends CommonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
	    isGroupLabelOption?: boolean;
	    label: string;
	    key?: string;
	    options?: Array<EuiComboBoxOptionOption<T>>;
	    value?: T;
	    prepend?: ReactNode;
	    append?: ReactNode;
	    truncationProps?: _EuiComboBoxProps<T>['truncationProps'];
	    /**
	     * Optional custom tooltip content for the button
	     */
	    toolTipContent?: EuiToolTipProps['content'];
	    /**
	     * Optional props to pass to the underlying **[EuiToolTip](/#/display/tooltip)**
	     */
	    toolTipProps?: Partial<Omit<EuiToolTipProps, 'content' | 'children'>>;
	}
	export type OptionHandler<T> = (option: EuiComboBoxOptionOption<T>) => void;
	export type RefInstance<T> = T | null;
	export interface EuiComboBoxSingleSelectionShape {
	    asPlainText?: boolean;
	}
	export interface EuiComboBoxOptionMatcherArgs<TOption> {
	    /**
	     * Option being currently processed
	     */
	    option: EuiComboBoxOptionOption<TOption>;
	    /**
	     * Raw search input value
	     */
	    searchValue: string;
	    /**
	     * Search input value normalized for case-sensitivity
	     * and with leading and trailing whitespace characters trimmed
	     */
	    normalizedSearchValue: string;
	    /**
	     * Whether to match the option with case-sensitivity
	     */
	    isCaseSensitive: boolean;
	}
	/**
	 * Option matcher function for EuiComboBox component.
	 *
	 * @example
	 * const equalityMatcher: EuiComboBoxOptionMatcher = ({ option, searchValue }) => {
	 *   return option.label === searchValue;
	 * }
	 */
	export type EuiComboBoxOptionMatcher<TOption> = (args: EuiComboBoxOptionMatcherArgs<TOption>) => boolean;

}
declare module '@elastic/eui/src/components/combo_box/matching_options' {
	import { EuiComboBoxOptionOption, EuiComboBoxOptionMatcher } from '@elastic/eui/src/components/combo_box/types';
	export type SortMatchesBy = 'none' | 'startsWith';
	interface GetMatchingOptions<T> {
	    options: Array<EuiComboBoxOptionOption<T>>;
	    selectedOptions: Array<EuiComboBoxOptionOption<T>>;
	    searchValue: string;
	    optionMatcher: EuiComboBoxOptionMatcher<T>;
	    isCaseSensitive?: boolean;
	    isPreFiltered?: boolean;
	    showPrevSelected?: boolean;
	    sortMatchesBy?: SortMatchesBy;
	}
	interface GetSelectedOptionForSearchValue<T> extends Pick<GetMatchingOptions<T>, 'isCaseSensitive' | 'searchValue' | 'selectedOptions'> {
	    optionKey?: string;
	}
	export const transformForCaseSensitivity: (string: string, isCaseSensitive?: boolean) => string;
	export const flattenOptionGroups: <T>(optionsOrGroups: Array<EuiComboBoxOptionOption<T>>) => EuiComboBoxOptionOption<T>[];
	export const getSelectedOptionForSearchValue: <T>({ isCaseSensitive, searchValue, selectedOptions, optionKey, }: GetSelectedOptionForSearchValue<T>) => EuiComboBoxOptionOption<T> | undefined;
	export const getMatchingOptions: <T>({ options, selectedOptions, searchValue, optionMatcher, isCaseSensitive, isPreFiltered, showPrevSelected, sortMatchesBy, }: GetMatchingOptions<T>) => EuiComboBoxOptionOption<T>[];
	/**
	 * Partial string equality option matcher for EuiComboBox.
	 * It matches all options with labels including the searched string.
	 */
	export const createPartialStringEqualityOptionMatcher: <TOption>() => EuiComboBoxOptionMatcher<TOption>;
	export {};

}
declare module '@elastic/eui/src/components/combo_box/utils' {
	import React, { PropsWithChildren } from 'react';
	import { EuiComboBoxOptionOption } from '@elastic/eui/src/components/combo_box/types';
	/**
	 * DRY util for rendering an option with its prepend and append properties
	 */
	export const EuiComboBoxOptionAppendPrepend: <T>({ children, option, classNamePrefix, marginSize, }: PropsWithChildren & {
	    option?: EuiComboBoxOptionOption<T>;
	    classNamePrefix?: string;
	    marginSize?: "s" | "xs" | "xxs";
	}) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_pill.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiComboBoxPillStyles: (euiThemeContext: UseEuiTheme) => {
	    euiComboBoxPill: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_pill' {
	import React, { AriaAttributes, MouseEventHandler } from 'react';
	import { EuiComboBoxOptionOption, OptionHandler } from '@elastic/eui/src/components/combo_box/types';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiComboBoxPillProps<T> extends CommonProps {
	    children?: string;
	    className?: string;
	    color?: string;
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	    onClickAriaLabel?: AriaAttributes['aria-label'];
	    onClose?: OptionHandler<T>;
	    option: EuiComboBoxOptionOption<T>;
	}
	export const EuiComboBoxPill: <T>({ children, className, color, onClick, onClickAriaLabel, onClose, option, ...rest }: EuiComboBoxPillProps<T>) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_input.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiComboBoxInputStyles: (euiThemeContext: UseEuiTheme) => {
	    euiComboBoxInputWrapper: import("@emotion/react").SerializedStyles;
	    multiSelect: import("@emotion/react").SerializedStyles;
	    uncompressed: string;
	    compressed: import("@emotion/react").SerializedStyles;
	    plainText: {
	        plainText: import("@emotion/react").SerializedStyles;
	        compressed: string;
	        uncompressed: string;
	    };
	    invalid: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    open: import("@emotion/react").SerializedStyles;
	    inGroup: import("@emotion/react").SerializedStyles;
	    euiComboBoxInput: import("@emotion/react").SerializedStyles;
	    formLayout: {
	        euiComboBox__formControlLayout: import("@emotion/react").SerializedStyles;
	        multiSelect: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_input' {
	import React, { Component, FocusEventHandler, KeyboardEventHandler, RefCallback } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { htmlIdGenerator } from '@elastic/eui/src/services';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form/form_control_layout';
	import { EuiComboBoxOptionOption, EuiComboBoxSingleSelectionShape, OptionHandler } from '@elastic/eui/src/components/combo_box/types';
	export interface EuiComboBoxInputProps<T> extends CommonProps {
	    compressed: boolean;
	    focusedOptionId?: string;
	    fullWidth?: boolean;
	    hasSelectedOptions: boolean;
	    id?: string;
	    inputRef?: RefCallback<HTMLInputElement>;
	    isDisabled?: boolean;
	    isListOpen: boolean;
	    noIcon: boolean;
	    onBlur?: FocusEventHandler<HTMLInputElement>;
	    onChange: (searchValue: string) => void;
	    onClear?: () => void;
	    onClick: () => void;
	    onCloseListClick: () => void;
	    onFocus: FocusEventHandler<HTMLInputElement>;
	    onOpenListClick: () => void;
	    onRemoveOption: OptionHandler<T>;
	    placeholder?: string;
	    rootId: ReturnType<typeof htmlIdGenerator>;
	    searchValue: string;
	    selectedOptions: Array<EuiComboBoxOptionOption<T>>;
	    singleSelection?: boolean | EuiComboBoxSingleSelectionShape;
	    toggleButtonRef?: RefCallback<HTMLButtonElement | HTMLSpanElement>;
	    value?: string;
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    append?: EuiFormControlLayoutProps['append'];
	    isLoading?: boolean;
	    isInvalid?: boolean;
	    autoFocus?: boolean;
	    'aria-label'?: string;
	    'aria-labelledby'?: string;
	    'aria-describedby'?: string;
	}
	interface EuiComboBoxInputState {
	    inputWidth: number;
	    hasFocus: boolean;
	}
	export class EuiComboBoxInput<T> extends Component<EuiComboBoxInputProps<T>, EuiComboBoxInputState> {
	    state: EuiComboBoxInputState;
	    private widthUtils?;
	    inputRefCallback: (el: HTMLInputElement) => void;
	    updateInputSize: (inputValue: string) => void;
	    componentDidUpdate(prevProps: EuiComboBoxInputProps<T>): void;
	    onFocus: FocusEventHandler<HTMLInputElement>;
	    onBlur: FocusEventHandler<HTMLInputElement>;
	    onKeyDown: KeyboardEventHandler<HTMLInputElement>;
	    get asPlainText(): boolean;
	    get searchValue(): string;
	    renderPills: () => React.JSX.Element[] | null;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/mark/mark.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMark: import("@emotion/react").SerializedStyles;
	};
	export const euiMarkScreenReaderStyles: (highlightStart: string, highlightEnd: string) => {
	    hasScreenReaderHelpText: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/mark/mark' {
	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiMarkProps = HTMLAttributes<HTMLElement> & CommonProps & {
	    /**
	     * Set to `false` to remove the CSS :before and :after
	     * screen reader helper text
	     */
	    hasScreenReaderHelpText?: boolean;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	};
	export const EuiMark: FunctionComponent<EuiMarkProps>;

}
declare module '@elastic/eui/src/components/mark' {
	export type { EuiMarkProps } from '@elastic/eui/src/components/mark/mark';
	export { EuiMark } from '@elastic/eui/src/components/mark/mark';

}
declare module '@elastic/eui/src/components/highlight/_highlight_all' {
	import { FunctionComponent } from 'react';
	import type { _SharedSubcomponentProps } from '@elastic/eui/src/components/highlight/highlight';
	/**
	 * Internal subcomponent with logic for highlighting all occurrences
	 * of a search value within a subject
	 *
	 * Uses regex rather than indexOf/while loops for easier dev maintainability
	 */
	export const HighlightAll: FunctionComponent<_SharedSubcomponentProps>;

}
declare module '@elastic/eui/src/components/highlight/_highlight_first' {
	import { FunctionComponent } from 'react';
	import { _SharedSubcomponentProps } from '@elastic/eui/src/components/highlight/highlight';
	/**
	 * Internal subcomponent with logic for highlighting only the first occurrence
	 * of a search value within a subject
	 *
	 * Uses indexOf for performance (which does matter for, e.g. EuiSelectable searching)
	 */
	export const HighlightFirst: FunctionComponent<_SharedSubcomponentProps>;

}
declare module '@elastic/eui/src/components/highlight/highlight' {
	import { HTMLAttributes, FunctionComponent, ElementType } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiMarkProps } from '@elastic/eui/src/components/mark';
	export type EuiHighlightProps = HTMLAttributes<HTMLSpanElement> & Pick<EuiMarkProps, 'hasScreenReaderHelpText'> & CommonProps & {
	    /**
	     * string to highlight as this component's content
	     */
	    children: string;
	    /**
	     * What to search for.
	     *
	     * Allows passing an array of strings (searching by multiple separate
	     * words or phrases) **only** if `highlightAll` is also set to `true`.
	     */
	    search: string | string[];
	    /**
	     * Should the search be strict or not
	     */
	    strict?: boolean;
	    /**
	     * Should highlight all matches
	     */
	    highlightAll?: boolean;
	};
	export const EuiHighlight: FunctionComponent<EuiHighlightProps>;
	export type _SharedSubcomponentProps = {
	    searchValue: EuiHighlightProps['search'];
	    searchSubject: EuiHighlightProps['children'];
	    isStrict: EuiHighlightProps['strict'];
	    highlightComponent?: ElementType;
	};

}
declare module '@elastic/eui/src/components/highlight' {
	export type { EuiHighlightProps } from '@elastic/eui/src/components/highlight/highlight';
	export { EuiHighlight } from '@elastic/eui/src/components/highlight/highlight';

}
declare module '@elastic/eui/src/components/filter_group/filter_select_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFilterSelectItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFilterSelectItem: import("@emotion/react").SerializedStyles;
	    isFocused: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/filter_group/filter_select_item' {
	import React, { ButtonHTMLAttributes, Component } from 'react';
	import { WithEuiThemeProps } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import type { EuiToolTipRef } from '@elastic/eui/src/components/tool_tip';
	import { EuiComboBoxOptionOption } from '@elastic/eui/src/components/combo_box';
	export type FilterChecked = 'on' | 'off';
	export interface EuiFilterSelectItemProps extends CommonProps, ButtonHTMLAttributes<HTMLButtonElement> {
	    checked?: FilterChecked;
	    showIcons?: boolean;
	    isFocused?: boolean;
	    truncateContent?: boolean;
	    toolTipContent?: EuiComboBoxOptionOption['toolTipContent'];
	    toolTipProps?: EuiComboBoxOptionOption['toolTipProps'];
	    forwardRef?: (ref: HTMLButtonElement | null) => void;
	}
	/**
	 * TODO: This component should removed in favor of EuiSelectable usage
	 * once EuiComboBox has been converted to dogfood EuiSelectable.
	 *
	 * @deprecated - Use EuiSelectable instead
	 */
	export class EuiFilterSelectItemClass extends Component<WithEuiThemeProps & EuiFilterSelectItemProps> {
	    static defaultProps: {
	        showIcons: boolean;
	        truncateContent: boolean;
	    };
	    buttonRef: HTMLButtonElement | null;
	    tooltipRef: React.RefObject<EuiToolTipRef>;
	    state: {
	        hasFocus: boolean;
	    };
	    setButtonRef: (node: HTMLButtonElement | null) => void;
	    focus: () => void;
	    toggleToolTip: (isFocused: boolean) => void;
	    hasFocus: () => boolean;
	    componentDidMount(): void;
	    componentDidUpdate(prevProps: Readonly<WithEuiThemeProps<{}> & EuiFilterSelectItemProps>): void;
	    render(): React.JSX.Element;
	}
	/**
	 * @deprecated - Use EuiSelectable instead
	 */
	export const EuiFilterSelectItem: React.ForwardRefExoticComponent<Omit<EuiFilterSelectItemProps, "theme"> & React.RefAttributes<Omit<EuiFilterSelectItemProps, "theme">>>;

}
declare module '@elastic/eui/src/components/selectable/selectable_list/selectable_list.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSelectableListStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSelectableList: import("@emotion/react").SerializedStyles;
	    fullHeight: import("@emotion/react").SerializedStyles;
	    bordered: import("@emotion/react").SerializedStyles;
	    paddingSize: {
	        s: import("@emotion/react").SerializedStyles;
	    };
	    euiSelectableList__list: string;
	};
	export const euiSelectableListGroupLabelStyles: (euiThemeContext: UseEuiTheme) => {
	    groupLabel: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/selectable/selectable_list/utils/get_list_item_size' {
	/**
	 * Util to calculate (virtualized) selection list item size
	 */
	export const getListItemSize: (index: number, rowHeight: number, isGroupLabel: boolean) => number;

}
declare module '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_options_list.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const LIST_MAX_HEIGHT = 200;
	export const euiComboBoxOptionListStyles: (euiThemeContext: UseEuiTheme) => {
	    euiComboBoxOptionList: import("@emotion/react").SerializedStyles;
	    hasRowHeightAuto: import("@emotion/react").SerializedStyles;
	    euiComboBoxOptionList__virtualization: import("@emotion/react").SerializedStyles;
	    euiComboBoxOptionsList__empty: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_options_list' {
	import React, { Component, ContextType, ReactNode, RefCallback, RefObject } from 'react';
	import { ListProps, ListChildComponentProps, VariableSizeList, VariableSizeListProps } from 'react-window';
	import { htmlIdGenerator } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiInputPopoverWidthContext } from '@elastic/eui/src/components/popover/input_popover';
	import type { _EuiComboBoxProps } from '@elastic/eui/src/components/combo_box/combo_box';
	import { EuiComboBoxOptionOption, EuiComboBoxSingleSelectionShape, OptionHandler } from '@elastic/eui/src/components/combo_box/types';
	export type EuiComboBoxOptionsListProps<T> = CommonProps & {
	    activeOptionIndex?: number;
	    areAllOptionsSelected?: boolean;
	    listboxAriaLabel: string;
	    /**
	     * Creates a custom text option. You can use `{searchValue}` inside your string to better customize your text.
	     * It won't show if there's no onCreateOption.
	     */
	    customOptionText?: string;
	    fullWidth?: boolean;
	    getSelectedOptionForSearchValue?: (params: {
	        isCaseSensitive?: boolean;
	        searchValue: string;
	        selectedOptions: any[];
	    }) => EuiComboBoxOptionOption<T> | undefined;
	    isCaseSensitive?: boolean;
	    isLoading?: boolean;
	    listRef: RefCallback<HTMLDivElement>;
	    setListOptionRefs: (ref: HTMLLIElement | null, index: number) => void;
	    matchingOptions: Array<EuiComboBoxOptionOption<T>>;
	    onCloseList: (event: Event) => void;
	    onCreateOption?: (searchValue: string, options: Array<EuiComboBoxOptionOption<T>>) => boolean | void;
	    onOptionClick?: OptionHandler<T>;
	    onOptionEnterKey?: OptionHandler<T>;
	    onScroll?: ListProps['onScroll'];
	    /**
	     * Array of EuiComboBoxOptionOption objects. See {@link EuiComboBoxOptionOption}
	     */
	    options: Array<EuiComboBoxOptionOption<T>>;
	    renderOption?: (option: EuiComboBoxOptionOption<T>, searchValue: string, OPTION_CONTENT_CLASSNAME: string) => ReactNode;
	    rootId: ReturnType<typeof htmlIdGenerator>;
	    rowHeight: number | 'auto';
	    scrollToIndex?: number;
	    searchValue: string;
	    selectedOptions: Array<EuiComboBoxOptionOption<T>>;
	    singleSelection?: boolean | EuiComboBoxSingleSelectionShape;
	    delimiter?: string;
	    truncationProps?: _EuiComboBoxProps<T>['truncationProps'];
	    onFocusBadge?: boolean;
	};
	export class EuiComboBoxOptionsList<T> extends Component<EuiComboBoxOptionsListProps<T>> {
	    listRef: VariableSizeList | null;
	    listBoxRef: RefObject<HTMLUListElement>;
	    optionRefs: Record<number, HTMLLIElement | null>;
	    static contextType: React.Context<number>;
	    context: ContextType<typeof EuiInputPopoverWidthContext>;
	    static defaultProps: {
	        'data-test-subj': string;
	        rowHeight: number;
	        isCaseSensitive: boolean;
	    };
	    componentDidUpdate(prevProps: EuiComboBoxOptionsListProps<T>): void;
	    setListRef: (ref: VariableSizeList | null) => void;
	    setOptionRef: (ref: HTMLLIElement | null, index: number) => void;
	    ListInnerElement: VariableSizeListProps['innerElementType'];
	    ListRow: ({ data, index, style }: ListChildComponentProps) => React.JSX.Element;
	    getListInnerElementProps: () => {
	        'aria-label': string;
	        id: string;
	        role: string;
	        'aria-multiselectable': boolean | undefined;
	        tabIndex: number;
	    };
	    optionWidth: number | undefined;
	    setOptionWidth: (width: number) => void;
	    renderTruncatedOption: (text: string, truncationProps?: EuiComboBoxOptionsListProps<T>["truncationProps"]) => string | React.JSX.Element;
	    renderVariableHeightOption: (text: string) => string | React.JSX.Element;
	    renderHighlightedOptionText: (text: string, searchValue: string) => React.JSX.Element;
	    getItemSize: (index: number) => number;
	    render(): React.JSX.Element;
	}

}
declare module '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_title' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	export const EuiComboBoxTitle: FunctionComponent<PropsWithChildren>;

}
declare module '@elastic/eui/src/components/combo_box/combo_box_options_list' {
	export type { EuiComboBoxOptionsListProps } from '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_options_list';
	export { EuiComboBoxOptionsList } from '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_options_list';
	export { EuiComboBoxTitle } from '@elastic/eui/src/components/combo_box/combo_box_options_list/combo_box_title';

}
declare module '@elastic/eui/src/components/combo_box/combo_box.styles' {
	export const euiComboBoxStyles: {
	    euiComboBox: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/combo_box/combo_box' {
	/**
	 * Elements within EuiComboBox which would normally be tabbable (inputs, buttons) have been removed
	 * from the tab order with tabindex={-1} so that we can control the keyboard navigation interface.
	 */
	import React, { Component, FocusEventHandler, HTMLAttributes, KeyboardEventHandler, RefCallback } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiInputPopoverProps } from '@elastic/eui/src/components/popover';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form';
	import type { EuiTextTruncateProps } from '@elastic/eui/src/components/text_truncate';
	import { SortMatchesBy } from '@elastic/eui/src/components/combo_box/matching_options';
	import { EuiComboBoxInputProps } from '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_input';
	import { OptionHandler, RefInstance, EuiComboBoxOptionOption, EuiComboBoxSingleSelectionShape, EuiComboBoxOptionMatcher } from '@elastic/eui/src/components/combo_box/types';
	import { type EuiComboBoxOptionsListProps } from '@elastic/eui/src/components/combo_box/combo_box_options_list';
	type DrillProps<T> = Pick<EuiComboBoxOptionsListProps<T>, 'customOptionText' | 'onCreateOption' | 'options' | 'renderOption' | 'selectedOptions' | 'onFocusBadge'>;
	export interface _EuiComboBoxProps<T> extends CommonProps, Omit<HTMLAttributes<HTMLDivElement>, 'onChange'>, DrillProps<T> {
	    'data-test-subj'?: string;
	    /**
	     * Updates the list of options asynchronously
	     */
	    async: boolean;
	    className?: string;
	    /**
	     * When `true` creates a shorter height input
	     */
	    compressed: boolean;
	    /**
	     * When `true` expands to the entire width available
	     */
	    fullWidth: boolean;
	    id?: string;
	    inputRef?: RefCallback<HTMLInputElement>;
	    /**
	     * Shows a button that quickly clears any input
	     */
	    isClearable: boolean;
	    /**
	     * Disables the input
	     */
	    isDisabled?: boolean;
	    isInvalid?: boolean;
	    /**
	     * Swaps the dropdown options for a loading spinner
	     */
	    isLoading?: boolean;
	    /**
	     * Doesn't show the suggestions list/dropdown
	     */
	    noSuggestions?: boolean;
	    onBlur?: FocusEventHandler<HTMLDivElement>;
	    /**
	     * Called every time the query in the combo box is parsed
	     */
	    onChange?: (options: Array<EuiComboBoxOptionOption<T>>) => void;
	    onFocus?: FocusEventHandler<HTMLDivElement>;
	    onKeyDown?: KeyboardEventHandler<HTMLDivElement>;
	    /**
	     * Called every time the text query in the search box is parsed
	     */
	    onSearchChange?: (searchValue: string, hasMatchingOptions?: boolean) => void;
	    /**
	     * Sets the placeholder of the input
	     */
	    placeholder?: string;
	    /**
	     *  The height of each option in pixels. When using a custom render (`renderOption` prop) it's recommended to set it explicitly.
	     * `auto` will disable virtualization, enabling text to wrap onto multiple lines.
	     */
	    rowHeight?: number | 'auto';
	    /**
	     * When `true` only allows the user to select a single option. Set to `{ asPlainText: true }` to not render input selection as pills
	     */
	    singleSelection: boolean | EuiComboBoxSingleSelectionShape;
	    /**
	     * Display matching options by:
	     * `startsWith`: moves items that start with search value to top of the list;
	     * `none`: don't change the sort order of initial object
	     */
	    sortMatchesBy: SortMatchesBy;
	    /**
	     * Whether to match options with case sensitivity.
	     */
	    isCaseSensitive?: boolean;
	    /**
	     * Optional custom option matcher function
	     *
	     * @example
	     * const exactEqualityMatcher: EuiComboBoxOptionMatcher = ({ option, searchValue }) => {
	     *   return option.label === searchValue;
	     * }
	     */
	    optionMatcher?: EuiComboBoxOptionMatcher<T>;
	    /**
	     * Creates an input group with element(s) coming before input. It won't show if `singleSelection` is set to `false`.
	     * `string` | `ReactElement` or an array of these
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Creates an input group with element(s) coming after input. It won't show if `singleSelection` is set to `false`.
	     * `string` | `ReactElement` or an array of these
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * A special character to use as a value separator. Typically a comma `,`
	     */
	    delimiter?: string;
	    /**
	     * Specifies that the input should have focus when the component loads
	     */
	    autoFocus?: boolean;
	    /**
	     * Required when rendering without a visible label from [EuiFormRow](/#/forms/form-layouts).
	     */
	    'aria-label'?: string;
	    /**
	     * Reference ID of a text element containing the visible label for the combo box when not
	     * supplied by `aria-label` or from [EuiFormRow](/#/forms/form-layouts).
	     */
	    'aria-labelledby'?: string;
	    /**
	     * By default, EuiComboBox will truncate option labels at the end of
	     * the string. You can pass in a custom truncation configuration that
	     * accepts any [EuiTextTruncate](/#/utilities/text-truncation) prop,
	     * except for `text` and `children`.
	     *
	     * Note: when searching, custom truncation props are ignored. The highlighted search
	     * text will always take precedence.
	     */
	    truncationProps?: Partial<Omit<EuiTextTruncateProps, 'text' | 'children'>>;
	    /**
	     * Allows customizing the underlying EuiInputPopover component
	     * (except for props that control state).
	     */
	    inputPopoverProps?: Partial<Omit<EuiInputPopoverProps, 'input' | 'isOpen' | 'closePopover'>>;
	}
	/**
	 * Because of how TypeScript's LibraryManagedAttributes is designed to handle defaultProps (https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#support-for-defaultprops-in-jsx)
	 * we can't directly export the above Props definitions, as the defaulted values are not made optional
	 * as it isn't processed by LibraryManagedAttributes. To get around this, we:
	 * - remove the props which have default values applied
	 *   - additionally re-define `options` and `selectedOptions` defaults, necessary as static members can't access generics and become never[]
	 * - export (Props - Defaults) & Partial<Defaults>
	 */
	type DefaultProps<T> = Omit<(typeof EuiComboBox)['defaultProps'], 'options' | 'selectedOptions' | 'optionMatcher'> & {
	    options: Array<EuiComboBoxOptionOption<T>>;
	    selectedOptions: Array<EuiComboBoxOptionOption<T>>;
	    optionMatcher: EuiComboBoxOptionMatcher<T>;
	};
	export type EuiComboBoxProps<T> = Omit<_EuiComboBoxProps<T>, keyof DefaultProps<T>> & Partial<DefaultProps<T>>;
	interface EuiComboBoxState<T> {
	    activeOptionIndex: number;
	    hasFocus: boolean;
	    isListOpen: boolean;
	    matchingOptions: Array<EuiComboBoxOptionOption<T>>;
	    listOptionRefs: Array<HTMLLIElement | null>;
	    searchValue: string;
	}
	export class EuiComboBox<T> extends Component<_EuiComboBoxProps<T>, EuiComboBoxState<T>> {
	    static defaultProps: {
	        async: boolean;
	        compressed: boolean;
	        fullWidth: boolean;
	        isClearable: boolean;
	        options: never[];
	        selectedOptions: never[];
	        singleSelection: boolean;
	        prepend: undefined;
	        append: undefined;
	        sortMatchesBy: "none";
	        optionMatcher: EuiComboBoxOptionMatcher<unknown>;
	    };
	    state: EuiComboBoxState<T>;
	    rootId: (idSuffix?: string) => string;
	    comboBoxRefInstance: RefInstance<HTMLDivElement>;
	    comboBoxRefCallback: RefCallback<HTMLDivElement>;
	    searchInputRefInstance: RefInstance<HTMLInputElement>;
	    searchInputRefCallback: RefCallback<HTMLInputElement>;
	    listRefInstance: RefInstance<HTMLDivElement>;
	    listRefCallback: RefCallback<HTMLDivElement>;
	    setListOptionRefs: (node: HTMLLIElement | null, index: number) => void;
	    openList: () => void;
	    closeList: () => void;
	    findNextSelectableOptionIndex: (options: Array<EuiComboBoxOptionOption<T>>, startIndex: number, direction?: 1 | -1) => number;
	    incrementActiveOptionIndex: (amount: number) => void;
	    hasActiveOption: () => boolean;
	    clearActiveOption: () => void;
	    clearSearchValue: () => void;
	    addCustomOption: (isContainerBlur: boolean, searchValue: string) => void;
	    doesSearchMatchOnlyOption: () => EuiComboBoxOptionOption<T> | undefined;
	    areAllOptionsSelected: () => boolean;
	    onComboBoxFocus: FocusEventHandler<HTMLInputElement>;
	    setCustomOptions: (isContainerBlur: boolean) => void;
	    onContainerBlur: FocusEventHandler<HTMLDivElement>;
	    onKeyDown: KeyboardEventHandler<HTMLDivElement>;
	    onOptionEnterKey: OptionHandler<T>;
	    onOptionClick: OptionHandler<T>;
	    onAddOption: (addedOption: EuiComboBoxOptionOption<T>, isContainerBlur?: boolean) => void;
	    onRemoveOption: OptionHandler<T>;
	    clearSelectedOptions: () => void;
	    onComboBoxClick: () => void;
	    onOpenListClick: () => void;
	    onOptionListScroll: () => void;
	    onSearchChange: NonNullable<EuiComboBoxInputProps<T>['onChange']>;
	    static getDerivedStateFromProps<T>(nextProps: _EuiComboBoxProps<T>, prevState: EuiComboBoxState<T>): Partial<EuiComboBoxState<T>>;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/combo_box/combo_box_input' {
	export type { EuiComboBoxInputProps } from '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_input';
	export { EuiComboBoxInput } from '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_input';
	export type { EuiComboBoxPillProps } from '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_pill';
	export { EuiComboBoxPill } from '@elastic/eui/src/components/combo_box/combo_box_input/combo_box_pill';

}
declare module '@elastic/eui/src/components/combo_box' {
	export type { EuiComboBoxProps } from '@elastic/eui/src/components/combo_box/combo_box';
	export { EuiComboBox } from '@elastic/eui/src/components/combo_box/combo_box';
	export * from '@elastic/eui/src/components/combo_box/combo_box_input';
	export * from '@elastic/eui/src/components/combo_box/combo_box_options_list';
	export type { EuiComboBoxOptionOption, EuiComboBoxSingleSelectionShape, EuiComboBoxOptionMatcher, EuiComboBoxOptionMatcherArgs, } from '@elastic/eui/src/components/combo_box/types';
	export { createPartialStringEqualityOptionMatcher } from '@elastic/eui/src/components/combo_box/matching_options';

}
declare module '@elastic/eui/src/components/timeline/timeline_item_event.styles' {
	export const euiTimelineItemEventStyles: () => {
	    euiTimelineItemEvent: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/timeline/timeline_item_event' {
	import { FunctionComponent, ReactNode } from 'react';
	import { EuiTimelineItemVerticalAlign } from '@elastic/eui/src/components/timeline/timeline_item';
	export interface EuiTimelineItemEventProps {
	    /**
	     * Accepts any node. But preferably `EuiPanel`
	     */
	    children: ReactNode;
	    verticalAlign?: EuiTimelineItemVerticalAlign;
	}
	export const EuiTimelineItemEvent: FunctionComponent<EuiTimelineItemEventProps>;

}
declare module '@elastic/eui/src/components/timeline/timeline_item_icon.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTimelineItemIconStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTimelineItemIcon: import("@emotion/react").SerializedStyles;
	    euiTimelineItemIcon__content: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/timeline/timeline_item_icon' {
	import { FunctionComponent, ReactNode } from 'react';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiTimelineItemVerticalAlign } from '@elastic/eui/src/components/timeline/timeline_item';
	export interface EuiTimelineItemIconProps {
	    /**
	     * Any `ReactNode`, but preferably `EuiAvatar`, or a `string` as an `EuiIcon['type']`.
	     */
	    icon: ReactNode | IconType;
	    verticalAlign?: EuiTimelineItemVerticalAlign;
	    /**
	     * Specify an `aria-label` for the icon when passed as an `IconType`.
	     * If no `aria-label` is passed we assume the icon is purely decorative.
	     */
	    iconAriaLabel?: string;
	}
	export const EuiTimelineItemIcon: FunctionComponent<EuiTimelineItemIconProps>;

}
declare module '@elastic/eui/src/components/timeline/timeline_item.styles' {
	export const euiTimelineItemStyles: () => {
	    euiTimelineItem: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/timeline/timeline_item' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTimelineItemEventProps } from '@elastic/eui/src/components/timeline/timeline_item_event';
	import { EuiTimelineItemIconProps } from '@elastic/eui/src/components/timeline/timeline_item_icon';
	export const VERTICAL_ALIGN: readonly ["top", "center"];
	export type EuiTimelineItemVerticalAlign = (typeof VERTICAL_ALIGN)[number];
	export interface EuiTimelineItemProps extends Omit<HTMLAttributes<HTMLElement>, 'children'>, CommonProps, Omit<EuiTimelineItemIconProps, 'verticalAlign'>, Omit<EuiTimelineItemEventProps, 'verticalAlign'> {
	    /**
	     * Vertical alignment of the event with the icon
	     */
	    verticalAlign?: EuiTimelineItemVerticalAlign;
	}
	export const EuiTimelineItem: FunctionComponent<EuiTimelineItemProps>;

}
declare module '@elastic/eui/src/components/timeline/timeline.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTimelineStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTimeline: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/timeline/timeline' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTimelineItemProps } from '@elastic/eui/src/components/timeline/timeline_item';
	export const GUTTER_SIZES: readonly ["m", "l", "xl"];
	export type EuiTimelineGutterSize = (typeof GUTTER_SIZES)[number];
	export interface EuiTimelineProps extends HTMLAttributes<HTMLOListElement>, CommonProps {
	    /**
	     * List of timeline items to render. See {@link EuiTimelineItem}
	     */
	    items?: EuiTimelineItemProps[];
	    /**
	     * Sets the size of the vertical space between each timeline item
	     */
	    gutterSize?: EuiTimelineGutterSize;
	}
	export const EuiTimeline: FunctionComponent<EuiTimelineProps>;

}
declare module '@elastic/eui/src/components/timeline' {
	export type { EuiTimelineProps } from '@elastic/eui/src/components/timeline/timeline';
	export { EuiTimeline } from '@elastic/eui/src/components/timeline/timeline';
	export type { EuiTimelineItemProps, EuiTimelineItemVerticalAlign, } from '@elastic/eui/src/components/timeline/timeline_item';
	export { EuiTimelineItem } from '@elastic/eui/src/components/timeline/timeline_item';
	export { EuiTimelineItemEvent } from '@elastic/eui/src/components/timeline/timeline_item_event';
	export { EuiTimelineItemIcon } from '@elastic/eui/src/components/timeline/timeline_item_icon';

}
declare module '@elastic/eui/src/components/comment_list/comment_event.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiCommentEventStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCommentEvent: import("@emotion/react").SerializedStyles;
	    border: import("@emotion/react").SerializedStyles;
	};
	export const euiCommentEventHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiCommentEvent__header: import("@emotion/react").SerializedStyles;
	    border: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerMain: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerData: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerEventIcon: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerUsername: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerEvent: import("@emotion/react").SerializedStyles;
	    euiCommentEvent__headerActions: import("@emotion/react").SerializedStyles;
	};
	export const euiCommentEventBodyStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiCommentEvent__body: import("@emotion/react").SerializedStyles;
	    regular: import("@emotion/react").SerializedStyles;
	    update: import("@emotion/react").SerializedStyles;
	    custom: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/comment_list/comment_event' {
	import { FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiPanelProps } from '@elastic/eui/src/components/panel';
	export interface EuiCommentEventProps extends CommonProps {
	    /**
	     * Author of the comment.
	     */
	    username: ReactNode;
	    /**
	     * Time of occurrence of the event. Its format is set on the consumer's side
	     */
	    timestamp?: ReactNode;
	    /**
	     * Describes the event that took place
	     */
	    event?: ReactNode;
	    /**
	     * Custom actions that the user can perform from the comment's header
	     */
	    actions?: ReactNode | ReactNode[];
	    /**
	     * Accepts any ReactNode. Renders in a panel within the comment event.
	     */
	    children?: ReactNode;
	    /**
	     * Custom icon that shows before the username.
	     */
	    eventIcon?: IconType;
	    /**
	     * Specify an `aria-label` for the `eventIcon`.
	     * If no `aria-label` is passed we assume the icon is purely decorative.
	     */
	    eventIconAriaLabel?: string;
	    /**
	     * Background color for the comment's header.
	     */
	    eventColor?: EuiPanelProps['color'];
	}
	export const EuiCommentEvent: FunctionComponent<EuiCommentEventProps>;

}
declare module '@elastic/eui/src/components/comment_list/comment_timeline' {
	import { FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiAvatarProps } from '@elastic/eui/src/components/avatar';
	export interface EuiCommentTimelineProps extends CommonProps {
	    /**
	     * Main avatar that accompanies the comment. Should indicate who is the author of the comment.
	     * Any `ReactNode`, but preferably `EuiAvatar`, or a `string` as an `EuiAvatarProps['iconType']`.
	     * If no `timelineAvatar` is passed, the `user` icon will be used as the avatar.
	     */
	    timelineAvatar?: ReactNode | EuiAvatarProps['iconType'];
	    /**
	     * Specify an `aria-label` and `title` for the `timelineAvatar` when passed as an `IconType` or when nothing is passed.
	     * If no `timelineAvatarAriaLabel` is passed we assume the avatar is purely decorative.
	     */
	    timelineAvatarAriaLabel?: string;
	}
	export const EuiCommentTimeline: FunctionComponent<EuiCommentTimelineProps>;

}
declare module '@elastic/eui/src/components/comment_list/comment' {
	import { FunctionComponent } from 'react';
	import { EuiTimelineItemProps } from '@elastic/eui/src/components/timeline';
	import { EuiCommentEventProps } from '@elastic/eui/src/components/comment_list/comment_event';
	import { EuiCommentTimelineProps } from '@elastic/eui/src/components/comment_list/comment_timeline';
	export interface EuiCommentProps extends EuiCommentEventProps, EuiCommentTimelineProps, Omit<EuiTimelineItemProps, 'children' | 'icon' | 'iconAriaLabel'> {
	}
	export const EuiComment: FunctionComponent<EuiCommentProps>;

}
declare module '@elastic/eui/src/components/comment_list/comment_list' {
	import { FunctionComponent } from 'react';
	import { EuiCommentProps } from '@elastic/eui/src/components/comment_list/comment';
	import { EuiTimelineProps } from '@elastic/eui/src/components/timeline';
	export type EuiCommentListProps = Omit<EuiTimelineProps, 'items' | 'gutterSize'> & {
	    /**
	     * List of comments to render. See {@link EuiComment}
	     */
	    comments?: EuiCommentProps[];
	    /**
	     * Sets the size of the vertical space between each comment
	     */
	    gutterSize?: EuiTimelineProps['gutterSize'];
	};
	export const EuiCommentList: FunctionComponent<EuiCommentListProps>;

}
declare module '@elastic/eui/src/components/comment_list' {
	export type { EuiCommentProps } from '@elastic/eui/src/components/comment_list/comment';
	export { EuiComment } from '@elastic/eui/src/components/comment_list/comment';
	export type { EuiCommentEventProps } from '@elastic/eui/src/components/comment_list/comment_event';
	export { EuiCommentEvent } from '@elastic/eui/src/components/comment_list/comment_event';
	export type { EuiCommentListProps } from '@elastic/eui/src/components/comment_list/comment_list';
	export { EuiCommentList } from '@elastic/eui/src/components/comment_list/comment_list';

}
declare module '@elastic/eui/src/components/datagrid/utils/data_grid_schema' {
	import { EuiDataGridColumn, EuiDataGridInMemory, EuiDataGridInMemoryValues, EuiDataGridSchema, EuiDataGridSchemaDetector } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const schemaDetectors: EuiDataGridSchemaDetector[];
	export const defaultComparator: NonNullable<EuiDataGridSchemaDetector['comparator']>;
	/**
	 * Schema detection & merging used by EuiDataGrid
	 */
	interface UseSchemaProps {
	    columns: EuiDataGridColumn[];
	    inMemory: EuiDataGridInMemory | undefined;
	    inMemoryValues: EuiDataGridInMemoryValues;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    autoDetectSchema: boolean;
	}
	export const useDefinedColumnSchemas: (columns: EuiDataGridColumn[]) => {
	    [key: string]: string;
	};
	export const useDetectSchema: ({ columns, inMemory, inMemoryValues, schemaDetectors, autoDetectSchema, }: UseSchemaProps) => EuiDataGridSchema;
	export const useMergedSchema: (props: UseSchemaProps) => {
	    [columnId: string]: {
	        columnType: string | null;
	    };
	};
	/**
	 * Schema utils used by columns
	 */
	export const getDetailsForSchema: (detectors: EuiDataGridSchemaDetector[], providedSchema: string | null) => EuiDataGridSchemaDetector;
	export {};

}
declare module '@elastic/eui/src/components/datagrid/utils/sorting' {
	import { DataGridSortedContextShape, EuiDataGridSorting, EuiDataGridInMemory, EuiDataGridInMemoryValues, EuiDataGridSchema, EuiDataGridSchemaDetector } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const DataGridSortedContext: import("react").Context<DataGridSortedContextShape>;
	export type useSortingArgs = {
	    sorting?: EuiDataGridSorting;
	    inMemory?: EuiDataGridInMemory;
	    inMemoryValues: EuiDataGridInMemoryValues;
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    startRow: number;
	};
	export const useSorting: ({ sorting, inMemory, inMemoryValues, schema, schemaDetectors, startRow, }: useSortingArgs) => {
	    sortedRowMap: number[];
	    getCorrectRowIndex: (visibleRowIndex: number) => number;
	};

}
declare module '@elastic/eui/src/components/datagrid/utils/row_heights' {
	import { MutableRefObject } from 'react';
	import { GridOnItemsRenderedProps } from 'react-window';
	import { EuiDataGridColumn, EuiDataGridRowHeightOption, EuiDataGridRowHeightsOptions, EuiDataGridScrollAnchorRow, ImperativeGridApi } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export type RowHeightUtilsType = RowHeightUtils | RowHeightVirtualizationUtils;
	export class RowHeightUtils {
	    getRowHeightOption(rowIndex: number, rowHeightsOptions?: EuiDataGridRowHeightsOptions): EuiDataGridRowHeightOption | undefined;
	    isRowHeightOverride(rowIndex: number, rowHeightsOptions?: EuiDataGridRowHeightsOptions): boolean;
	    getCalculatedHeight(heightOption: EuiDataGridRowHeightOption, defaultHeight: number, rowIndex?: number, rowHeightsOptions?: EuiDataGridRowHeightsOptions): number;
	    /**
	     * Height types
	     */
	    getHeightType: (option?: EuiDataGridRowHeightOption) => "auto" | "default" | "lineCount" | "numerical";
	    /**
	     * Line count utils
	     */
	    getLineCount(option?: EuiDataGridRowHeightOption): number | undefined;
	    calculateHeightForLineCount(cellRef: HTMLElement, lineCount: number): number;
	    isAutoBelowLineCount(options?: EuiDataGridRowHeightsOptions, option?: EuiDataGridRowHeightOption): boolean;
	    /**
	     * Auto height utils
	     */
	    isAutoHeight(rowIndex: number, rowHeightsOptions?: EuiDataGridRowHeightsOptions): boolean;
	    /**
	     * Heights cache utils
	     * This cache is primarily used by auto heights & secondarily used by lineCount row overrides
	     */
	    private heightsCache;
	    getRowHeight(rowIndex: number): number;
	    setRowHeight(rowIndex: number, colId: string, height: number | undefined, _visibleRowIndex: number): boolean;
	    pruneHiddenColumnHeights(visibleColumns: EuiDataGridColumn[]): boolean;
	}
	/**
	 * Row height utils with virtualization library-specific APIs
	 */
	export class RowHeightVirtualizationUtils extends RowHeightUtils {
	    private gridRef;
	    private outerGridElementRef;
	    private gridItemsRenderedRef;
	    private rerenderGridBodyRef;
	    constructor(gridRef: MutableRefObject<ImperativeGridApi | null>, outerGridElementRef: MutableRefObject<HTMLDivElement | null>, gridItemsRenderedRef: MutableRefObject<GridOnItemsRenderedProps | null>, rerenderGridBodyRef: MutableRefObject<(() => void) | null>);
	    /**
	     * Virtualization workarounds for auto height rows
	     */
	    private timerId?;
	    private lastUpdatedRow;
	    setRowHeight(rowIndex: number, colId: string, height: number | undefined, visibleRowIndex: number): boolean;
	    pruneHiddenColumnHeights(visibleColumns: EuiDataGridColumn[]): boolean;
	    resetRow(visibleRowIndex: number): void;
	    resetGrid(): void;
	    compensateForLayoutShift(rowIndex: number, verticalLayoutShift: number, anchorRow: EuiDataGridScrollAnchorRow): void;
	}
	/**
	 * Hook for instantiating RowHeightUtils, setting internal class vars,
	 * and setting up various row-height-related side effects
	 */
	export const useRowHeightUtils: ({ virtualization, rowHeightsOptions, columns, }: {
	    virtualization?: false | {
	        gridRef: MutableRefObject<ImperativeGridApi | null>;
	        outerGridElementRef: MutableRefObject<HTMLDivElement | null>;
	        gridItemsRenderedRef: MutableRefObject<GridOnItemsRenderedProps | null>;
	    };
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    columns: EuiDataGridColumn[];
	}) => RowHeightUtils;
	export const useDefaultRowHeight: ({ rowHeightsOptions, rowHeightUtils, }: {
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    rowHeightUtils: RowHeightUtilsType;
	}) => {
	    defaultRowHeight: number;
	    setRowHeight: import("react").Dispatch<import("react").SetStateAction<number>>;
	    getRowHeight: (rowIndex: number) => number;
	};

}
declare module '@elastic/eui/src/components/token/token_types' {
	import { HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	export const SIZES: readonly ["xs", "s", "m", "l"];
	export type TokenSize = (typeof SIZES)[number];
	export const SHAPES: readonly ["circle", "square", "rectangle"];
	export type TokenShape = (typeof SHAPES)[number];
	export const FILLS: readonly ["light", "dark", "none"];
	export type TokenFill = (typeof FILLS)[number];
	export const COLORS: readonly ["euiColorVis0", "euiColorVis1", "euiColorVis2", "euiColorVis3", "euiColorVis4", "euiColorVis5", "euiColorVis6", "euiColorVis7", "euiColorVis8", "euiColorVis9", "gray"];
	export type TokenColor = (typeof COLORS)[number];
	export interface TokenProps {
	    /**
	     * An EUI icon type
	     */
	    iconType: IconType;
	    /**
	     * For best results use one of the vis color names (or 'gray').
	     * Or supply your own HEX color. The `fill='light'` (lightened background) will always be overridden by `fill='dark'` (solid background).
	     * Default: `gray` for glyphs or one of the vis colors for prefab token types
	     */
	    color?: TokenColor | string;
	    /**
	     * Outer shape surrounding the icon
	     * Default: `circle`
	     */
	    shape?: TokenShape;
	    /**
	     * `light` for lightened color with border, `dark` for solid, or `none`
	     * Default: `light`
	     */
	    fill?: TokenFill;
	    /**
	     * Size of the token
	     */
	    size?: TokenSize;
	    /**
	     * The icon's title. Required for accessibility
	     */
	    title?: string;
	    'aria-label'?: string;
	    'aria-labelledby'?: string;
	    'aria-describedby'?: string;
	}
	export type EuiTokenProps = CommonProps & TokenProps & Omit<HTMLAttributes<HTMLSpanElement>, 'title'>;

}
declare module '@elastic/eui/src/components/token/token_map' {
	import type { TokenProps } from '@elastic/eui/src/components/token/token_types';
	export type EuiTokenMapType = 'tokenAlias' | 'tokenAnnotation' | 'tokenArray' | 'tokenBinary' | 'tokenBoolean' | 'tokenClass' | 'tokenCompletionSuggester' | 'tokenConstant' | 'tokenDate' | 'tokenDimension' | 'tokenElement' | 'tokenEnum' | 'tokenEnumMember' | 'tokenEvent' | 'tokenException' | 'tokenField' | 'tokenFile' | 'tokenFlattened' | 'tokenFunction' | 'tokenGeo' | 'tokenHistogram' | 'tokenInterface' | 'tokenIP' | 'tokenJoin' | 'tokenKey' | 'tokenKeyword' | 'tokenMethod' | 'tokenMetricCounter' | 'tokenMetricGauge' | 'tokenModule' | 'tokenNamespace' | 'tokenNested' | 'tokenNull' | 'tokenNumber' | 'tokenObject' | 'tokenOperator' | 'tokenPackage' | 'tokenParameter' | 'tokenPercolator' | 'tokenProperty' | 'tokenRange' | 'tokenRankFeature' | 'tokenRankFeatures' | 'tokenRepo' | 'tokenSearchType' | 'tokenSemanticText' | 'tokenShape' | 'tokenString' | 'tokenStruct' | 'tokenSymbol' | 'tokenTag' | 'tokenText' | 'tokenTokenCount' | 'tokenVariable' | 'tokenVectorDense' | 'tokenDenseVector' | 'tokenVectorSparse';
	/**
	 * Most of the style combinations for tokens are semi-arbitrary. However, there was an effort
	 * to use the square shape for more common token types like string and number. Reserving the
	 * circle shape for more uncommon token types so they grab attention.
	 */
	export const TOKEN_MAP: {
	    [mapType in EuiTokenMapType]: Omit<TokenProps, 'iconType'>;
	};
	export const TOKEN_COLOR_TO_ICON_COLOR_MAP: {
	    euiColorVis0: string;
	    euiColorVis1: string;
	    euiColorVis2: string;
	    euiColorVis3: string;
	    euiColorVis4: string;
	    euiColorVis5: string;
	    euiColorVis6: string;
	    euiColorVis7: string;
	    euiColorVis8: string;
	    euiColorVis9: string;
	};

}
declare module '@elastic/eui/src/components/token/token.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	import type { TokenFill } from '@elastic/eui/src/components/token/token_types';
	export const euiTokenStyles: (euiThemeContext: UseEuiTheme, fill: TokenFill) => {
	    euiToken: import("@emotion/react").SerializedStyles;
	    circle: import("@emotion/react").SerializedStyles;
	    square: import("@emotion/react").SerializedStyles;
	    rectangle: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    euiColorVis0: import("@emotion/react").SerializedStyles;
	    euiColorVis1: import("@emotion/react").SerializedStyles;
	    euiColorVis2: import("@emotion/react").SerializedStyles;
	    euiColorVis3: import("@emotion/react").SerializedStyles;
	    euiColorVis4: import("@emotion/react").SerializedStyles;
	    euiColorVis5: import("@emotion/react").SerializedStyles;
	    euiColorVis6: import("@emotion/react").SerializedStyles;
	    euiColorVis7: import("@emotion/react").SerializedStyles;
	    euiColorVis8: import("@emotion/react").SerializedStyles;
	    euiColorVis9: import("@emotion/react").SerializedStyles;
	    gray: import("@emotion/react").SerializedStyles;
	    customColor: import("@emotion/react").SerializedStyles;
	    light: import("@emotion/react").SerializedStyles;
	    dark: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/token/token' {
	import { FunctionComponent } from 'react';
	import type { EuiTokenProps } from '@elastic/eui/src/components/token/token_types';
	export const EuiToken: FunctionComponent<EuiTokenProps>;

}
declare module '@elastic/eui/src/components/token' {
	export type { EuiTokenProps } from '@elastic/eui/src/components/token/token_types';
	export { SIZES as TOKEN_SIZES, SHAPES as TOKEN_SHAPES, COLORS as TOKEN_COLORS, } from '@elastic/eui/src/components/token/token_types';
	export { EuiToken } from '@elastic/eui/src/components/token/token';

}
declare module '@elastic/eui/src/components/datagrid/data_grid_types' {
	import { ComponentType, JSXElementConstructor, ReactNode, HTMLAttributes, CSSProperties, ReactElement, AriaAttributes, MutableRefObject, Ref, Component, ComponentClass, KeyboardEventHandler, JSX } from 'react';
	import { VariableSizeGridProps, VariableSizeGrid as Grid, GridOnItemsRenderedProps, GridOnScrollProps } from 'react-window';
	import { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group';
	import { EuiButtonEmpty, EuiButtonIcon } from '@elastic/eui/src/components/button';
	import { ExclusiveUnion, CommonProps, OneOf } from '@elastic/eui/src/components/common';
	import { RowHeightUtilsType } from '@elastic/eui/src/components/datagrid/utils/row_heights';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiTokenProps } from '@elastic/eui/src/components/token';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	export type ImperativeGridApi = Omit<Grid, keyof Component>;
	export interface EuiDataGridToolbarProps {
	    gridWidth: number;
	    minSizeForControls?: number;
	    toolbarVisibility: boolean | EuiDataGridToolBarVisibilityOptions;
	    isFullScreen: boolean;
	    fullScreenSelector: ReactNode;
	    keyboardShortcuts: ReactNode;
	    displaySelector: ReactNode;
	    columnSelector: ReactNode;
	    columnSorting: ReactNode;
	    renderCustomToolbar?: (props: EuiDataGridCustomToolbarProps) => ReactElement;
	}
	/**
	 * Props which are available for a custom toolbar rendering
	 */
	export interface EuiDataGridCustomToolbarProps {
	    hasRoomForGridControls: boolean;
	    fullScreenControl: ReactNode;
	    keyboardShortcutsControl: ReactNode;
	    displayControl: ReactNode;
	    columnControl: ReactNode;
	    columnSortingControl: ReactNode;
	}
	export interface EuiDataGridInMemoryRendererProps {
	    inMemory: EuiDataGridInMemory;
	    columns: EuiDataGridColumn[];
	    rowCount: number;
	    renderCellValue: EuiDataGridCellProps['renderCellValue'];
	    onCellRender: (rowIndex: number, columnId: string, value: string) => void;
	}
	export interface DataGridWrapperRowsContentsShape {
	    headerRowHeight: number;
	    headerRow: ReactElement | null;
	    footerRow: ReactElement | null;
	}
	export interface EuiDataGridSchema {
	    [columnId: string]: {
	        columnType: string | null;
	    };
	}
	export interface SchemaTypeScore {
	    type: string;
	    score: number;
	}
	export interface EuiDataGridSchemaDetector {
	    /**
	     * The name of this data type, matches {@link EuiDataGridColumn} / `schema`
	     */
	    type: string;
	    /**
	     * The function given the text value of a cell and returns a score of [0...1] of how well the value matches this data type
	     */
	    detector: (value: string) => number;
	    /**
	     * A custom comparator function when performing in-memory sorting on this data type, takes `(a: string, b: string, direction: 'asc' | 'desc', indexes: {aIndex: number, bIndex: number}) => -1 | 0 | 1`
	     */
	    comparator?: (a: string, b: string, direction: 'asc' | 'desc', indexes: {
	        aIndex: number;
	        bIndex: number;
	    }) => -1 | 0 | 1;
	    /**
	     * The icon used to visually represent this data type. Accepts any `EuiIcon IconType`.
	     */
	    icon: IconType;
	    /**
	     * The color associated with this data type; it's used to color the icon token
	     */
	    color?: EuiTokenProps['color'] | string;
	    /**
	     * Text for how to represent an ascending sort of this data type, e.g. 'A -> Z'
	     */
	    sortTextAsc: ReactNode;
	    /**
	     * Text for how to represent a descending sort of this data type, e.g. 'Z -> A'
	     */
	    sortTextDesc: ReactNode;
	    /**
	     * Whether columns with this schema are sortable (defaults to true). Can be overridden at the individual {@link EuiDataGridColumn} level
	     */
	    isSortable?: boolean;
	    /**
	     * This property controls the capitalization of text
	     */
	    textTransform?: 'uppercase' | 'lowercase' | 'capitalize';
	    /**
	     * Default sort direction of columns with this schema. Can be overridden at the individual {@link EuiDataGridColumn} level
	     */
	    defaultSortDirection?: 'asc' | 'desc';
	}
	export interface EuiDataGridHeaderRowPropsSpecificProps {
	    sorting?: EuiDataGridSorting;
	    leadingControlColumns?: EuiDataGridControlColumn[];
	    trailingControlColumns?: EuiDataGridControlColumn[];
	    columns: EuiDataGridColumn[];
	    columnWidths: EuiDataGridColumnWidths;
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    defaultColumnWidth?: number | null;
	    setColumnWidth: (columnId: string, width: number) => void;
	    visibleColCount: number;
	    setVisibleColumns: (columnId: string[]) => void;
	    switchColumnPos: (colFromId: string, colToId: string) => void;
	    gridStyles: EuiDataGridStyle;
	    canDragAndDropColumns?: boolean;
	}
	export type EuiDataGridHeaderRowProps = CommonProps & HTMLAttributes<HTMLDivElement> & EuiDataGridHeaderRowPropsSpecificProps;
	export interface EuiDataGridHeaderCellProps extends Omit<EuiDataGridHeaderRowPropsSpecificProps, 'leadingControlColumns' | 'trailingControlColumns' | 'visibleColCount'> {
	    index: number;
	    column: EuiDataGridColumn;
	    isLastColumn: boolean;
	}
	export interface EuiDataGridControlHeaderCellProps {
	    index: number;
	    isLastColumn: boolean;
	    controlColumn: EuiDataGridControlColumn;
	}
	export interface EuiDataGridHeaderCellWrapperProps {
	    children: ReactNode | ((renderFocusTrap: boolean) => ReactNode);
	    id: string;
	    index: number;
	    isLastColumn: boolean;
	    width?: number | null;
	    className?: string;
	    'aria-label'?: AriaAttributes['aria-label'];
	    'aria-labelledby'?: AriaAttributes['aria-labelledby'];
	    hasColumnActions?: boolean;
	    isDragging?: boolean;
	    onKeyDown?: KeyboardEventHandler;
	}
	export type EuiDataGridFooterRowProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    rowIndex: number;
	    leadingControlColumns: EuiDataGridControlColumn[];
	    trailingControlColumns: EuiDataGridControlColumn[];
	    columns: EuiDataGridColumn[];
	    schema: EuiDataGridSchema;
	    columnWidths: EuiDataGridColumnWidths;
	    defaultColumnWidth?: number | null;
	    renderCellValue: EuiDataGridCellProps['renderCellValue'];
	    renderCellPopover?: EuiDataGridCellProps['renderCellPopover'];
	    interactiveCellId: EuiDataGridCellProps['interactiveCellId'];
	    visibleRowIndex?: number;
	    visibleColCount: number;
	    gridStyles: EuiDataGridStyle;
	};
	export interface EuiDataGridVisibleRows {
	    startRow: number;
	    endRow: number;
	    visibleRowCount: number;
	}
	export interface DataGridSortedContextShape {
	    sorting?: EuiDataGridSorting;
	    sortedRowMap: number[];
	    getCorrectRowIndex: (visibleRowIndex: number) => number;
	}
	export type EuiDataGridFocusedCell = [number, number];
	export interface DataGridFocusContextShape {
	    focusedCell?: EuiDataGridFocusedCell;
	    setFocusedCell: (cell: EuiDataGridFocusedCell, forceUpdate?: boolean) => void;
	    setIsFocusedCellInView: (isFocusedCellInView: boolean) => void;
	    onFocusUpdate: (cell: EuiDataGridFocusedCell, updateFocus: Function) => () => void;
	    focusFirstVisibleInteractiveCell: () => void;
	}
	export interface DataGridCellPopoverContextShape {
	    popoverIsOpen: boolean;
	    cellLocation: {
	        rowIndex: number;
	        colIndex: number;
	    };
	    openCellPopover(args: {
	        rowIndex: number;
	        colIndex: number;
	    }): void;
	    closeCellPopover(): void;
	    setPopoverAnchor(anchor: HTMLElement): void;
	    setPopoverAnchorPosition(position: 'downLeft' | 'upLeft'): void;
	    setPopoverContent(content: ReactNode): void;
	    setCellPopoverProps: EuiDataGridCellPopoverElementProps['setCellPopoverProps'];
	}
	export type CommonGridProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * An array of {@link EuiDataGridColumn} objects. Lists the columns available and the schema and settings tied to it.
	     */
	    columns: EuiDataGridColumn[];
	    /**
	     * An array of {@link EuiDataGridControlColumn} objects. Used to define ancillary columns on the left side of the data grid.
	     * Useful for adding items like checkboxes and buttons.
	     */
	    leadingControlColumns?: EuiDataGridControlColumn[];
	    /**
	     * An array of {@link EuiDataGridControlColumn} objects. Used to define ancillary columns on the right side of the data grid.
	     * Useful for adding items like checkboxes and buttons.
	     */
	    trailingControlColumns?: EuiDataGridControlColumn[];
	    /**
	     * An array of {@link EuiDataGridColumnVisibility} objects.
	     * Defines which columns are **intitially** visible in the grid and the order they are displayed.
	     * Users can still turn their visibility on/off when `toolbarVisibility.showColumnSelector = true` (which is the default).
	     */
	    columnVisibility: EuiDataGridColumnVisibility;
	    /**
	     * An array of custom {@link EuiDataGridSchemaDetector} objects. You can inject custom schemas to the grid to define the classnames applied.
	     */
	    schemaDetectors?: EuiDataGridSchemaDetector[];
	    /**
	     * The total number of rows in the dataset (used by e.g. pagination to know how many pages to list).
	     */
	    rowCount: number;
	    /**
	     * A function called to render a cell's value. Behind the scenes it is treated as a React component
	     * allowing hooks, context, and other React concepts to be used. The function receives {@link EuiDataGridCellValueElementProps}
	     * as its only argument.
	     */
	    renderCellValue: EuiDataGridCellProps['renderCellValue'];
	    /**
	     * An optional object of props passed to the `renderCellValue` component.
	     * This API exists to make it easier to define your `renderCellValue` function
	     * component statically, and not rerender due to other dependent state.
	     */
	    cellContext?: EuiDataGridCellProps['cellContext'];
	    /**
	     * An optional function that can be used to completely customize the rendering of cell popovers.
	     *
	     * If not specified, defaults to an `<EuiText>` wrapper around the rendered cell value and an
	     * `<EuiPopoverFooter>` around the cell actions.
	     *
	     * Behind the scenes it is treated as a React component allowing hooks, context, and other React concepts to be used.
	     * The function receives {@link EuiDataGridCellPopoverElementProps} as its only argument.
	     *
	     */
	    renderCellPopover?: EuiDataGridCellProps['renderCellPopover'];
	    /**
	     * An optional function called to render a footer cell. If not specified, no footer row is rendered.
	     *
	     * Behind the scenes it is treated as a React component
	     * allowing hooks, context, and other React concepts to be used. The function receives {@link EuiDataGridCellValueElementProps}
	     * as its only argument.
	     */
	    renderFooterCellValue?: EuiDataGridCellProps['renderCellValue'];
	    /**
	     * An optional function called to completely customize and control the rendering of
	     * EuiDataGrid's body and cell placement.  This can be used to, e.g. remove EuiDataGrid's
	     * virtualization library, or roll your own.
	     *
	     * This component is **only** meant as an escape hatch for extremely custom use cases.
	     *
	     * Behind the scenes, this function is treated as a React component,
	     * allowing hooks, context, and other React concepts to be used.
	     * It receives {@link EuiDataGridCustomBodyProps} as its only argument.
	     */
	    renderCustomGridBody?: (args: EuiDataGridCustomBodyProps) => ReactNode;
	    /**
	     * An optional function called to customize placement of controls in EuiDataGrid's toolbar.
	     * This can be used to add custom buttons or reorder existing ones.
	     *
	     * Behind the scenes, this function is treated as a React component,
	     * allowing hooks, context, and other React concepts to be used.
	     * It receives {@link EuiDataGridCustomToolbarProps} as its only argument.
	     */
	    renderCustomToolbar?: EuiDataGridToolbarProps['renderCustomToolbar'];
	    /**
	     * Defines the initial style of the grid. Accepts a partial {@link EuiDataGridStyle} object.
	     * Settings provided may be overwritten or merged with user defined preferences if `toolbarVisibility.showDisplaySelector.allowDensity = true` (which is the default).
	     */
	    gridStyle?: EuiDataGridStyle;
	    /**
	     * Allows you to configure what features the toolbar shows.
	     *
	     * Accepts either a boolean or {@link EuiDataGridToolBarVisibilityOptions} object.
	     * When used as a boolean, defines the display of the entire toolbar.
	     * When passed an object allows you to turn off individual controls within the toolbar as well as add additional buttons.
	     */
	    toolbarVisibility?: boolean | EuiDataGridToolBarVisibilityOptions;
	    /**
	     * Allows you to configure if the header row is rendered.
	     * @default true
	     */
	    headerVisibility?: boolean;
	    /**
	     * A {@link EuiDataGridInMemory} object to define the level of high order schema-detection and sorting logic to use on your data.
	     * **Try to set when possible**.
	     * If omitted, disables all enhancements and assumes content is flat strings.
	     */
	    inMemory?: EuiDataGridInMemory;
	    /**
	     * A {@link EuiDataGridPaginationProps} object. Omit to disable pagination completely.
	     */
	    pagination?: EuiDataGridPaginationProps;
	    /**
	     * A {@link EuiDataGridSorting} object that provides the sorted columns along with their direction. Provides a callback for when it changes.
	     * Optional, but required when inMemory is set.
	     * Omit to disable, but you'll likely want to also turn off the user sorting controls through the `toolbarVisibility` prop.
	     */
	    sorting?: EuiDataGridSorting;
	    /**
	     * A callback for when a column's size changes. Callback receives `{ columnId: string, width: number }`.
	     */
	    onColumnResize?: EuiDataGridOnColumnResizeHandler;
	    /**
	     * Defines a minimum width for the grid to show all controls in its toolbar.
	     */
	    minSizeForControls?: number;
	    /**
	     * Sets the grid's height, forcing it to overflow in a scrollable container with cell virtualization.
	     */
	    height?: CSSProperties['height'];
	    /**
	     * Sets the grid's width, forcing it to overflow in a scrollable container with cell virtualization.
	     */
	    width?: CSSProperties['width'];
	    /**
	     * Allows customizing the underlying [react-window grid](https://react-window.vercel.app/#/api/VariableSizeGrid) props.
	     */
	    virtualizationOptions?: Pick<VariableSizeGridProps, 'className' | 'style' | 'direction' | 'estimatedRowHeight' | 'estimatedColumnWidth' | 'overscanRowCount' | 'overscanColumnCount' | 'initialScrollTop' | 'initialScrollLeft' | 'onItemsRendered' | 'itemKey' | 'outerElementType'> & {
	        /**
	         * Called when the grid scroll positions changes, as a result of user scrolling or scroll-to method calls.
	         */
	        onScroll?: (args: GridOnScrollProps & {
	            scrollHeight: number;
	            scrollWidth: number;
	            clientHeight: number;
	            clientWidth: number;
	            isScrolledToBlockStart: boolean;
	            isScrolledToBlockEnd: boolean;
	            isScrolledToInlineStart: boolean;
	            isScrolledToInlineEnd: boolean;
	        }) => void;
	    };
	    /**
	     * A {@link EuiDataGridRowHeightsOptions} object that provides row heights options.
	     * Allows configuring both default and specific heights of grid rows.
	     * Settings provided may be overwritten or merged with user defined preferences if `toolbarVisibility.showDisplaySelector.allowRowHeight = true` (which is the default).
	     */
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    /**
	     * A callback for when the fullscreen state changes. Callback receives `isFullScreen: boolean`.
	     */
	    onFullScreenChange?: (isFullScreen: boolean) => void;
	};
	export type EuiDataGridProps = OneOf<CommonGridProps, 'aria-label' | 'aria-labelledby'>;
	export interface EuiDataGridRefProps {
	    /**
	     * Allows manually controlling the fullscreen state of the grid.
	     */
	    setIsFullScreen: (isFullScreen: boolean) => void;
	    /**
	     * Allows manually focusing the specified cell in the grid.
	     *
	     * Using this method is an accessibility requirement if your EuiDataGrid
	     * toggles a modal or flyout - focus must be restored to the grid on close
	     * to prevent keyboard or screen reader users from being stranded.
	     */
	    setFocusedCell: (cell: {
	        rowIndex: number;
	        colIndex: number;
	    }) => void;
	    /**
	     * Allows manually opening the popover of the specified cell in the grid.
	     */
	    openCellPopover: (cell: {
	        rowIndex: number;
	        colIndex: number;
	    }) => void;
	    /**
	     * Closes any currently open popovers in the data grid.
	     */
	    closeCellPopover: () => void;
	    /**
	     * Scrolls to a specified top and left offset.
	     */
	    scrollTo?: ImperativeGridApi['scrollTo'];
	    /**
	     * Scrolls to a specified rowIndex.
	     */
	    scrollToItem?: ImperativeGridApi['scrollToItem'];
	}
	export interface EuiDataGridColumnResizerProps {
	    columnId: string;
	    columnWidth: number;
	    setColumnWidth: (columnId: string, width: number) => void;
	    isLastColumn: boolean;
	}
	export interface EuiDataGridColumnResizerState {
	    initialX: number;
	    offset: number;
	}
	export interface EuiDataGridColumnSortingDraggableProps {
	    id: string;
	    direction: string;
	    index: number;
	    sorting: EuiDataGridSorting;
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    /**
	     * Value to be shown in column sorting popover.
	     */
	    display: string;
	}
	export interface EuiDataGridBodyProps {
	    leadingControlColumns: EuiDataGridControlColumn[];
	    trailingControlColumns: EuiDataGridControlColumn[];
	    columns: EuiDataGridColumn[];
	    visibleColCount: number;
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    rowCount: number;
	    visibleRows: EuiDataGridVisibleRows;
	    renderCellValue: EuiDataGridCellProps['renderCellValue'];
	    cellContext?: EuiDataGridCellProps['cellContext'];
	    renderCellPopover?: EuiDataGridCellProps['renderCellPopover'];
	    renderFooterCellValue?: EuiDataGridCellProps['renderCellValue'];
	    renderCustomGridBody?: EuiDataGridProps['renderCustomGridBody'];
	    interactiveCellId: EuiDataGridCellProps['interactiveCellId'];
	    sorting?: EuiDataGridSorting;
	    pagination?: Required<EuiDataGridPaginationProps>;
	    setVisibleColumns: EuiDataGridHeaderRowProps['setVisibleColumns'];
	    switchColumnPos: EuiDataGridHeaderRowProps['switchColumnPos'];
	    onColumnResize?: EuiDataGridOnColumnResizeHandler;
	    virtualizationOptions?: EuiDataGridProps['virtualizationOptions'];
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    isFullScreen: boolean;
	    gridStyles: EuiDataGridStyle;
	    gridWidth: number;
	    gridRef: MutableRefObject<Grid | null>;
	    gridItemsRendered: MutableRefObject<GridOnItemsRenderedProps | null>;
	    wrapperRef: MutableRefObject<HTMLDivElement | null>;
	    className?: string;
	    canDragAndDropColumns?: boolean;
	    showHeader?: boolean;
	}
	export interface EuiDataGridCustomBodyProps {
	    /**
	     * When taking control of data grid rendering, the underlying `EuiDataGridCell`
	     * is passed as a prop for usage. You **must** pass in a valid `colIndex`
	     * and `visibleRowIndex` to this cell component.
	     *
	     * You may also pass in any other optional cell prop overrides
	     * that `EuiDataGridCell` accepts, such as `isExpandable` or `renderCellValue`.
	     */
	    Cell: JSXElementConstructor<{
	        colIndex: number;
	        visibleRowIndex: number;
	    } & Partial<EuiDataGridCellProps>>;
	    /**
	     * The currently visible columns are passed to your data grid renderer so that your
	     * custom grid can automatically adjust to column hiding & reordering.
	     */
	    visibleColumns: EuiDataGridColumn[];
	    /**
	     * The currently visible rows are passed to your data grid renderer so that your
	     * custom grid can automatically adjust to sorting and pagination.
	     *
	     * You will need  to manually slice your data with `startRow` and `endRow` in order to simulate pagination.
	     */
	    visibleRowData: {
	        startRow: number;
	        endRow: number;
	        visibleRowCount: number;
	    };
	    /**
	     * Callback function to set custom props & attributes on the custom grid body's wrapping `div` element.
	     * It's best to wrap calls to `setCustomGridBodyProps` in a `useEffect` hook
	     */
	    setCustomGridBodyProps: (props: EuiDataGridSetCustomGridBodyProps) => void;
	    /**
	     * The width of the grid, can be used by consumer as a layout utility
	     */
	    gridWidth: number;
	    /**
	     * Header row component to render by custom renderer
	     * */
	    headerRow: JSX.Element | null;
	    /**
	     * Footer row component to render by custom renderer
	     * */
	    footerRow: JSX.Element | null;
	}
	export type EuiDataGridSetCustomGridBodyProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    ref?: MutableRefObject<HTMLDivElement> | Ref<HTMLDivElement>;
	};
	/**
	 * Props shared between renderCellValue and renderCellPopover
	 */
	interface SharedRenderCellElementProps {
	    /**
	     * Index of the row being rendered, 0 represents the first row. This index always includes
	     * pagination offset, meaning the first rowIndex in a grid is `pagination.pageIndex * pagination.pageSize`
	     * so take care if you need to adjust the rowIndex to fit your data
	     */
	    rowIndex: number;
	    /**
	     * Index of the column being rendered, 0 represents the first column. This index accounts
	     * for columns that have been hidden or reordered by the user, so take care if you need
	     * to adjust the colIndex to fit your data
	     */
	    colIndex: number;
	    /**
	     * ID of the column being rendered, the value comes from the {@link EuiDataGridColumn} `id`
	     */
	    columnId: string;
	    /**
	     * The schema type of the column being rendered
	     */
	    schema?: string | null;
	}
	export type EuiDataGridSetCellProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'role' | 'tabIndex' | 'aria-rowindex'> & {
	    isExpandable?: boolean;
	};
	export interface EuiDataGridCellValueElementProps extends SharedRenderCellElementProps {
	    /**
	     * Callback function to set custom props & attributes on the cell's wrapping `div` element;
	     * it's best to wrap calls to `setCellProps` in a `useEffect` hook
	     */
	    setCellProps: (props: EuiDataGridSetCellProps) => void;
	    /**
	     * Whether or not the cell is expandable, comes from the {@link EuiDataGridColumn} `isExpandable` which defaults to `true`
	     */
	    isExpandable: boolean;
	    /**
	     * Whether or not the cell is expanded
	     */
	    isExpanded: boolean;
	    /**
	     * When rendering the cell, `isDetails` is false; when the cell is expanded, `renderCellValue` is called again to render into the details popover and `isDetails` is true
	     */
	    isDetails: boolean;
	}
	export interface EuiDataGridCellPopoverElementProps extends SharedRenderCellElementProps {
	    /**
	     * The default `children` passed to the cell popover comes from the passed `renderCellValue` prop as a ReactElement.
	     *
	     * Allows wrapping the rendered content: `({ children }) => <div>{children}</div>` - or leave it out to render completely custom content.
	     */
	    children: ReactNode;
	    /**
	     * References the div element the cell contents have been rendered into. Primarily useful for processing the rendered text
	     */
	    cellContentsElement: HTMLDivElement;
	    /**
	     * An `EuiPopoverFooter` containing all column `cellActions` (as `EuiEmptyButton`s).
	     * Use `{cellActions}` to render the default cell action buttons, or leave it out to hide cell actions/render your own.
	     */
	    cellActions: ReactNode;
	    /**
	     * For certain columns or schemas, you may want to fall back to the standard EuiDataGrid popover display.
	     * If so, that component is provided here as a passed React function component for your usage.
	     */
	    DefaultCellPopover: JSXElementConstructor<EuiDataGridCellPopoverElementProps>;
	    /**
	     * Allows passing props to the wrapping cell expansion popover and panel.
	     * Accepts any props that `EuiPopover` accepts, except for `button` and `closePopover`.
	     */
	    setCellPopoverProps: (props: Omit<EuiPopoverProps, 'button' | 'closePopover'>) => void;
	}
	type CellContext = Omit<Record<string, any>, keyof EuiDataGridCellValueElementProps>;
	type CellPropsWithContext = CellContext & EuiDataGridCellValueElementProps;
	export type RenderCellValue = ((props: CellPropsWithContext) => ReactNode) | ComponentClass<CellPropsWithContext>;
	export interface EuiDataGridCellProps {
	    rowIndex: number;
	    visibleRowIndex: number;
	    colIndex: number;
	    column?: EuiDataGridColumn;
	    columnId: string;
	    columnType?: string | null;
	    width?: number;
	    interactiveCellId: string;
	    isExpandable: boolean;
	    className?: string;
	    popoverContext: DataGridCellPopoverContextShape;
	    renderCellValue: RenderCellValue;
	    cellContext?: CellContext;
	    renderCellPopover?: JSXElementConstructor<EuiDataGridCellPopoverElementProps> | ((props: EuiDataGridCellPopoverElementProps) => ReactNode);
	    setRowHeight?: (height: number) => void;
	    getRowHeight?: (rowIndex: number) => number;
	    style?: CSSProperties;
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    rowHeightUtils?: RowHeightUtilsType;
	    rowManager?: EuiDataGridRowManager;
	    pagination?: Required<EuiDataGridPaginationProps>;
	    gridStyles: EuiDataGridStyle;
	}
	export interface EuiDataGridCellState {
	    cellProps: EuiDataGridSetCellProps;
	    isFocused: boolean;
	    isHovered: boolean;
	}
	export type EuiDataGridCellValueProps = Omit<EuiDataGridCellProps, 'width' | 'interactiveCellId' | 'popoverContext' | 'rowManager'>;
	export interface EuiDataGridControlColumn {
	    /**
	     * Used as the React `key` when rendering content
	     */
	    id: string;
	    /**
	     * Width of the column, users are unable to change this
	     */
	    width: number;
	    /**
	     * Component to render in the column header
	     */
	    headerCellRender: ComponentType;
	    /**
	     * Optional props to pass to the column header cell
	     */
	    headerCellProps?: HTMLAttributes<HTMLDivElement>;
	    /**
	     * Component to render for each row in the column
	     */
	    rowCellRender: EuiDataGridCellProps['renderCellValue'];
	    /**
	     * Component to render in the optional column footer
	     */
	    footerCellRender?: EuiDataGridCellProps['renderCellValue'];
	    /**
	     * Optional props to pass to the column footer cell
	     */
	    footerCellProps?: HTMLAttributes<HTMLDivElement>;
	}
	export const emptyControlColumns: EuiDataGridControlColumn[];
	export interface EuiDataGridColumn {
	    /**
	     * The unique identifier for this column
	     */
	    id: string;
	    /**
	     * A `ReactNode` used when rendering the column header. When providing complicated content, please make sure to utilize CSS to respect truncation as space allows. Check the docs example.
	     */
	    display?: ReactNode;
	    /**
	     * Display name as text for the column.
	     * This can be used to display a readable column name in column hiding/sorting, where `display` won't be used.
	     * This will also be used as a `title` attribute that will display on mouseover (useful if the display text is being truncated by the column width).
	     * If not passed, `id` will be shown as the column name.
	     * Passing this together with `display` is useful to ensure an accessible label is added to the column.
	     */
	    displayAsText?: string;
	    /**
	     * Optional props to pass to the column header cell
	     */
	    displayHeaderCellProps?: HTMLAttributes<HTMLDivElement>;
	    /**
	     * Initial width (in pixels) of the column
	     */
	    initialWidth?: number;
	    /**
	     * Defaults to true, always true if cellActions are defined. Defines whether or not the column's cells can be expanded with a popup onClick / keydown.
	     */
	    isExpandable?: boolean;
	    /**
	     * Whether this column's width can be changed by the user, defaults to true
	     */
	    isResizable?: boolean;
	    /**
	     * Whether this column is sortable
	     */
	    isSortable?: boolean;
	    /**
	     * Default sort direction of the column
	     */
	    defaultSortDirection?: 'asc' | 'desc';
	    /**
	     * A Schema to use for the column.
	     * Built-in values are [`boolean`, `currency`, `datetime`, `numeric`, `json`] but can be expanded by defining your own {@link EuiDataGrid} `schemaDetectors` (for in-memory detection).
	     * In general, it is advised to pass in a value here when you are sure of the schema ahead of time, so that you don't need to rely on the automatic detection.
	     */
	    schema?: string;
	    /**
	     * Configuration of column actions. Set to false to disable or use {@link EuiDataGridColumnActions} to configure the actions displayed in the header cell of the column.
	     */
	    actions?: false | EuiDataGridColumnActions;
	    /**
	     * Additional actions displayed as icon on hover / focus, and in the expanded view of the cell containing the value
	     */
	    cellActions?: EuiDataGridColumnCellAction[];
	    /**
	     * Configures the amount of cell action buttons immediately visible on a cell.
	     * Any cell actions above this number will only display in the cell expansion popover.
	     * Defaults to 2.
	     */
	    visibleCellActions?: number;
	}
	export type EuiDataGridColumnCellAction = ComponentType<EuiDataGridColumnCellActionProps>;
	export interface EuiDataGridColumnActions {
	    /**
	     * Show/hide/configure the action to hide a column, provided EuiListGroupItemProps are merged
	     */
	    showHide?: boolean | EuiListGroupItemProps;
	    /**
	     * Show/hide/configure the action that switches the actual column with the column to the left side, provided EuiListGroupItemProps are merged
	     */
	    showMoveLeft?: boolean | EuiListGroupItemProps;
	    /**
	     * Show/hide/configure the action that switches the actual column with the column to the right side, provided EuiListGroupItemProps are merged
	     */
	    showMoveRight?: boolean | EuiListGroupItemProps;
	    /**
	     * Show/hide/configure the action to sort ascending by the actual column, provided EuiListGroupItemProps are merged
	     */
	    showSortAsc?: boolean | EuiListGroupItemProps;
	    /**
	     * Show/hide/configure the action to sort descending by the actual column, provided EuiListGroupItemProps are merged
	     */
	    showSortDesc?: boolean | EuiListGroupItemProps;
	    /**
	     * Append additional actions
	     */
	    additional?: EuiListGroupItemProps[];
	}
	export interface EuiDataGridColumnCellActionProps {
	    /**
	     * The index of the row that contains cell's data
	     */
	    rowIndex: number;
	    /**
	     * The index of the column that contains cell's data
	     */
	    colIndex: number;
	    /**
	     * The id of the column that contains the cell's data
	     */
	    columnId: string;
	    /**
	     * React component representing the action displayed in the cell.
	     *
	     * On cell hover/focus, an EuiButtonIcon will be displayed that cannot
	     * have its size or color customized, only its icon.
	     *
	     * On cell expand, an EuiButtonEmpty will be displayed in the cell popover
	     * that can have any sizing, color, or text.
	     */
	    Component: typeof EuiButtonEmpty | typeof EuiButtonIcon;
	    /**
	     * Determines whether the cell's action is displayed expanded (in the Popover)
	     */
	    isExpanded: boolean;
	}
	export interface EuiDataGridColumnVisibility {
	    /**
	     * An array of {@link EuiDataGridColumn} `id`s dictating the order and visibility of columns.
	     */
	    visibleColumns: string[];
	    /**
	     * A callback for when a column's visibility or order is modified by the user.
	     */
	    setVisibleColumns: (visibleColumns: string[]) => void;
	    /** Enables reordering grid columns on drag and drop via the headers cells */
	    canDragAndDropColumns?: boolean;
	}
	export interface EuiDataGridColumnWidths {
	    [key: string]: number;
	}
	export type EuiDataGridStyleFontSizes = 's' | 'm' | 'l';
	export type EuiDataGridStyleBorders = 'all' | 'horizontal' | 'none';
	export type EuiDataGridStyleHeader = 'shade' | 'underline';
	export type EuiDataGridStyleFooter = 'shade' | 'overline' | 'striped';
	export type EuiDataGridStyleRowHover = 'highlight' | 'none';
	export type EuiDataGridStyleCellPaddings = 's' | 'm' | 'l';
	export interface EuiDataGridStyle {
	    /**
	     * Size of fonts used within the row and column cells
	     * @default m
	     */
	    fontSize?: EuiDataGridStyleFontSizes;
	    /**
	     * Defines the padding with the row and column cells
	     * @default m
	     */
	    cellPadding?: EuiDataGridStyleCellPaddings;
	    /**
	     * Border used for the row and column cells
	     * @default all
	     */
	    border?: EuiDataGridStyleBorders;
	    /**
	     * If set to true, rows will alternate zebra striping for clarity
	     * @default false
	     */
	    stripes?: boolean;
	    /**
	     * Visual style for the column headers. Recommendation is to use the `underline` style in times when {@link EuiDataGrid} `toolbarVisibility` is set to `false`.
	     * @default shade
	     */
	    header?: EuiDataGridStyleHeader;
	    /**
	     * Visual style for the column footers.
	     * @default overline
	     */
	    footer?: EuiDataGridStyleFooter;
	    /**
	     * If set to true, the footer row will be sticky
	     * @default true
	     */
	    stickyFooter?: boolean;
	    /**
	     * Will define what visual style to show on row hover
	     * @default hover
	     */
	    rowHover?: EuiDataGridStyleRowHover;
	    /**
	     * Optionally pass custom classes to highlight or customize certain rows
	     */
	    rowClasses?: {
	        [rowIndex: number]: string;
	    };
	    /**
	     * Optional callback returning the current `gridStyle` config when changes occur from user input (e.g. toolbar display controls).
	     * Can be used for, e.g. storing user `gridStyle` in a local storage object.
	     */
	    onChange?: (gridStyle: EuiDataGridStyle) => void;
	}
	export interface EuiDataGridToolBarVisibilityColumnSelectorOptions {
	    /**
	     * When `false`, removes the ability to show & hide columns through the UI
	     */
	    allowHide?: boolean;
	    /**
	     * When `false`, removes the ability to re-order columns through the UI
	     */
	    allowReorder?: boolean;
	}
	export interface EuiDataGridToolBarVisibilityDisplaySelectorOptions {
	    /**
	     * When `false`, removes the ability to change density display through the UI
	     */
	    allowDensity?: boolean;
	    /**
	     * When `false`, removes the ability to change row height display through the UI
	     */
	    allowRowHeight?: boolean;
	    /**
	     * When `false`, removes the ability to reset styles to default through the UI
	     */
	    allowResetButton?: boolean;
	    /**
	     * Allows appending additional content to the bottom of the display settings popover
	     */
	    additionalDisplaySettings?: ReactNode;
	    /**
	     * Allows completely custom rendering of the display selector popover via render prop.
	     * Passes back the default controls as arguments for optional rendering.
	     */
	    customRender?: EuiDataGridDisplaySelectorCustomRender;
	}
	export type EuiDataGridDisplaySelectorCustomRenderProps = {
	    densityControl: ReactNode;
	    rowHeightControl: ReactNode;
	    additionalDisplaySettings: ReactNode;
	    resetButton: ReactNode;
	};
	export type EuiDataGridDisplaySelectorCustomRender = (args: EuiDataGridDisplaySelectorCustomRenderProps) => ReactNode;
	export interface EuiDataGridToolBarVisibilityOptions {
	    /**
	     * Allows the ability for the user to hide fields and sort columns, boolean or a {@link EuiDataGridToolBarVisibilityColumnSelectorOptions}
	     * @default true
	     */
	    showColumnSelector?: boolean | EuiDataGridToolBarVisibilityColumnSelectorOptions;
	    /**
	     * Allows the ability for the user to customize display settings such as grid density and row heights.
	     * User changes will override what is provided in {@link EuiDataGridStyle} and {@link EuiDataGridRowHeightsOptions}
	     * @default true
	     */
	    showDisplaySelector?: boolean | EuiDataGridToolBarVisibilityDisplaySelectorOptions;
	    /**
	     * Allows the ability for the user to sort rows based upon column values
	     * @default true
	     */
	    showSortSelector?: boolean;
	    /**
	     * Displays a popover listing all keyboard controls and shortcuts for the data grid.
	     * If set to `false`, the toggle will be visually hidden, but still focusable by keyboard and screen reader users.
	     * @default true
	     */
	    showKeyboardShortcuts?: boolean;
	    /**
	     * Allows user to be able to fullscreen the data grid. If set to `false` make sure your grid fits within a large enough panel to still show the other controls.
	     * @default true
	     */
	    showFullScreenSelector?: boolean;
	    /**
	     * If passed a `ReactNode`, appends the passed custom control into the left side of the toolbar, after the column & sort controls.
	     * Or use {@link EuiDataGridToolBarAdditionalControlsOptions} to customize the location of your control.
	     */
	    additionalControls?: ReactNode | EuiDataGridToolBarAdditionalControlsOptions;
	}
	export interface EuiDataGridToolBarAdditionalControlsOptions {
	    /**
	     * If passed a `ReactNode`, appends the passed node into the left side of the toolbar, **after** the column & sort controls.
	     * Or use {@link EuiDataGridToolBarAdditionalControlsLeftOptions} to customize the location of your control.
	     * We recommend using `<EuiButtonEmpty size="xs" />` to match the existing controls on the left.
	     */
	    left?: ReactNode | EuiDataGridToolBarAdditionalControlsLeftOptions;
	    /**
	     * Will prepend the passed node into the right side of the toolbar, **before** the density & fullscreen controls.
	     * We recommend using `<EuiButtonIcon size="xs" />` to match the existing controls on the right.
	     */
	    right?: ReactNode;
	}
	export interface EuiDataGridToolBarAdditionalControlsLeftOptions {
	    /**
	     * Will prepend the passed node into the left side of the toolbar, **before** the column & sort controls.
	     */
	    prepend?: ReactNode;
	    /**
	     * Will append the passed node into the left side of the toolbar, **after** the column & sort controls.
	     */
	    append?: ReactNode;
	}
	export interface EuiDataGridPaginationProps {
	    /**
	     * The index of the current page, starts at 0 for the first page
	     */
	    pageIndex: number;
	    /**
	     * How many rows should initially be shown per page.
	     * Pass `0` to display the selected "Show all" option and hide the pagination.
	     *
	     * @default 10
	     */
	    pageSize?: number;
	    /**
	     * An array of page sizes the user can select from.
	     * Pass `0` as one of the options to create a "Show all" option.
	     * Pass an empty array to hide "Rows per page" select button.
	     *
	     * @default [10, 25, 50]
	     */
	    pageSizeOptions?: number[];
	    /**
	     * A callback for when the user changes the page size selection
	     */
	    onChangeItemsPerPage: (itemsPerPage: number) => void;
	    /**
	     * A callback for when the current page index changes
	     */
	    onChangePage: (pageIndex: number) => void;
	}
	export interface EuiDataGridColumnSortingConfig {
	    id: string;
	    direction: 'asc' | 'desc';
	}
	export interface EuiDataGridSorting {
	    /**
	     * A function that receives updated column sort details in response to user interactions in the toolbar controls
	     */
	    onSort: (columns: EuiDataGridColumnSortingConfig[]) => void;
	    /**
	     * An array of the column ids currently being sorted and their sort direction. The array order determines the sort order. `{ id: 'A'; direction: 'asc' }`
	     */
	    columns: EuiDataGridColumnSortingConfig[];
	}
	export interface EuiDataGridInMemory {
	    /**
	      Given the data flow Sorting->Pagination:
	      Each step can be performed by service calls or in-memory by the grid.
	      However, we cannot allow any service calls after an in-memory operation.
	      E.g. if Pagination requires a service call the grid cannot perform
	      in-memory Sorting. This means a single value representing the
	      service / in-memory boundary can be used. Thus there are four states for in-memory's level:
	      * "enhancements" - no in-memory operations, but use the available data to enhance the grid
	      * "pagination" - only pagination is performed in-memory
	      * "sorting" - sorting & pagination is performed in-memory
	   */
	    level: 'enhancements' | 'pagination' | 'sorting';
	    /**
	     * An array of column ids for the in-memory processing to skip
	     */
	    skipColumns?: string[];
	}
	export interface EuiDataGridInMemoryValues {
	    [rowIndex: string]: {
	        [columnId: string]: string;
	    };
	}
	export interface EuiDataGridOnColumnResizeData {
	    columnId: string;
	    width: number;
	}
	export type EuiDataGridOnColumnResizeHandler = (data: EuiDataGridOnColumnResizeData) => void;
	export type EuiDataGridScrollAnchorRow = 'start' | 'center' | undefined;
	export type EuiDataGridRowHeightOption = number | 'auto' | ExclusiveUnion<{
	    lineCount: number;
	}, {
	    height: number;
	}>;
	export interface EuiDataGridRowHeightsOptions {
	    /**
	     * Defines the default size for all rows. It can be line count or just height.
	     */
	    defaultHeight?: EuiDataGridRowHeightOption;
	    /**
	     * Feature flag for custom `lineCount` behavior, where `lineCount` acts like a
	     * *max* number of lines (instead of a set number of lines for all rows).
	     *
	     * This functionality is in beta and has performance implications;
	     * we do not yet fully recommend/support it for heavy production usage.
	     */
	    autoBelowLineCount?: boolean;
	    /**
	     * Defines the height for a specific row. It can be line count or just height.
	     *
	     * When using row height overrides, we strongly setting the `showDisplaySelector: allowRowHeight`
	     * toolbar control to `false` in {@link EuiDataGridToolBarVisibilityOptions}
	     */
	    rowHeights?: Record<number, EuiDataGridRowHeightOption>;
	    /**
	     * Defines a global lineHeight style to apply to all cells
	     */
	    lineHeight?: string;
	    /**
	     * Optional callback returning the current `rowHeightsOptions` when changes occur from user input (e.g. toolbar display controls).
	     * Can be used for, e.g. storing user `rowHeightsOptions` in a local storage object.
	     */
	    onChange?: (rowHeightsOptions: EuiDataGridRowHeightsOptions) => void;
	    /**
	     * Optional indicator of the row that should be used as an anchor for vertical layout shift compensation.
	     * When set to 'start' or 'center', the topmost or middle visible row will try
	     * to compensate for changes in their top offsets by adjusting the grid's scroll
	     * position.
	     */
	    scrollAnchorRow?: EuiDataGridScrollAnchorRow;
	}
	export interface EuiDataGridRowManager {
	    getRow(args: {
	        rowIndex: number;
	        visibleRowIndex: number;
	        top: string;
	        height: number;
	    }): HTMLDivElement;
	}
	export {};

}
declare module '@elastic/eui/src/components/drag_and_drop/drag_drop_context' {
	import React, { FunctionComponent } from 'react';
	import { DragDropContextProps } from '@hello-pangea/dnd';
	type EuiDraggingType = string | null;
	export interface EuiDragDropContextProps {
	    isDraggingType: EuiDraggingType;
	}
	export const EuiDragDropContextContext: React.Context<EuiDragDropContextProps>;
	export const EuiDragDropContext: FunctionComponent<DragDropContextProps>;
	export {};

}
declare module '@elastic/eui/src/components/drag_and_drop/droppable.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDroppableStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDroppable: import("@emotion/react").SerializedStyles;
	    isDragging: import("@emotion/react").SerializedStyles;
	    isDraggingOver: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    noGrow: import("@emotion/react").SerializedStyles;
	    spacing: {
	        none: null;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	};
	export const sharedSpacingPadding: ({ euiTheme }: UseEuiTheme) => {
	    none: null;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/drag_and_drop/droppable' {
	import React, { CSSProperties, FunctionComponent, ReactElement } from 'react';
	import { DroppableProps } from '@hello-pangea/dnd';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SPACINGS: readonly ["none", "s", "m", "l"];
	export interface EuiDroppableProps extends CommonProps, Omit<DroppableProps, 'children'> {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactElement | ReactElement[] | DroppableProps['children'];
	    className?: string;
	    /**
	     * Makes its items immutable. Dragging creates cloned items that can be dropped elsewhere.
	     */
	    cloneDraggables?: boolean;
	    style?: CSSProperties;
	    /**
	     * Adds padding to the droppable area
	     */
	    spacing?: (typeof SPACINGS)[number];
	    /**
	     * Adds an EuiPanel style to the droppable area
	     */
	    withPanel?: boolean;
	    /**
	     * Allow the panel to flex-grow?
	     */
	    grow?: boolean;
	}
	export const EuiDroppableContext: React.Context<{
	    cloneItems: boolean;
	}>;
	export const EuiDroppable: FunctionComponent<EuiDroppableProps>;

}
declare module '@elastic/eui/src/components/drag_and_drop/draggable.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDraggableStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDraggable: import("@emotion/react").SerializedStyles;
	    isDragging: import("@emotion/react").SerializedStyles;
	    hasClone: import("@emotion/react").SerializedStyles;
	    isRemovable: import("@emotion/react").SerializedStyles;
	    spacing: {
	        none: null;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiDraggableItemStyles: {
	    euiDraggable__item: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/drag_and_drop/draggable' {
	import { CSSProperties, FunctionComponent, ReactElement } from 'react';
	import { DraggableProps } from '@hello-pangea/dnd';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { SPACINGS } from '@elastic/eui/src/components/drag_and_drop/droppable';
	export interface EuiDraggableProps extends CommonProps, Omit<DraggableProps, 'children'> {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactElement | DraggableProps['children'];
	    className?: string;
	    /**
	     * Whether the `children` will provide and set up its own drag handle.
	     * The `custom` value additionally removes the `role` from the draggable container.
	     * Use this if the `children` element is focusable and should keep its
	     * semantic role for accessibility purposes.
	     */
	    customDragHandle?: boolean | 'custom';
	    /**
	     * Whether the container has interactive children and should have `role="group"` instead of `"button"`.
	     * Setting this flag ensures your drag & drop container is keyboard and screen reader accessible.
	     */
	    hasInteractiveChildren?: boolean;
	    /**
	     * Whether the item is currently in a position to be removed
	     */
	    isRemovable?: boolean;
	    /**
	     * Whether the currently dragged item is cloned into a portal in the body. This settings will
	     * ensure that drag & drop still works as expected within stacking contexts (e.g. within `EuiFlyout`,
	     * `EuiModal` and `EuiPopover`).
	     *
	     * Make sure to apply styles directly to the Draggable content as relative styling from an outside
	     * scope might not be applied when the content is placed in a portal as the DOM structure changes.
	     */
	    usePortal?: boolean;
	    /**
	     * Adds padding to the draggable item
	     */
	    spacing?: (typeof SPACINGS)[number];
	    style?: CSSProperties;
	}
	export const EuiDraggable: FunctionComponent<EuiDraggableProps>;

}
declare module '@elastic/eui/src/components/drag_and_drop/services' {
	import { DraggableLocation } from '@hello-pangea/dnd';
	interface DropResult {
	    [droppableId: string]: any[];
	}
	export const euiDragDropReorder: <T extends any[]>(list: T, startIndex: number, endIndex: number) => T;
	export const euiDragDropMove: (sourceList: any[], destinationList: any[], dropResultSource: DraggableLocation, dropResultDestination: DraggableLocation) => DropResult;
	export const euiDragDropCopy: (sourceList: any[], destinationList: any[], dropResultSource: DraggableLocation, dropResultDestination: DraggableLocation, idModification: {
	    property: string | number;
	    modifier: () => string | number;
	}) => DropResult;
	export {};

}
declare module '@elastic/eui/src/components/drag_and_drop' {
	export type { EuiDragDropContextProps } from '@elastic/eui/src/components/drag_and_drop/drag_drop_context';
	export { EuiDragDropContext } from '@elastic/eui/src/components/drag_and_drop/drag_drop_context';
	export type { EuiDraggableProps } from '@elastic/eui/src/components/drag_and_drop/draggable';
	export { EuiDraggable } from '@elastic/eui/src/components/drag_and_drop/draggable';
	export type { EuiDroppableProps } from '@elastic/eui/src/components/drag_and_drop/droppable';
	export { EuiDroppable } from '@elastic/eui/src/components/drag_and_drop/droppable';
	export { euiDragDropCopy, euiDragDropMove, euiDragDropReorder, } from '@elastic/eui/src/components/drag_and_drop/services';
	export type { DraggableLocation, DraggableProps, DraggableProvidedDragHandleProps, DragDropContextProps, DragStart, DroppableProps, DropResult, ResponderProvided, } from '@hello-pangea/dnd';

}
declare module '@elastic/eui/src/components/datagrid/utils/focus' {
	import { HTMLAttributes, KeyboardEvent } from 'react';
	import { DataGridFocusContextShape, EuiDataGridFocusedCell, EuiDataGridProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const DataGridFocusContext: import("react").Context<DataGridFocusContextShape>;
	type FocusProps = Pick<HTMLAttributes<HTMLDivElement>, 'tabIndex' | 'onKeyUp'>;
	/**
	 * Main focus context and overarching focus state management
	 */
	export const useFocus: () => DataGridFocusContextShape & {
	    focusProps: FocusProps;
	};
	export const notifyCellOfFocusState: (cellsUpdateFocus: Map<string, Function>, cell: EuiDataGridFocusedCell, isFocused: boolean) => void;
	/**
	 * Keydown handler for connecting focus state with keyboard navigation
	 */
	export const createKeyDownHandler: ({ gridElement, visibleColCount, visibleRowCount, visibleRowStartIndex, rowCount, pagination, hasFooter, focusContext, }: {
	    gridElement: HTMLDivElement | null;
	    visibleColCount: number;
	    visibleRowCount: number;
	    visibleRowStartIndex: number;
	    rowCount: EuiDataGridProps["rowCount"];
	    pagination: Required<EuiDataGridProps["pagination"]>;
	    hasFooter: boolean;
	    focusContext: DataGridFocusContextShape;
	}) => (event: KeyboardEvent<HTMLDivElement>) => void;
	/**
	 * Mutation observer for the grid body, which exists to pick up DOM changes
	 * in cells and remove interactive elements from the page's tab index, as
	 * we want to move between cells via arrow keys instead of tabbing.
	 */
	export const preventTabbing: (records: MutationRecord[]) => void;
	export const getParentCellContent: (_element: Node | HTMLElement) => HTMLElement | null;
	export {};

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridCellOutlineStyles: ({ euiTheme }: UseEuiTheme) => {
	    borderRadius: string;
	    focusColor: string;
	    focusStyles: string;
	    hoverColor: string;
	    hoverStyles: string;
	    markedColor: string;
	    markedStyles: string;
	};
	export const euiDataGridCellOutlineSelectors: (parentSelector?: string) => {
	    outline: {
	        show: string;
	        hover: string;
	        focusTrapped: string;
	        marked: string;
	    };
	    actions: {
	        hoverZone: string;
	        hoverColor: string;
	        showAnimation: string;
	        hoverAnimation: string;
	    };
	    header: {
	        focus: string;
	        focusTrapped: string;
	        showActions: string;
	        hideActions: string;
	    };
	};
	export const euiDataGridRowCellStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridRowCell: import("@emotion/react").SerializedStyles;
	    content: {
	        euiDataGridRowCell__content: import("@emotion/react").SerializedStyles;
	        autoHeight: import("@emotion/react").SerializedStyles;
	        defaultHeight: import("@emotion/react").SerializedStyles;
	        controlColumn: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/datagrid/data_grid.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridVariables: (euiThemeContext: UseEuiTheme) => {
	    cellPadding: {
	        s: string;
	        m: string;
	        l: string;
	    };
	    lineHeight: {
	        s: import("csstype").Property.LineHeight<string | number> | undefined;
	        m: import("csstype").Property.LineHeight<string | number> | undefined;
	    };
	    fontSize: {
	        s: import("csstype").Property.FontSize<string | number> | undefined;
	        m: import("csstype").Property.FontSize<string | number> | undefined;
	    };
	    levels: {
	        stickyHeader: number;
	    };
	};
	export const euiDataGridStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGrid: import("@emotion/react").SerializedStyles;
	    cellPadding: {
	        cellPadding: (size: "s" | "m" | "l") => import("@emotion/react").SerializedStyles;
	        readonly s: import("@emotion/react").SerializedStyles;
	        readonly m: import("@emotion/react").SerializedStyles;
	        readonly l: import("@emotion/react").SerializedStyles;
	    };
	    fontSize: {
	        fontSize: (size: "s" | "m") => import("@emotion/react").SerializedStyles;
	        readonly s: import("@emotion/react").SerializedStyles;
	        readonly m: import("@emotion/react").SerializedStyles;
	        readonly l: import("@emotion/react").SerializedStyles;
	    };
	    borders: {
	        none: null;
	        horizontal: import("@emotion/react").SerializedStyles;
	        all: import("@emotion/react").SerializedStyles;
	    };
	    euiDataGrid__content: import("@emotion/react").SerializedStyles;
	    euiDataGrid__focusWrap: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/draggable_columns.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridDraggableHeaderStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiDataGridHeaderDroppable: import("@emotion/react").SerializedStyles;
	    euiDataGridHeaderCellDraggableWrapper: import("@emotion/react").SerializedStyles;
	    euiDataGridHeaderCellDraggable: import("@emotion/react").SerializedStyles;
	    isKeyboardDragging: import("@emotion/react").SerializedStyles;
	    underline: import("@emotion/react").SerializedStyles;
	    shade: import("@emotion/react").SerializedStyles;
	    noLeadingBorder: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/draggable_columns' {
	import { CSSProperties, FunctionComponent, ComponentProps, ReactElement, ReactNode } from 'react';
	import { DraggableProvidedDragHandleProps } from '@hello-pangea/dnd';
	import { EuiDroppableProps } from '@elastic/eui/src/components/drag_and_drop';
	import { EuiDataGridHeaderRowProps, EuiDataGridStyle } from '@elastic/eui/src/components/datagrid/data_grid_types';
	/**
	 * Parent context + EuiDroppable wrapper
	 */
	export const DroppableColumns: FunctionComponent<Pick<EuiDataGridHeaderRowProps, 'columns' | 'switchColumnPos'> & {
	    indexOffset: number;
	    children: EuiDroppableProps['children'];
	}>;
	/**
	 * Individual EuiDraggable columns
	 */
	export const DraggableColumn: FunctionComponent<{
	    id: string;
	    index: number;
	    gridStyles: EuiDataGridStyle;
	    columnResizer?: ReactNode;
	    actionsPopoverToggle?: HTMLButtonElement | null;
	    children: (dragProps?: Partial<DraggableProvidedDragHandleProps> & {
	        'data-column-moving'?: boolean;
	    }) => ReactElement;
	}>;
	/**
	 * Components for conditionally rendering drag/drop wrappers
	 * Allows us to conditionally call hooks while not instantiating a bunch
	 * of extra state/etc., since draggable columns isn't yet(?) a default
	 */
	type CanDragAndDropColumns = {
	    canDragAndDropColumns: boolean;
	};
	export const ConditionalDroppableColumns: FunctionComponent<ComponentProps<typeof DroppableColumns> & CanDragAndDropColumns>;
	export const ConditionalDraggableColumn: FunctionComponent<ComponentProps<typeof DraggableColumn> & CanDragAndDropColumns>;
	/**
	 * Creates an invisible overlay that prevents hover interactions/transitions
	 * on other elements that the dragged element is dragged over, and also maintains
	 * the intended drag cursor over any location.
	 *
	 * TODO: If this is useful elsewhere, consider moving it to `src/services`
	 */
	export const DragOverlay: FunctionComponent<{
	    isDragging?: boolean;
	    cursor?: CSSProperties['cursor'];
	    zIndex?: CSSProperties['zIndex'];
	}>;
	export {};

}
declare module '@elastic/eui/src/utils/prop_types/is' {
	export const is: <T>(expectedValue: any) => {
	    (props: T, propName: keyof T, componentName: string): Error | null;
	    isRequired(props: T, propName: keyof T, componentName: string): Error | null;
	};

}
declare module '@elastic/eui/src/utils/prop_types/with_required_prop' {
	/**
	 * PropType validation that, if the property is present,
	 * validates against a proptype and verifies that another property exists
	 *
	 * example:
	 * ExampleComponent.propTypes = {
	 *   items: PropTypes.array,
	 *   itemId: withRequiredProp(PropTypes.string, 'items', 'itemId is required to extract the ID from an item')
	 * }
	 *
	 * this validator warns if ExampleComponent is passed an `items` prop but not `itemId`
	 */
	export const withRequiredProp: (proptype: any, requiredPropName: string, messageDescription?: string) => (...args: any[]) => any;

}
declare module '@elastic/eui/src/utils/prop_types' {
	export const EuiPropTypes: {
	    is: <T>(expectedValue: any) => {
	        (props: T, propName: keyof T, componentName: string): Error | null;
	        isRequired(props: T, propName: keyof T, componentName: string): Error | null;
	    };
	    withRequiredProp: (proptype: any, requiredPropName: string, messageDescription?: string) => (...args: any[]) => any;
	};

}
declare module '@elastic/eui/src/utils/is_jest' {
	export const IS_JEST_ENVIRONMENT: boolean;

}
declare module '@elastic/eui/src/utils/type_guards' {
	export const isDOMNode: (el: any) => el is Node;

}
declare module '@elastic/eui/src/utils/element_can_be_disabled' {
	export const elementCanBeDisabled: <T extends HTMLElement>(htmlElement: T | null) => boolean;

}
declare module '@elastic/eui/src/utils' {
	export * from '@elastic/eui/src/utils/prop_types';
	export * from '@elastic/eui/src/utils/is_jest';
	export * from '@elastic/eui/src/utils/type_guards';
	export { elementCanBeDisabled } from '@elastic/eui/src/utils/element_can_be_disabled';

}
declare module '@elastic/eui/src/components/datagrid/body/cell/focus_utils' {
	import { PropsWithChildren, FunctionComponent } from 'react';
	import { FocusableElement } from 'tabbable';
	/**
	 * This internal utility component is used by all cells, both header and body/footer cells.
	 * It always handles:
	 *   1. Removing any interactive children from keyboard tab order on cell mount
	 *   2. Listening for focus on any interactive children and updating the cell focus context
	 *
	 * It should *only* render focus traps for:
	 *   1. Header cells that are `actions: false` but still have interactive children
	 *   2. Body cells that are `isExpandable: false` but still have interactive children
	 */
	export const HandleInteractiveChildren: FunctionComponent<PropsWithChildren & {
	    cellEl?: HTMLElement | null;
	    updateCellFocusContext: Function;
	    renderFocusTrap?: boolean;
	    onInteractiveChildrenFound?: (interactiveChildren: FocusableElement[]) => void;
	}>;
	/**
	 * Cells with interactive children but no cell popover expansion should render a
	 * focus trap that can be entered with the Enter key, which cycles keyboard tabs
	 * through the cell contents only, and exited with the Escape key
	 */
	export const FocusTrappedChildren: FunctionComponent<PropsWithChildren & {
	    cellEl: HTMLElement;
	}>;

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_cell_wrapper.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Styles that apply to both control and non-control columns
	 */
	export const euiDataGridHeaderCellWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridHeaderCell: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_cell_wrapper' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridHeaderCellWrapperProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	/**
	 * This is a wrapper that handles repeated concerns between control &
	 * standard header cells. Most of its shared logic is around focus state/UX,
	 * but it also DRY's out certain class/data-test-subj/style attributes
	 */
	export const EuiDataGridHeaderCellWrapper: FunctionComponent<EuiDataGridHeaderCellWrapperProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_control_header_cell' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridControlHeaderCellProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGridControlHeaderCell: FunctionComponent<EuiDataGridControlHeaderCellProps>;

}
declare module '@elastic/eui/src/components/datagrid/controls/column_sorting.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridColumnSortingStyles: (euiThemeContext: UseEuiTheme) => {
	    /**
	     * Sorted fields
	     */
	    euiDataGridColumnSorting: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSorting__item: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSorting__name: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSorting__order: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSorting__dragHandle: import("@emotion/react").SerializedStyles;
	    /**
	     * 'Pick fields to sort by' popover
	     */
	    euiDataGridColumnSorting__fieldList: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSorting__field: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/column_sorting_draggable' {
	import React, { FunctionComponent } from 'react';
	import { EuiDataGridColumnSortingDraggableProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const defaultSortAscLabel: React.JSX.Element;
	export const defaultSortDescLabel: React.JSX.Element;
	export const EuiDataGridColumnSortingDraggable: FunctionComponent<EuiDataGridColumnSortingDraggableProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_cell.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Styles only applied to data header cell content, not control header cells
	 */
	export const euiDataGridHeaderCellStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridHeaderCell__content: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    euiDataGridHeaderCell__popover: import("@emotion/react").SerializedStyles;
	    euiDataGridHeaderCell__actions: {
	        action: import("@emotion/react").SerializedStyles;
	        start: import("@emotion/react").SerializedStyles;
	        end: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/column_actions' {
	import React, { Ref, KeyboardEventHandler, FunctionComponent } from 'react';
	import { EuiListGroupItemProps } from '@elastic/eui/src/components/list_group';
	import { EuiDataGridHeaderCellProps, EuiDataGridColumn, EuiDataGridColumnActions, EuiDataGridSchema, EuiDataGridSchemaDetector, EuiDataGridSorting, DataGridFocusContextShape } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const useHasColumnActions: (columnActions: EuiDataGridColumn["actions"]) => boolean;
	export type PropsFromColumnActions = {
	    className?: string;
	    onKeyDown?: KeyboardEventHandler;
	    'data-column-moving'?: boolean;
	};
	export const ColumnActions: FunctionComponent<Pick<EuiDataGridHeaderCellProps, 'index' | 'column' | 'columns' | 'schema' | 'schemaDetectors' | 'setVisibleColumns' | 'switchColumnPos' | 'sorting'> & {
	    id: string;
	    title: string;
	    hasFocusTrap: boolean;
	    setPropsFromColumnActions: (props: PropsFromColumnActions) => void;
	    actionsButtonRef: Ref<HTMLButtonElement>;
	}>;
	/**
	 * Add keyboard arrow navigation to the cell actions popover
	 * to match the UX of the rest of EuiDataGrid
	 */
	export const usePopoverArrowNavigation: () => {
	    panelRef: (ref: HTMLElement | null) => void;
	    panelProps: {
	        onKeyDown: (e: React.KeyboardEvent) => void;
	    };
	    popoverScreenReaderText: React.JSX.Element;
	};
	/**
	 * Logic for returning an array of actions/items to pass to EuiListGroup
	 */
	interface GetColumnActions {
	    column: EuiDataGridColumn;
	    columns: EuiDataGridColumn[];
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	    setVisibleColumns: (columnId: string[]) => void;
	    focusFirstVisibleInteractiveCell: DataGridFocusContextShape['focusFirstVisibleInteractiveCell'];
	    setIsPopoverOpen: (value: boolean) => void;
	    sorting: EuiDataGridSorting | undefined;
	    switchColumnPos: (colFromId: string, colToId: string) => void;
	    setIsColumnMoving: (value: boolean) => void;
	    setFocusedCell: DataGridFocusContextShape['setFocusedCell'];
	    columnFocusIndex: number;
	}
	export const getColumnActions: ({ column, columns, schema, schemaDetectors, setVisibleColumns, focusFirstVisibleInteractiveCell, setIsPopoverOpen, sorting, switchColumnPos, setIsColumnMoving, setFocusedCell, columnFocusIndex, }: GetColumnActions) => EuiListGroupItemProps[];
	/**
	 * Hide column action
	 */
	type HideColumnAction = Pick<GetColumnActions, 'column' | 'columns' | 'setVisibleColumns' | 'focusFirstVisibleInteractiveCell'>;
	export const getHideColumnAction: ({ column, columns, setVisibleColumns, focusFirstVisibleInteractiveCell, }: HideColumnAction) => EuiListGroupItemProps[];
	/**
	 * Sort column actions
	 */
	type SortColumnActions = Pick<GetColumnActions, 'column' | 'sorting' | 'schema' | 'schemaDetectors'>;
	export const getSortColumnActions: ({ column, sorting, schema, schemaDetectors, }: SortColumnActions) => EuiListGroupItemProps[];
	/**
	 * Column action utility helpers - mostly syntactical sugar for adding an extra
	 * actions !== false checks, which we make an early return for in the main fn,
	 * but that the individual utils don't know about and Typescript complains about
	 */
	export const isColumnActionEnabled: (actionKey: keyof EuiDataGridColumnActions, actions: EuiDataGridColumn["actions"]) => boolean;
	export const getColumnActionConfig: (action: EuiListGroupItemProps, actionKey: keyof EuiDataGridColumnActions, actions: EuiDataGridColumn["actions"]) => EuiListGroupItemProps;
	export {};

}
declare module '@elastic/eui/src/components/datagrid/body/header/column_sorting' {
	import React from 'react';
	import { EuiDataGridSorting } from '@elastic/eui/src/components/datagrid/data_grid_types';
	/**
	 * Column sorting utility helpers
	 */
	export const useColumnSorting: ({ sorting, id, }: {
	    sorting?: EuiDataGridSorting;
	    id: string;
	}) => {
	    sortingArrow: React.JSX.Element | null;
	    ariaSort: "ascending" | "descending" | undefined;
	    sortingAriaId: string;
	    sortingScreenReaderText: React.JSX.Element | null;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/column_resizer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridColumnResizerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridColumnResizer: import("@emotion/react").SerializedStyles;
	    isLastColumn: import("@emotion/react").SerializedStyles;
	    isDragging: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/column_resizer' {
	import React, { Component } from 'react';
	import { EuiDataGridColumnResizerProps, EuiDataGridColumnResizerState } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export class EuiDataGridColumnResizer extends Component<EuiDataGridColumnResizerProps, EuiDataGridColumnResizerState> {
	    state: {
	        initialX: number;
	        offset: number;
	    };
	    onMouseDown: (e: React.MouseEvent<HTMLDivElement>) => void;
	    onMouseUp: () => void;
	    onMouseMove: (e: {
	        pageX: number;
	    }) => void;
	    render(): React.JSX.Element;
	}

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_cell' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridHeaderCellProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGridHeaderCell: FunctionComponent<EuiDataGridHeaderCellProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_row.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridHeader: import("@emotion/react").SerializedStyles;
	    underline: import("@emotion/react").SerializedStyles;
	    shade: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header/data_grid_header_row' {
	import React from 'react'; const EuiDataGridHeaderRow: React.MemoExoticComponent<React.ForwardRefExoticComponent<import ("@elastic/eui/src/components").CommonProps & React.HTMLAttributes<HTMLDivElement> & import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridHeaderRowPropsSpecificProps & React.RefAttributes<HTMLDivElement>>>;
	export { EuiDataGridHeaderRow };

}
declare module '@elastic/eui/src/components/datagrid/body/header/use_data_grid_header' {
	import React from 'react';
	import { EuiDataGridHeaderRowProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	/**
	 * DRY out setting up the grid header and its refs & observers
	 */
	export const useDataGridHeader: (props: EuiDataGridHeaderRowProps) => {
	    headerRow: React.JSX.Element;
	    headerRowHeight: number;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/header' {
	export { EuiDataGridHeaderRow } from '@elastic/eui/src/components/datagrid/body/header/data_grid_header_row';
	export { useDataGridHeader } from '@elastic/eui/src/components/datagrid/body/header/use_data_grid_header';

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_actions.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridCellActionsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridRowCell__actionsWrapper: import("@emotion/react").SerializedStyles;
	    euiDataGridRowCell__actions: import("@emotion/react").SerializedStyles;
	    euiDataGridRowCell__actionButtonIcon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_actions' {
	import React, { Ref } from 'react';
	import { EuiDataGridColumn } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGridCellActions: ({ onExpandClick, popoverAnchorRef, column, rowIndex, colIndex, }: {
	    onExpandClick: () => void;
	    popoverAnchorRef: Ref<HTMLDivElement>;
	    column?: EuiDataGridColumn;
	    rowIndex: number;
	    colIndex: number;
	}) => React.JSX.Element;
	export const EuiDataGridCellPopoverActions: ({ rowIndex, colIndex, column, }: {
	    column?: EuiDataGridColumn;
	    colIndex: number;
	    rowIndex: number;
	}) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_popover.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridCellPopoverStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridRowCell__popover: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_popover' {
	import React, { ReactNode } from 'react';
	import { DataGridCellPopoverContextShape, EuiDataGridCellPopoverElementProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const DataGridCellPopoverContext: React.Context<DataGridCellPopoverContextShape>;
	export const useCellPopover: () => {
	    cellPopoverContext: DataGridCellPopoverContextShape;
	    cellPopover: ReactNode;
	};
	export const DefaultCellPopover: ({ schema, cellActions, children, cellContentsElement, }: EuiDataGridCellPopoverElementProps) => React.JSX.Element;
	export const JsonPopoverContent: ({ cellText }: {
	    cellText: string;
	}) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell' {
	import React, { Component, ContextType, KeyboardEvent, MutableRefObject } from 'react';
	import { DataGridFocusContext } from '@elastic/eui/src/components/datagrid/utils/focus';
	import { EuiDataGridCellProps, EuiDataGridCellState, EuiDataGridSetCellProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export class EuiDataGridCell extends Component<EuiDataGridCellProps, EuiDataGridCellState> {
	    cellRef: MutableRefObject<HTMLDivElement | null>;
	    contentObserver: any;
	    popoverAnchorRef: MutableRefObject<HTMLDivElement | null>;
	    cellContentsRef: HTMLDivElement | null;
	    state: EuiDataGridCellState;
	    unsubscribeCell?: Function;
	    style: null;
	    static contextType: React.Context<import ("@elastic/eui/src/components/datagrid/data_grid_types").DataGridFocusContextShape>;
	    context: ContextType<typeof DataGridFocusContext>;
	    updateCellFocusContext: () => void;
	    takeFocus: (preventScroll: boolean) => void;
	    recalculateAutoHeight: () => void;
	    recalculateLineHeight: () => void;
	    componentDidMount(): void;
	    isFocusedCell: () => boolean;
	    onFocusUpdate: (isFocused: boolean, preventScroll?: boolean) => void;
	    componentWillUnmount(): void;
	    componentDidUpdate(prevProps: EuiDataGridCellProps): void;
	    shouldComponentUpdate(nextProps: EuiDataGridCellProps, nextState: EuiDataGridCellState): boolean;
	    setCellProps: (cellProps: EuiDataGridSetCellProps) => void;
	    setCellContentsRef: (ref: HTMLDivElement | null) => void;
	    isExpandable: () => boolean;
	    isPopoverOpen: () => boolean;
	    handleCellPopover: () => void;
	    handleCellKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
	    handleCellExpansionClick: () => void;
	    onMouseEnter: () => void;
	    onMouseLeave: () => void;
	    render(): React.JSX.Element;
	}

}
declare module '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_wrapper' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridCellProps, EuiDataGridBodyProps, EuiDataGridHeaderRowProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export type CellProps = Pick<EuiDataGridCellProps, 'colIndex' | 'visibleRowIndex' | 'style' | 'renderCellValue' | 'cellContext' | 'renderCellPopover' | 'interactiveCellId' | 'gridStyles' | 'rowHeightsOptions' | 'rowHeightUtils' | 'rowManager' | 'setRowHeight' | 'column'> & Pick<EuiDataGridBodyProps, 'schema' | 'schemaDetectors' | 'pagination' | 'columns' | 'leadingControlColumns' | 'trailingControlColumns' | 'visibleColCount'> & Pick<EuiDataGridHeaderRowProps, 'columnWidths' | 'defaultColumnWidth'> & Partial<EuiDataGridCellProps>;
	/**
	 * A DRY wrapper used by both custom and virtualized grid cells.
	 * It grabs context,  determines the type of cell being rendered
	 * (e.g. control vs data cell), & sets shared props between all cells
	 */
	export const CellWrapper: FunctionComponent<CellProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/cell' {
	export { EuiDataGridCell } from '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell';
	export { CellWrapper } from '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_wrapper';
	export { DataGridCellPopoverContext, useCellPopover, } from '@elastic/eui/src/components/datagrid/body/cell/data_grid_cell_popover';

}
declare module '@elastic/eui/src/components/datagrid/body/footer/data_grid_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridFooter: import("@emotion/react").SerializedStyles;
	    sticky: import("@emotion/react").SerializedStyles;
	    overline: import("@emotion/react").SerializedStyles;
	    shade: import("@emotion/react").SerializedStyles;
	    striped: import("@emotion/react").SerializedStyles;
	    euiDataGridFooterCell: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/footer/data_grid_footer_row' {
	import React from 'react'; const EuiDataGridFooterRow: React.MemoExoticComponent<React.ForwardRefExoticComponent<import ("@elastic/eui/src/components").CommonProps & React.HTMLAttributes<HTMLDivElement> & {
	    rowIndex: number;
	    leadingControlColumns: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridControlColumn[];
	    trailingControlColumns: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridControlColumn[];
	    columns: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridColumn[];
	    schema: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridSchema;
	    columnWidths: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridColumnWidths;
	    defaultColumnWidth?: number | null;
	    renderCellValue: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridCellProps["renderCellValue"];
	    renderCellPopover?: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridCellProps["renderCellPopover"];
	    interactiveCellId: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridCellProps["interactiveCellId"];
	    visibleRowIndex?: number;
	    visibleColCount: number;
	    gridStyles: import ("@elastic/eui/src/components/datagrid/data_grid_types").EuiDataGridStyle;
	} & React.RefAttributes<HTMLDivElement>>>;
	export { EuiDataGridFooterRow };

}
declare module '@elastic/eui/src/components/datagrid/body/footer/use_data_grid_footer' {
	import React from 'react';
	import { EuiDataGridFooterRowProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	type Props = Omit<EuiDataGridFooterRowProps, 'renderCellValue'> & {
	    renderFooterCellValue?: EuiDataGridFooterRowProps['renderCellValue'];
	};
	/**
	 * DRY out setting up the grid footer and its refs & observers
	 */
	export const useDataGridFooter: (props: Props) => {
	    footerRow: React.JSX.Element | null;
	    footerRowHeight: number;
	};
	export {};

}
declare module '@elastic/eui/src/components/datagrid/body/footer' {
	export { EuiDataGridFooterRow } from '@elastic/eui/src/components/datagrid/body/footer/data_grid_footer_row';
	export { useDataGridFooter } from '@elastic/eui/src/components/datagrid/body/footer/use_data_grid_footer';

}
declare module '@elastic/eui/src/components/datagrid/body/data_grid_row_manager' {
	import { RefObject } from 'react';
	import { EuiDataGridRowManager, EuiDataGridStyle } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const useRowManager: ({ innerGridRef, rowClasses, }: {
	    innerGridRef: RefObject<HTMLDivElement>;
	    rowClasses?: EuiDataGridStyle["rowClasses"];
	}) => EuiDataGridRowManager;

}
declare module '@elastic/eui/src/components/datagrid/utils/grid_height_width' {
	import { MutableRefObject } from 'react';
	import { EuiDataGridRowHeightsOptions } from '@elastic/eui/src/components/datagrid/data_grid_types';
	import { RowHeightUtilsType } from '@elastic/eui/src/components/datagrid/utils/row_heights';
	export const useFinalGridDimensions: ({ unconstrainedHeight, unconstrainedWidth, wrapperDimensions, wrapperRef, isFullScreen, rowCount, }: {
	    unconstrainedHeight: number;
	    unconstrainedWidth: number;
	    wrapperDimensions: {
	        width: number;
	        height: number;
	    };
	    wrapperRef: MutableRefObject<HTMLDivElement | null>;
	    isFullScreen: boolean;
	    rowCount: number;
	}) => {
	    finalHeight: number;
	    finalWidth: number;
	};
	/**
	 * Computes the unconstrained (total possible) height of a grid
	 */
	export const useUnconstrainedHeight: ({ rowHeightUtils, startRow, endRow, rowHeightsOptions, defaultRowHeight, headerRowHeight, footerRowHeight, scrollBarHeight, innerGridRef, }: {
	    rowHeightUtils: RowHeightUtilsType;
	    startRow: number;
	    endRow: number;
	    rowHeightsOptions?: EuiDataGridRowHeightsOptions;
	    defaultRowHeight: number;
	    headerRowHeight: number;
	    footerRowHeight: number;
	    scrollBarHeight: number;
	    innerGridRef: React.MutableRefObject<HTMLDivElement | null>;
	}) => number;
	/**
	 * Returns the size of the cell container minus the scroll bar width.
	 * To do so, this hook is listening for size changes of the container itself,
	 * as well as pagination changes to make sure every update is caught.
	 *
	 * This is necessary because there is no callback/event fired by the browser
	 * indicating the scroll bar state has changed.
	 * @param resizeRef the wrapper element containging the data grid
	 * @param pageSize the currently applied page size
	 */
	export const useVirtualizeContainerWidth: (virtualizeContainer: HTMLDivElement | null, gridWidth: number, pageSize: number | undefined) => number;

}
declare module '@elastic/eui/src/components/datagrid/utils/col_widths' {
	import { EuiDataGridColumn, EuiDataGridColumnWidths, EuiDataGridControlColumn, EuiDataGridOnColumnResizeHandler, EuiDataGridProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const useDefaultColumnWidth: (gridWidth: number, leadingControlColumns: EuiDataGridControlColumn[], trailingControlColumns: EuiDataGridControlColumn[], columns: EuiDataGridProps["columns"]) => number | null;
	export const doesColumnHaveAnInitialWidth: (column: EuiDataGridColumn) => boolean;
	export const useColumnWidths: ({ columns, leadingControlColumns, trailingControlColumns, defaultColumnWidth, onColumnResize, }: {
	    columns: EuiDataGridColumn[];
	    leadingControlColumns: EuiDataGridControlColumn[];
	    trailingControlColumns: EuiDataGridControlColumn[];
	    defaultColumnWidth?: number | null;
	    onColumnResize?: EuiDataGridOnColumnResizeHandler;
	}) => {
	    columnWidths: EuiDataGridColumnWidths;
	    setColumnWidth: (columnId: string, width: number) => void;
	    getColumnWidth: (index: number) => number;
	};

}
declare module '@elastic/eui/src/components/datagrid/utils/scrolling.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridScrollBarStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGrid__scrollOverlay: import("@emotion/react").SerializedStyles;
	    euiDataGrid__scrollBarOverlayBottom: import("@emotion/react").SerializedStyles;
	    euiDataGrid__scrollBarOverlayRight: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/utils/scrolling' {
	import { MutableRefObject, ReactNode } from 'react';
	import { VariableSizeGrid as Grid } from 'react-window';
	import { EuiDataGridStyle } from '@elastic/eui/src/components/datagrid/data_grid_types';
	interface ScrollCellIntoView {
	    rowIndex: number;
	    colIndex: number;
	}
	interface Dependencies {
	    gridRef: MutableRefObject<Grid | null>;
	    outerGridRef: MutableRefObject<HTMLDivElement | null>;
	    hasGridScrolling: boolean;
	    headerRowHeight: number;
	    footerRowHeight: number;
	    visibleRowCount: number;
	    hasStickyFooter: boolean;
	    canDragAndDropColumns?: boolean;
	}
	/**
	 * The primary goal of this scroll logic is to ensure keyboard navigation works accessibly,
	 * but there are other scenarios where it applies (e.g. clicking partially-visible cells)
	 * or is useful for (e.g. manually scrolling to cell that is currently out of viewport
	 * while accounting for headers/footers/scrollbars)
	 */
	export const useScroll: (args: Dependencies) => {
	    scrollCellIntoView: ({ rowIndex, colIndex }: ScrollCellIntoView) => Promise<void>;
	};
	/**
	 * Ensures that the passed cell is always fully in view by using cell position
	 * checks and scroll adjustments/workarounds.
	 */
	export const useScrollCellIntoView: ({ gridRef, outerGridRef, hasGridScrolling, headerRowHeight, footerRowHeight, visibleRowCount, hasStickyFooter, canDragAndDropColumns, }: Dependencies) => {
	    scrollCellIntoView: ({ rowIndex, colIndex }: ScrollCellIntoView) => Promise<void>;
	};
	/**
	 * Checks whether the current grid scrolls and/or has scrollbars
	 */
	export const useScrollBars: (outerGridRef: MutableRefObject<HTMLDivElement | null>, borderStyle?: EuiDataGridStyle["border"]) => {
	    scrollBarHeight: number;
	    scrollBarWidth: number;
	    hasVerticalScroll: boolean;
	    hasHorizontalScroll: boolean;
	    scrollBorderOverlay: ReactNode;
	};
	export {};

}
declare module '@elastic/eui/src/components/datagrid/body/data_grid_body_virtualized' {
	import React, { FunctionComponent } from 'react';
	import { GridChildComponentProps } from 'react-window';
	import { EuiDataGridBodyProps, DataGridWrapperRowsContentsShape } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const Cell: FunctionComponent<GridChildComponentProps>;
	export const DataGridWrapperRowsContext: React.Context<DataGridWrapperRowsContentsShape>;
	export const EuiDataGridBodyVirtualized: FunctionComponent<EuiDataGridBodyProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/data_grid_body_custom' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridBodyProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGridBodyCustomRender: FunctionComponent<EuiDataGridBodyProps>;

}
declare module '@elastic/eui/src/components/datagrid/body/data_grid_body.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridBodyStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridBody: import("@emotion/react").SerializedStyles;
	    virtualized: import("@emotion/react").SerializedStyles;
	    customRender: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/body/data_grid_body' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridBodyProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGridBody: FunctionComponent<EuiDataGridBodyProps>;

}
declare module '@elastic/eui/src/components/datagrid/body' {
	export { EuiDataGridBody } from '@elastic/eui/src/components/datagrid/body/data_grid_body';

}
declare module '@elastic/eui/src/components/datagrid/controls/data_grid_toolbar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridToolbarStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiDataGrid__controls: import("@emotion/react").SerializedStyles;
	    euiDataGrid__rightControls: import("@emotion/react").SerializedStyles;
	    euiDataGrid__leftControls: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/data_grid_toolbar' {
	import React, { ReactNode } from 'react';
	import { EuiDataGridProps, EuiDataGridToolbarProps, EuiDataGridToolBarVisibilityOptions } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const MINIMUM_WIDTH_FOR_GRID_CONTROLS = 479;
	export const EuiDataGridToolbar: ({ gridWidth, minSizeForControls, toolbarVisibility, isFullScreen, fullScreenSelector, keyboardShortcuts, displaySelector, columnSelector, columnSorting, renderCustomToolbar, }: EuiDataGridToolbarProps) => React.JSX.Element;
	export function checkOrDefaultToolBarDisplayOptions<OptionKey extends keyof EuiDataGridToolBarVisibilityOptions>(arg: EuiDataGridProps['toolbarVisibility'], option: OptionKey): Required<EuiDataGridToolBarVisibilityOptions>[OptionKey];
	export const renderAdditionalControls: (toolbarVisibility: EuiDataGridProps["toolbarVisibility"], position: "left.prepend" | "left.append" | "right") => ReactNode;
	/**
	 * Utility helper for selectors/controls that allow nested options
	 * (e.g. column selector, display selector)
	 */
	export function getNestedObjectOptions<T>(controlOption: undefined | boolean | T, objectKey: keyof T): boolean;

}
declare module '@elastic/eui/src/components/datagrid/controls/data_grid_toolbar_control' {
	import { FunctionComponent } from 'react';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	export type EuiDataGridToolbarControlProps = EuiButtonEmptyProps & {
	    badgeContent?: number | string;
	};
	export const EuiDataGridToolbarControl: FunctionComponent<EuiDataGridToolbarControlProps>;

}
declare module '@elastic/eui/src/components/datagrid/controls/column_selector.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridColumnSelectorStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGridColumnSelector: import("@emotion/react").SerializedStyles;
	    euiDataGridColumnSelector__item: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/column_selector' {
	import { ReactNode } from 'react';
	import { EuiDataGridColumn, EuiDataGridColumnVisibility, EuiDataGridToolBarVisibilityOptions } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const useDataGridColumnSelector: (availableColumns: EuiDataGridColumn[], columnVisibility: EuiDataGridColumnVisibility, showColumnSelector: EuiDataGridToolBarVisibilityOptions["showColumnSelector"], displayValues: {
	    [key: string]: string;
	}) => [ReactNode, EuiDataGridColumn[], (columns: string[]) => void, (colFrom: string, colTo: string) => void];

}
declare module '@elastic/eui/src/components/datagrid/controls/column_sorting' {
	import { ReactNode, FunctionComponent } from 'react';
	import { EuiDataGridColumn, EuiDataGridSchema, EuiDataGridSchemaDetector, EuiDataGridSorting } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export type ColumnSortingProps = {
	    sorting: EuiDataGridSorting;
	    columns: EuiDataGridColumn[];
	    displayValues: {
	        [key: string]: string;
	    };
	    schema: EuiDataGridSchema;
	    schemaDetectors: EuiDataGridSchemaDetector[];
	};
	export const useDataGridColumnSorting: ({ sorting, ...rest }: Omit<ColumnSortingProps, "sorting"> & {
	    sorting?: EuiDataGridSorting;
	}) => ReactNode;
	export const DataGridSortingControl: FunctionComponent<ColumnSortingProps>;

}
declare module '@elastic/eui/src/components/datagrid/controls/display_selector' {
	import { ReactNode } from 'react';
	import { EuiDataGridToolBarVisibilityOptions, EuiDataGridStyle, EuiDataGridRowHeightsOptions } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const startingStyles: EuiDataGridStyle;
	/**
	 * Display settings/selector popover
	 */
	export const useDataGridDisplaySelector: (showDisplaySelector: EuiDataGridToolBarVisibilityOptions["showDisplaySelector"], passedGridStyles: EuiDataGridStyle, passedRowHeightsOptions?: EuiDataGridRowHeightsOptions) => [ReactNode, EuiDataGridStyle, EuiDataGridRowHeightsOptions];

}
declare module '@elastic/eui/src/components/description_list/description_list_types' {
	import { HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiDescriptionListProps {
	    listItems?: Array<{
	        title: NonNullable<ReactNode>;
	        description: NonNullable<ReactNode>;
	    }>;
	    /**
	     * Text alignment
	     */
	    align?: EuiDescriptionListAlignment;
	    /**
	     * Smaller text and condensed spacing
	     */
	    compressed?: boolean;
	    /**
	     * How should the content be styled, by default
	     * this will emphasize the title
	     */
	    textStyle?: 'normal' | 'reverse';
	    /**
	     * How each item should be laid out
	     */
	    type?: EuiDescriptionListType;
	    /**
	     * Props object to be passed to `EuiDescriptionListTitle`
	     */
	    titleProps?: HTMLAttributes<HTMLElement> & CommonProps;
	    /**
	     * Props object to be passed to `EuiDescriptionListDescription`
	     */
	    descriptionProps?: HTMLAttributes<HTMLElement> & CommonProps;
	    /**
	     * Allows customizing the vertical spacing between rows.
	     */
	    rowGutterSize?: EuiDescriptionListGutterSizes;
	    /**
	     * Allows customizing the horizontal spacing between columns.
	     *
	     * Only applies to `column` and `responsiveColumn` types.
	     */
	    columnGutterSize?: EuiDescriptionListColumnGapSizes;
	    /**
	     * Allows customizing specific column widths (e.g. `['100px', '200px']`). The first
	     * array value applies to the title column, and the second applies to the description column.
	     *
	     * Passing numbers instead of CSS width strings will use a ratio of widths.
	     * For example, [1, 3] will render a description column 3x the width of the title column.
	     * In other words, descriptions will have a width of `75%` and titles will have a width of `25%`.
	     *
	     * Only applies to `column` and `responsiveColumn` types.
	     *
	     * _Advanced usage note:_ column width strings also accept [CSS grid special units,
	     * sizing, keywords, and sizing functions](https://css-tricks.com/snippets/css/complete-guide-grid/#aa-special-units-functions).
	     */
	    columnWidths?: [number | string, number | string];
	}
	export const CHILD_TYPES: readonly ["row", "inline", "column"];
	export type EuiDescriptionListChildTypes = (typeof CHILD_TYPES)[number];
	export const TYPES: readonly ["row", "inline", "column", "responsiveColumn"];
	export type EuiDescriptionListType = (typeof TYPES)[number];
	export const ALIGNMENTS: readonly ["center", "left"];
	export type EuiDescriptionListAlignment = (typeof ALIGNMENTS)[number];
	export const TEXT_STYLES: readonly ["normal", "reverse"];
	export type EuiDescriptionListTextStyle = (typeof TEXT_STYLES)[number];
	export const ROW_GUTTER_SIZES: readonly ["s", "m"];
	export type EuiDescriptionListGutterSizes = (typeof ROW_GUTTER_SIZES)[number];
	export const COLUMN_GUTTER_SIZES: readonly ["s", "m"];
	export type EuiDescriptionListColumnGapSizes = (typeof COLUMN_GUTTER_SIZES)[number];

}
declare module '@elastic/eui/src/components/description_list/description_list_context' {
	import { EuiDescriptionListProps, EuiDescriptionListChildTypes } from '@elastic/eui/src/components/description_list/description_list_types';
	type EuiDescriptionListContextValues = Required<Pick<EuiDescriptionListProps, 'textStyle' | 'align' | 'rowGutterSize'> & {
	    type: EuiDescriptionListChildTypes;
	}> & {
	    compressed?: EuiDescriptionListProps['compressed'];
	};
	export const contextDefaults: EuiDescriptionListContextValues;
	export const EuiDescriptionListContext: import("react").Context<EuiDescriptionListContextValues>;
	export {};

}
declare module '@elastic/eui/src/components/description_list/description_list_title.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDescriptionListTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDescriptionList__title: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    inline: import("@emotion/react").SerializedStyles;
	    fontStyles: {
	        normal: import("@emotion/react").SerializedStyles;
	        reverse: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    inlineStyles: {
	        normal: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    right: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/description_list/description_list_title' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiDescriptionListTitleProps extends CommonProps, HTMLAttributes<HTMLElement> {
	}
	export const EuiDescriptionListTitle: FunctionComponent<EuiDescriptionListTitleProps>;

}
declare module '@elastic/eui/src/components/description_list/description_list_description.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDescriptionListDescriptionStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDescriptionList__description: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    inline: import("@emotion/react").SerializedStyles;
	    fontStyles: {
	        normal: import("@emotion/react").SerializedStyles;
	        reverse: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    inlineStyles: {
	        compressed: import("@emotion/react").SerializedStyles;
	        normal: import("@emotion/react").SerializedStyles;
	    };
	    left: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/description_list/description_list_description' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiDescriptionListDescriptionProps extends CommonProps, HTMLAttributes<HTMLElement> {
	}
	export const EuiDescriptionListDescription: FunctionComponent<EuiDescriptionListDescriptionProps>;

}
declare module '@elastic/eui/src/components/description_list/description_list.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDescriptionListStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDescriptionList: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	    inline: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    columnGap: {
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	    rowGap: {
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	    center: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/description_list/description_list' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiDescriptionListProps } from '@elastic/eui/src/components/description_list/description_list_types';
	export const EuiDescriptionList: FunctionComponent<CommonProps & HTMLAttributes<HTMLDListElement> & EuiDescriptionListProps>;

}
declare module '@elastic/eui/src/components/description_list' {
	export type { EuiDescriptionListProps } from '@elastic/eui/src/components/description_list/description_list_types';
	export { EuiDescriptionList } from '@elastic/eui/src/components/description_list/description_list';
	export { EuiDescriptionListTitle } from '@elastic/eui/src/components/description_list/description_list_title';
	export { EuiDescriptionListDescription } from '@elastic/eui/src/components/description_list/description_list_description';

}
declare module '@elastic/eui/src/components/datagrid/controls/keyboard_shortcuts.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridKeyboardShortcutsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDataGrid__keyboardShortcuts: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/keyboard_shortcuts' {
	import { ReactNode } from 'react';
	export const useDataGridKeyboardShortcuts: () => {
	    keyboardShortcuts: ReactNode;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/fullscreen_selector.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridFullScreenStyles: (euiThemeContext: UseEuiTheme) => {
	    'euiDataGrid--fullScreen': string;
	    euiDataGrid__restrictBody: string;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls/fullscreen_selector' {
	import { ReactNode, KeyboardEventHandler } from 'react';
	export const useDataGridFullScreenSelector: (onFullScreenChange?: (isFullScreen: boolean) => void) => {
	    isFullScreen: boolean;
	    setIsFullScreen: (isFullScreen: boolean) => void;
	    fullScreenSelector: ReactNode;
	    handleGridKeyDown: KeyboardEventHandler<HTMLDivElement>;
	    fullScreenStyles: string;
	};

}
declare module '@elastic/eui/src/components/datagrid/controls' {
	export { useDataGridColumnSelector } from '@elastic/eui/src/components/datagrid/controls/column_selector';
	export { useDataGridColumnSorting } from '@elastic/eui/src/components/datagrid/controls/column_sorting';
	export { useDataGridDisplaySelector, startingStyles } from '@elastic/eui/src/components/datagrid/controls/display_selector';
	export { useDataGridKeyboardShortcuts } from '@elastic/eui/src/components/datagrid/controls/keyboard_shortcuts';
	export { useDataGridFullScreenSelector } from '@elastic/eui/src/components/datagrid/controls/fullscreen_selector';
	export { checkOrDefaultToolBarDisplayOptions, EuiDataGridToolbar, } from '@elastic/eui/src/components/datagrid/controls/data_grid_toolbar';
	export { EuiDataGridToolbarControl, type EuiDataGridToolbarControlProps, } from '@elastic/eui/src/components/datagrid/controls/data_grid_toolbar_control';

}
declare module '@elastic/eui/src/components/datagrid/pagination/data_grid_pagination.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDataGridPaginationStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiDataGrid__pagination: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/datagrid/pagination/data_grid_pagination' {
	import React, { AriaAttributes } from 'react';
	import { EuiDataGridPaginationProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	type _EuiDataGridPaginationProps = Required<EuiDataGridPaginationProps> & {
	    rowCount: number;
	    controls: string;
	    'aria-label'?: AriaAttributes['aria-label'];
	};
	/**
	 * Do not render the pagination when:
	 * 1. Rows count is less than min pagination option (rows per page)
	 * 2. Rows count is less than pageSize (the case when there are no pageSizeOptions provided)
	 */
	export const shouldRenderPagination: (rowCount: number, { pageSize, pageSizeOptions }: Required<EuiDataGridPaginationProps>) => boolean;
	export const EuiDataGridPagination: ({ pageIndex, pageSize, pageSizeOptions, onChangePage: _onChangePage, onChangeItemsPerPage, rowCount, controls, "aria-label": ariaLabel, }: _EuiDataGridPaginationProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/datagrid/pagination' {
	export { shouldRenderPagination, EuiDataGridPagination, } from '@elastic/eui/src/components/datagrid/pagination/data_grid_pagination';

}
declare module '@elastic/eui/src/components/datagrid/utils/in_memory' {
	import { FunctionComponent } from 'react';
	import { EuiDataGridInMemory, EuiDataGridInMemoryValues, EuiDataGridInMemoryRendererProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	/**
	 * inMemory values hook
	 */
	export const useInMemoryValues: (inMemory: EuiDataGridInMemory | undefined, rowCount: number) => [EuiDataGridInMemoryValues, EuiDataGridInMemoryRendererProps["onCellRender"]];
	/**
	 * InMemory renderer
	 */
	export const EuiDataGridInMemoryRenderer: FunctionComponent<EuiDataGridInMemoryRendererProps>;

}
declare module '@elastic/eui/src/components/datagrid/utils/row_count' {
	import { EuiDataGridProps, EuiDataGridVisibleRows } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const computeVisibleRows: ({ pagination, rowCount, }: {
	    pagination: Required<EuiDataGridProps["pagination"]>;
	    rowCount: EuiDataGridProps["rowCount"];
	}) => EuiDataGridVisibleRows;

}
declare module '@elastic/eui/src/components/datagrid/utils/ref' {
	import { Ref, RefObject } from 'react';
	import type { VariableSizeGrid } from 'react-window';
	import { EuiDataGridRefProps, EuiDataGridProps, DataGridFocusContextShape, DataGridCellPopoverContextShape, DataGridSortedContextShape } from '@elastic/eui/src/components/datagrid/data_grid_types';
	interface Dependencies {
	    ref: Ref<unknown>;
	    gridRef: RefObject<VariableSizeGrid>;
	    setIsFullScreen: EuiDataGridRefProps['setIsFullScreen'];
	    focusContext: DataGridFocusContextShape;
	    cellPopoverContext: DataGridCellPopoverContextShape;
	    sortedContext: DataGridSortedContextShape;
	    pagination: Required<EuiDataGridProps['pagination']>;
	    rowCount: number;
	    visibleColCount: number;
	}
	export const useImperativeGridRef: ({ ref, gridRef, setIsFullScreen, focusContext, cellPopoverContext, sortedContext: { sortedRowMap }, pagination, rowCount, visibleColCount, }: Dependencies) => void;
	/**
	 * Throw a digestible error if the consumer attempts to focus into an invalid
	 * cell range, which should also stop the APIs from continuing
	 */
	export const useCellLocationCheck: (rowCount: number, colCount: number) => {
	    checkCellExists: ({ rowIndex, colIndex }: {
	        rowIndex: number;
	        colIndex: number;
	    }) => void;
	};
	/**
	 * The rowIndex passed from the consumer is the unsorted and unpaginated
	 * index derived from their original data. We need to convert that rowIndex
	 * into a visibleRowIndex (which is what our internal cell APIs use) and, if
	 * the row is not on the current page, the grid should automatically handle
	 * paginating to that row.
	 */
	export const useSortPageCheck: (pagination: Required<EuiDataGridProps["pagination"]>, sortedRowMap: DataGridSortedContextShape["sortedRowMap"]) => {
	    findVisibleRowIndex: (rowIndex: number) => number;
	};
	export {};

}
declare module '@elastic/eui/src/components/datagrid/data_grid' {
	import React from 'react';
	import { EuiDataGridProps, EuiDataGridRefProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const EuiDataGrid: React.MemoExoticComponent<React.ForwardRefExoticComponent<EuiDataGridProps & React.RefAttributes<EuiDataGridRefProps>>>;

}
declare module '@elastic/eui/src/components/datagrid' {
	export { EuiDataGrid } from '@elastic/eui/src/components/datagrid/data_grid';
	export { useDataGridColumnSelector, useDataGridColumnSorting, useDataGridDisplaySelector, EuiDataGridToolbarControl, } from '@elastic/eui/src/components/datagrid/controls';
	export * from '@elastic/eui/src/components/datagrid/data_grid_types';

}
declare module '@elastic/eui/src/components/date_picker/react-datepicker/src' {
	/*
	 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
	 * or more contributor license agreements. Licensed under the Elastic License
	 * 2.0 and the Server Side Public License, v 1; you may not use this file except
	 * in compliance with, at your election, the Elastic License 2.0 or the Server
	 * Side Public License, v 1.
	 */

	// Type definitions for react-datepicker 1.8
	// Project: https://github.com/Hacker0x01/react-datepicker
	// Definitions by: Rajab Shakirov <https://github.com/radziksh>,
	//                 Andrey Balokha <https://github.com/andrewBalekha>,
	//                 Greg Smith <https://github.com/smrq>,
	//                 Platon Pronko <https://github.com/Rogach>
	//                 Roy Xue <https://github.com/royxue>
	//                 Koala Human <https://github.com/KoalaHuman>
	//                 Sean Kelley <https://github.com/seansfkelley>
	//                 Justin Grant <https://github.com/justingrant>
	// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
	// TypeScript Version: 2.8

	import * as React from 'react';
	import * as moment from 'moment';

	import type { EuiPopoverProps, PopoverAnchorPosition } from '@elastic/eui/src/components/popover';
	import type { EuiFieldTextProps } from '@elastic/eui/src/components/form/field_text';

	export interface ReactDatePickerProps {
	  /**
	   * Whether changes to Year and Month (via dropdowns) should trigger `onChange`
	   */
	  adjustDateOnChange?: boolean;
	  accessibleMode?: boolean;
	  allowSameDay?: boolean;
	  autoComplete?: string;
	  autoFocus?: boolean;

	  /**
	   * Optional class added to the calendar portion of datepicker
	   */
	  calendarClassName?: string;
	  children?: React.ReactNode;

	  /**
	   * Added to the actual input of the calendar
	   */
	  className?: string;
	  defaultInputProps?: Partial<EuiFieldTextProps>;

	  /**
	   * Replaces the input with any node, like a button
	   */
	  customInput?: React.ReactNode;
	  customInputRef?: string;

	  /**
	   * Accepts any moment format string
	   */
	  dateFormat?: string | string[];
	  dateFormatCalendar?: string;
	  dayClassName?(date: moment.Moment): string | null;
	  disabled?: boolean;
	  disabledKeyboardNavigation?: boolean;
	  dropdownMode?: 'scroll' | 'select';
	  endDate?: moment.Moment | null;
	  excludeDates?: moment.Moment[];
	  excludeTimes?: moment.Moment[];
	  filterDate?(date: moment.Moment): boolean;
	  fixedHeight?: boolean;
	  forceShowMonthNavigation?: boolean;
	  formatWeekNumber?(date: moment.Moment): string | number;
	  highlightDates?: moment.Moment[];
	  id?: string;
	  includeDates?: moment.Moment[];
	  includeTimes?: moment.Moment[];
	  inline?: boolean;

	  /**
	   * Adds additional times to the time selector other then :30 increments
	   */
	  injectTimes?: moment.Moment[];
	  isClearable?: boolean;

	  /**
	   * Switches the locale / display. "en-us", "zn-ch"...etc
	   */
	  locale?: moment.LocaleSpecifier;

	  /**
	   * The max date accepted (in moment format) as a selection
	   */
	  maxDate?: moment.Moment;

	  /**
	   * The max time accepted (in moment format) as a selection
	   */
	  maxTime?: moment.Moment;

	  /**
	   * The min date accepted (in moment format) as a selection
	   */
	  minDate?: moment.Moment;

	  /**
	   * The min time accepted (in moment format) as a selection
	   */
	  minTime?: moment.Moment;
	  monthsShown?: number;
	  name?: string;
	  onBlur?(event: React.FocusEvent<HTMLInputElement>): void;

	  /**
	   * What to do when the input changes
	   */
	  onChange?(
	    date: moment.Moment | null,
	    event?: React.SyntheticEvent<any>
	  ): void;
	  onChangeRaw?(event: React.FocusEvent<HTMLInputElement>): void;
	  onClickOutside?(event: React.MouseEvent<HTMLDivElement>): void;
	  onFocus?(event: React.FocusEvent<HTMLInputElement>): void;
	  onKeyDown?(event: React.KeyboardEvent<HTMLDivElement>): void;
	  onMonthChange?(date: moment.Moment): void;
	  onSelect?(date: moment.Moment, event?: React.SyntheticEvent<any>): void;
	  onWeekSelect?(
	    firstDayOfWeek: moment.Moment,
	    weekNumber: string | number,
	    event?: React.SyntheticEvent<any>
	  ): void;
	  onYearChange?(date: moment.Moment): void;
	  openToDate?: moment.Moment;
	  peekNextMonth?: boolean;
	  placeholderText?: string;

	  /**
	   * Class applied to the popup, when inline is false
	   */
	  popperClassName?: string;
	  popperContainer?(props: { children: React.ReactNode[] }): React.ReactNode;
	  popperPlacement?: PopoverAnchorPosition;
	  popperProps?: Partial<EuiPopoverProps>;
	  preventOpenOnFocus?: boolean;
	  readOnly?: boolean;
	  required?: boolean;
	  scrollableMonthYearDropdown?: boolean;
	  scrollableYearDropdown?: boolean;

	  /**
	   * The selected datetime (in moment format)
	   */
	  selected?: moment.Moment | null;
	  selectsEnd?: boolean;
	  selectsStart?: boolean;

	  /**
	   * Will close the popup on selection
	   */
	  shouldCloseOnSelect?: boolean;
	  showDisabledMonthNavigation?: boolean;
	  showMonthDropdown?: boolean;
	  showMonthYearDropdown?: boolean;

	  /**
	   * Show the time selection alongside the calendar
	   */
	  showTimeSelect?: boolean;

	  /**
	   * Only show the time selector, not the calendar
	   */
	  showTimeSelectOnly?: boolean;
	  showWeekNumbers?: boolean;
	  showYearDropdown?: boolean;
	  startDate?: moment.Moment | null;
	  startOpen?: boolean;

	  /**
	   * Use Moment strict mode, allowing exact format matches only
	   */
	  strictParsing?: boolean;
	  tabIndex?: number;
	  timeCaption?: string;

	  /**
	   * The format of the time within the selector, in moment notation
	   */
	  timeFormat?: string;
	  timeIntervals?: number;
	  title?: string;
	  todayButton?: string;
	  useShortMonthInDropdown?: boolean;
	  useWeekdaysShort?: boolean;
	  utcOffset?: number;
	  value?: string;
	  weekLabel?: string;
	  withPortal?: boolean;
	  
	  /**
	   * The total number of years to show as options in years selection dropdown
	   */
	  yearDropdownItemNumber?: number;
	} const ReactDatePicker: React.ClassicComponentClass<ReactDatePickerProps>;
	export default ReactDatePicker;

}
declare module '@elastic/eui/src/components/date_picker/react-datepicker' {
	import ReactDatePicker from '@elastic/eui/src/components/date_picker/react-datepicker/src';
	export { ReactDatePicker };
	export type { ReactDatePickerProps } from '@elastic/eui/src/components/date_picker/react-datepicker/src';

}
declare module '@elastic/eui/src/components/date_picker/react_date_picker.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDatePickerVariables: (euiThemeContext: UseEuiTheme) => {
	    gapSize: string;
	    readonly paddingSize: string;
	    headerButtonSize: string;
	    readonly headerOffset: string;
	    colors: {
	        day: {
	            inMonth: string;
	            outsideMonth: string;
	            header: string;
	            today: string;
	        };
	        hover: {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        } & {
	            border: undefined;
	        };
	        disabled: {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        } & {
	            border: undefined;
	        };
	        readonly inRange: {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        } & {
	            border: undefined;
	        };
	        inRangeAndDisabled: {
	            backgroundColor: string;
	        };
	        selected: {
	            border: string;
	            color: string;
	            backgroundColor: string;
	        } | {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        } | {
	            color: string;
	            backgroundColor: string;
	            forcedColorAdjust: string;
	        };
	        selectedAndDisabled: {
	            border: string;
	            color: string;
	            backgroundColor: string;
	        } | {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        };
	        highlighted: {
	            border: string;
	            color: string;
	            backgroundColor: string;
	        } | {
	            border?: undefined;
	            color: string;
	            backgroundColor: string;
	        };
	    };
	    animationSpeed: import("csstype").Property.AnimationDuration<string & {}> | undefined;
	};
	export const euiReactDatePickerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiReactDatePicker: string;
	};

}
declare module '@elastic/eui/src/components/date_picker/date_picker.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDatePickerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDatePicker: import("@emotion/react").SerializedStyles;
	    inline: {
	        inline: import("@emotion/react").SerializedStyles;
	        noShadow: string;
	        shadow: import("@emotion/react").SerializedStyles;
	        invalid: import("@emotion/react").SerializedStyles;
	        disabled: import("@emotion/react").SerializedStyles;
	        readOnly: import("@emotion/react").SerializedStyles;
	    };
	    inGroup: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/date_picker' {
	import { FunctionComponent, Component, MouseEventHandler, Ref } from 'react';
	import type { Moment } from 'moment';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { PopoverAnchorPosition } from '@elastic/eui/src/components/popover';
	import { EuiFormControlLayoutProps } from '@elastic/eui/src/components/form';
	import { EuiFormControlLayoutIconsProps } from '@elastic/eui/src/components/form/form_control_layout/form_control_layout_icons';
	import { ReactDatePickerProps } from '@elastic/eui/src/components/date_picker/react-datepicker';
	export const euiDatePickerDefaultDateFormat = "MM/DD/YYYY";
	export const euiDatePickerDefaultTimeFormat = "hh:mm A"; const unsupportedProps: readonly ["monthsShown", "showWeekNumbers", "fixedHeight", "dropdownMode", "useShortMonthInDropdown", "todayButton", "timeCaption", "disabledKeyboardNavigation", "isClearable", "withPortal", "showMonthYearDropdown", "popperPlacement", "defaultInputProps"];
	type UnsupportedProps = (typeof unsupportedProps)[number];
	interface EuiExtendedDatePickerProps extends Omit<ReactDatePickerProps, UnsupportedProps> {
	    /**
	     * Applies classes to the numbered days provided. Check docs for example.
	     */
	    dayClassName?: (date: Moment) => string | null;
	    /**
	     * Renders the input as full width
	     */
	    fullWidth?: boolean;
	    /**
	     * Renders the input with compressed height and sizing
	     */
	    compressed?: boolean;
	    /**
	     * ref for the ReactDatePicker instance
	     */
	    inputRef?: Ref<Component<ReactDatePickerProps, any, any>>;
	    /**
	     * Provides styling to the input when invalid
	     */
	    isInvalid?: boolean;
	    /**
	     * Provides styling to the input when loading
	     */
	    isLoading?: boolean;
	    /**
	     * What to do when the input is cleared by the x icon
	     */
	    onClear?: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Opens to this date (in moment format) on first press, regardless of selection
	     */
	    openToDate?: Moment;
	    /**
	     * Shows only when no date is selected
	     */
	    placeholder?: string;
	    /**
	     * Displays the date picker calendar on directly on the page.
	     * Will not render `iconType` or `fullWidth`.
	     */
	    inline?: boolean;
	    /**
	     * Allows turning the shadow off if using the `inline` prop
	     */
	    shadow?: boolean;
	    /**
	     * Show the icon in input
	     */
	    showIcon?: boolean;
	    /**
	     * Pass an icon type to change the default `calendar` or `clock` icon
	     */
	    iconType?: EuiFormControlLayoutIconsProps['icon'];
	    /**
	     * Sets the placement of the popover.
	     *
	     * **Use [EuiPopover](/#/layout/popover) values**: 'upCenter', 'upLeft', 'upRight', downCenter', 'downLeft', 'downRight', 'leftCenter', 'leftUp', 'leftDown', 'rightCenter', 'rightUp', 'rightDown'.
	     */
	    popoverPlacement?: PopoverAnchorPosition;
	    /**
	     * Creates an input group with element(s) coming before the input.
	     * `string` | `ReactElement` or an array of these
	     *
	     * Ignored if `inline` or `controlOnly` are true.
	     */
	    append?: EuiFormControlLayoutProps['append'];
	    /**
	     * Creates an input group with element(s) coming before the input.
	     * `string` | `ReactElement` or an array of these
	     *
	     * Ignored if `inline` or `controlOnly` are true.
	     */
	    prepend?: EuiFormControlLayoutProps['prepend'];
	    /**
	     * Completely removes form control layout wrapper and ignores
	     * `iconType`, `prepend`, and `append`.
	     *
	     * Best used inside EuiFormControlLayoutDelimited.
	     */
	    controlOnly?: boolean;
	}
	export type EuiDatePickerProps = CommonProps & EuiExtendedDatePickerProps;
	export const EuiDatePicker: FunctionComponent<EuiDatePickerProps>;
	export {};

}
declare module '@elastic/eui/src/components/tabs/tab.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTabStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTab: import("@emotion/react").SerializedStyles;
	    expanded: import("@emotion/react").SerializedStyles;
	    selected: import("@emotion/react").SerializedStyles;
	    disabled: {
	        disabled: import("@emotion/react").SerializedStyles;
	        selected: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiTabContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTab__content: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tabs/tabs.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTabsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTabs: import("@emotion/react").SerializedStyles;
	    bottomBorder: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tabs/tabs' {
	import React, { HTMLAttributes, PropsWithChildren, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["s", "m", "l"];
	export type EuiTabsSizes = (typeof SIZES)[number];
	export type EuiTabsProps = HTMLAttributes<HTMLDivElement> & PropsWithChildren & CommonProps & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Evenly stretches each tab to fill the
	     * horizontal space
	     */
	    expand?: boolean;
	    /**
	     * Adds a bottom border to separate it from the content after
	     */
	    bottomBorder?: boolean;
	    /**
	     * Sizes affect both font size and overall size.
	     */
	    size?: EuiTabsSizes;
	};
	export type EuiTabRef = HTMLDivElement;
	export const EuiTabs: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
	    children?: ReactNode | undefined;
	} & CommonProps & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    /**
	     * Evenly stretches each tab to fill the
	     * horizontal space
	     */
	    expand?: boolean;
	    /**
	     * Adds a bottom border to separate it from the content after
	     */
	    bottomBorder?: boolean;
	    /**
	     * Sizes affect both font size and overall size.
	     */
	    size?: EuiTabsSizes;
	} & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/tabs/tabs_context' {
	import { EuiTabsProps } from '@elastic/eui/src/components/tabs/tabs';
	export type EuiTabsContextValues = Required<Pick<EuiTabsProps, 'expand' | 'size'>>;
	export const contextDefaults: EuiTabsContextValues;
	export const EuiTabsContext: import("react").Context<Required<Pick<EuiTabsProps, "size" | "expand">>>;

}
declare module '@elastic/eui/src/components/tabs/tab' {
	import { MouseEventHandler, AnchorHTMLAttributes, ButtonHTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export interface EuiTabProps extends CommonProps {
	    isSelected?: boolean;
	    disabled?: boolean;
	    /**
	     * Places content before the tab content/children.
	     * Will be excluded from interactive effects.
	     */
	    prepend?: ReactNode;
	    /**
	     * Places content after the tab content/children.
	     * Will be excluded from interactive effects.
	     */
	    append?: ReactNode;
	}
	type EuiTabPropsForAnchor = EuiTabProps & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'onClick' | 'href'> & {
	    href?: string;
	    onClick?: MouseEventHandler<HTMLAnchorElement>;
	};
	type EuiTabPropsForButton = EuiTabProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'> & {
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	};
	export type Props = ExclusiveUnion<EuiTabPropsForAnchor, EuiTabPropsForButton>;
	export const EuiTab: FunctionComponent<Props>;
	export {};

}
declare module '@elastic/eui/src/components/tabs/tabbed_content/tabbed_content' {
	import React, { Component, HTMLAttributes, ReactNode, FocusEvent } from 'react';
	import { EuiTabsSizes } from '@elastic/eui/src/components/tabs/tabs';
	import { EuiTabProps } from '@elastic/eui/src/components/tabs/tab';
	import { CommonProps } from '@elastic/eui/src/components/common';
	/**
	 * Marked as const so type is `['initial', 'selected']` instead of `string[]`
	 */
	export const AUTOFOCUS: readonly ["initial", "selected"];
	export interface EuiTabbedContentTab extends EuiTabProps {
	    id: string;
	    name: ReactNode;
	    content: ReactNode;
	}
	interface EuiTabbedContentState {
	    selectedTabId: string | undefined;
	    inFocus: boolean;
	}
	export type EuiTabbedContentProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'autoFocus'> & {
	    /**
	     * When tabbing into the tabs, set the focus on `initial` for the first tab,
	     * or `selected` for the currently selected tab. Best use case is for inside of
	     * overlay content like popovers or flyouts.
	     */
	    autoFocus?: 'initial' | 'selected';
	    /**
	     * Evenly stretches each tab to fill the horizontal space
	     */
	    expand?: boolean;
	    /**
	     * Use this prop to set the initially selected tab while letting the tabbed content component
	     * control selection state internally
	     */
	    initialSelectedTab?: EuiTabbedContentTab;
	    onTabClick?: (selectedTab: EuiTabbedContentTab) => void;
	    /**
	     * Use this prop if you want to control selection state within the owner component
	     */
	    selectedTab?: EuiTabbedContentTab;
	    size?: EuiTabsSizes;
	    /**
	     * Each tab needs id and content properties, so we can associate it with its panel for accessibility.
	     * The name property (a node) is also required to display to the user.
	     */
	    tabs: EuiTabbedContentTab[];
	};
	export class EuiTabbedContent extends Component<EuiTabbedContentProps, EuiTabbedContentState> {
	    static defaultProps: {
	        autoFocus: EuiTabbedContentProps['autoFocus'];
	    };
	    private readonly rootId;
	    private readonly tabsRef;
	    constructor(props: EuiTabbedContentProps);
	    focusTab: () => void;
	    initializeFocus: () => void;
	    removeFocus: (blurEvent: FocusEvent<HTMLDivElement>) => void;
	    onTabClick: (selectedTab: EuiTabbedContentTab) => void;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/tabs/tabbed_content' {
	export type { EuiTabbedContentTab, EuiTabbedContentProps, } from '@elastic/eui/src/components/tabs/tabbed_content/tabbed_content';
	export { EuiTabbedContent } from '@elastic/eui/src/components/tabs/tabbed_content/tabbed_content';

}
declare module '@elastic/eui/src/components/tabs' {
	export type { EuiTabProps } from '@elastic/eui/src/components/tabs/tab';
	export { EuiTab } from '@elastic/eui/src/components/tabs/tab';
	export type { EuiTabsProps } from '@elastic/eui/src/components/tabs/tabs';
	export { EuiTabs } from '@elastic/eui/src/components/tabs/tabs';
	export type { EuiTabbedContentTab, EuiTabbedContentProps, } from '@elastic/eui/src/components/tabs/tabbed_content';
	export { EuiTabbedContent } from '@elastic/eui/src/components/tabs/tabbed_content';

}
declare module '@elastic/eui/src/components/date_picker/types' {
	import { ReactElement } from 'react';
	export interface DurationRange {
	    end: ShortDate;
	    label?: string;
	    start: ShortDate;
	}
	export type TimeUnitId = 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
	export type TimeUnitFromNowId = 's+' | 'm+' | 'h+' | 'd+' | 'w+' | 'M+' | 'y+';
	export type TimeUnitAllId = TimeUnitId | TimeUnitFromNowId;
	export type TimeUnitLabel = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
	export type TimeUnitLabelPlural = 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
	export type AbsoluteDateMode = 'absolute';
	export type RelativeDateMode = 'relative';
	export type NowDateMode = 'now';
	export type DateMode = AbsoluteDateMode | RelativeDateMode | NowDateMode;
	/**
	 * String as either datemath (e.g.: now, now-15m, now-15m/m) or
	 * absolute date in the format 'YYYY-MM-DDTHH:mm:ss.SSSZ'
	 */
	export type ShortDate = NowDateMode | string;
	export type Milliseconds = number;
	export interface RelativeParts {
	    count: number;
	    round: boolean;
	    roundUnit?: TimeUnitId;
	    unit: string;
	}
	export interface RelativeOption {
	    text: string;
	    value: TimeUnitAllId;
	}
	export const REFRESH_UNIT_OPTIONS: readonly ["s", "m", "h"];
	export type RefreshUnitsOptions = (typeof REFRESH_UNIT_OPTIONS)[number];
	export type OnRefreshChangeProps = {
	    isPaused: boolean;
	    refreshInterval: number;
	    intervalUnits: RefreshUnitsOptions;
	};
	export type ApplyRefreshInterval = (args: OnRefreshChangeProps) => void;
	export interface QuickSelect {
	    timeTense: string;
	    timeValue: number;
	    timeUnits: TimeUnitId;
	}
	interface ApplyTimeArgs extends DurationRange {
	    keepPopoverOpen?: boolean;
	    quickSelect?: QuickSelect;
	}
	export type ApplyTime = (args: ApplyTimeArgs) => void;
	export interface QuickSelectPanel {
	    title: string;
	    content: ReactElement;
	}
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/time_options' {
	import { EuiSelectOption } from '@elastic/eui/src/components/form';
	import { TimeUnitId, RelativeOption, DurationRange } from '@elastic/eui/src/components/date_picker/types';
	export const LAST = "last";
	export const NEXT = "next";
	export type TimeOptions = {
	    timeTenseOptions: EuiSelectOption[];
	    timeUnitsOptions: EuiSelectOption[];
	    relativeOptions: RelativeOption[];
	    relativeRoundingLabels: {
	        [id in TimeUnitId]: string;
	    };
	    refreshUnitsOptions: EuiSelectOption[];
	    commonDurationRanges: DurationRange[];
	};
	/**
	 * i18n'd time options, mostly used in EuiSelects (except for a few cases)
	 * used in EuiSuperDatePicker child sub-components
	 */
	export const useI18nTimeOptions: () => TimeOptions;
	export const RenderI18nTimeOptions: (props: {
	    children: (args: TimeOptions) => any;
	}) => any;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/relative_utils' {
	import { TimeUnitId, RelativeParts, ShortDate } from '@elastic/eui/src/components/date_picker/types';
	export const relativeUnitsFromLargestToSmallest: TimeUnitId[];
	export function parseRelativeParts(value: string): RelativeParts;
	export const toRelativeStringFromParts: (relativeParts: RelativeParts) => string;
	export const isRelativeToNow: (timeFrom: ShortDate, timeTo: ShortDate) => boolean;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_modes' {
	import { AbsoluteDateMode, RelativeDateMode, NowDateMode, ShortDate } from '@elastic/eui/src/components/date_picker/types';
	export const DATE_MODES: {
	    ABSOLUTE: AbsoluteDateMode;
	    RELATIVE: RelativeDateMode;
	    NOW: NowDateMode;
	};
	export const INVALID_DATE = "invalid_date";
	export function getDateMode(value: ShortDate): "absolute" | "relative" | "now";
	export function toAbsoluteString(value: string, roundUp?: boolean): string;
	export function toRelativeString(value: string): string;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTimeZoneDisplayStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTimeZoneDisplay: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display' {
	import React, { type ReactNode, type ComponentPropsWithoutRef } from 'react';
	import { Moment } from 'moment';
	/**
	 * Available elements to render passed to the
	 * `customRender` render function.
	 */
	type TimeZoneCustomDisplayRenderOptions = {
	    /** Name with UTC offset and an icon */
	    nameDisplay?: ReactNode;
	    /** UTC offset in hours, in plain text e.g. UTC+1 */
	    utcOffset?: string;
	    /** Time zone name e.g. Europe/Brussels */
	    timeZoneName?: string;
	};
	export type EuiTimeZoneDisplayProps = ComponentPropsWithoutRef<'div'> & {
	    /**
	     * A valid time zone name, from the IANA database, e.g. "America/Los_Angeles".
	     *
	     * @link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
	     */
	    timeZone?: string;
	    /**
	     * Render prop function to add additional content to the time zone display.
	     * Useful for e.g. adding links to documentation or setting pages.
	     */
	    customRender?: (options: TimeZoneCustomDisplayRenderOptions) => ReactNode;
	    /**
	     * Reference date to be used while resolving the UTC offset.
	     * Only useful for edge cases involving daylight saving time.
	     */
	    date?: Moment;
	};
	/**
	 * Display time zone information.
	 */
	export const EuiTimeZoneDisplay: React.FC<EuiTimeZoneDisplayProps>;
	/**
	 * Get the UTC offset display in hours e.g. "UTC+2" from time zone name.
	 *
	 * @param timeZoneName IANA time zone name
	 * @param [date] Reference date to get offset with Intl.DateTimeFormat
	 */
	export function useEuiUTCOffsetDisplay(timeZoneName: string, date?: Date): {
	    utc: string;
	    name: string;
	    isInvalid: boolean;
	};
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/relative_tab' {
	import { FunctionComponent } from 'react';
	import { LocaleSpecifier } from 'moment';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	import { EuiDatePopoverContentProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	import { type EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';
	export interface EuiRelativeTabProps {
	    dateFormat: string;
	    locale?: LocaleSpecifier;
	    value: string;
	    onChange: EuiDatePopoverContentProps['onChange'];
	    roundUp?: boolean;
	    labelPrefix: string;
	    timeOptions: TimeOptions;
	    timeZoneDisplayProps?: EuiTimeZoneDisplayProps;
	}
	export const EuiRelativeTab: FunctionComponent<EuiRelativeTabProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDatePopoverContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDatePopoverContent: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content' {
	import { FunctionComponent } from 'react';
	import { LocaleSpecifier, Moment } from 'moment';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	import { type EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';
	export interface EuiDatePopoverContentProps {
	    value: string;
	    onChange: (date: string) => void;
	    canRoundRelativeUnits?: boolean;
	    roundUp?: boolean;
	    dateFormat: string;
	    timeFormat: string;
	    locale?: LocaleSpecifier;
	    position: 'start' | 'end';
	    utcOffset?: number;
	    minDate?: Moment;
	    maxDate?: Moment;
	    timeOptions: TimeOptions;
	    timeZoneDisplayProps?: EuiTimeZoneDisplayProps;
	}
	export const EuiDatePopoverContent: FunctionComponent<EuiDatePopoverContentProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/absolute_tab.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiAbsoluteTabDateFormStyles: (euiThemeContext: UseEuiTheme) => {
	    euiAbsoluteTabDateForm: import("@emotion/react").SerializedStyles;
	    euiAbsoluteTabDateForm__submit: import("@emotion/react").SerializedStyles;
	    euiAbsoluteTabDateForm__row: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/absolute_tab' {
	import { FunctionComponent } from 'react';
	import { Moment, LocaleSpecifier } from 'moment';
	import { EuiDatePopoverContentProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	import { type EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';
	export interface EuiAbsoluteTabProps {
	    dateFormat: string;
	    timeFormat: string;
	    locale?: LocaleSpecifier;
	    value: string;
	    onChange: EuiDatePopoverContentProps['onChange'];
	    roundUp: boolean;
	    labelPrefix: string;
	    utcOffset?: number;
	    minDate?: Moment;
	    maxDate?: Moment;
	    timeZoneDisplayProps?: EuiTimeZoneDisplayProps;
	}
	export const EuiAbsoluteTab: FunctionComponent<EuiAbsoluteTabProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/pretty_duration' {
	import React from 'react';
	import { LocaleSpecifier } from 'moment';
	import { DurationRange, ShortDate } from '@elastic/eui/src/components/date_picker/types';
	export const useFormatTimeString: (timeString: string, dateFormat: string, options?: {
	    locale?: LocaleSpecifier;
	    roundUp?: boolean;
	    canRoundRelativeUnits?: boolean;
	}) => string;
	/**
	 * Pretty duration hook+component
	 */
	interface PrettyDurationProps {
	    timeFrom: ShortDate;
	    timeTo: ShortDate;
	    quickRanges?: DurationRange[];
	    dateFormat: string;
	}
	export const usePrettyDuration: ({ timeFrom, timeTo, quickRanges, dateFormat, }: PrettyDurationProps) => string;
	export const PrettyDuration: React.FC<PrettyDurationProps>;
	export const showPrettyDuration: (timeFrom: ShortDate, timeTo: ShortDate, quickRanges: DurationRange[]) => boolean;
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDatePopoverButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDatePopoverButton: import("@emotion/react").SerializedStyles;
	    now: import("@emotion/react").SerializedStyles;
	    tooltipAnchor: import("@emotion/react").SerializedStyles;
	};
	export const _buttonStyles: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_button' {
	import { FunctionComponent, ButtonHTMLAttributes, MouseEventHandler } from 'react';
	import { LocaleSpecifier, Moment } from 'moment';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	import { EuiDatePopoverContentProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	import { type EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';
	export interface EuiDatePopoverButtonProps {
	    className?: string;
	    buttonProps?: CommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
	    dateFormat: string;
	    isDisabled?: boolean;
	    isInvalid?: boolean;
	    isOpen: boolean;
	    needsUpdating?: boolean;
	    locale?: LocaleSpecifier;
	    onChange: EuiDatePopoverContentProps['onChange'];
	    onPopoverClose: EuiPopoverProps['closePopover'];
	    onPopoverToggle: MouseEventHandler<HTMLButtonElement>;
	    position: 'start' | 'end';
	    canRoundRelativeUnits?: boolean;
	    roundUp?: boolean;
	    timeFormat: string;
	    value: string;
	    utcOffset?: number;
	    minDate?: Moment;
	    maxDate?: Moment;
	    compressed?: boolean;
	    timeOptions: TimeOptions;
	    timeZoneDisplayProps?: EuiTimeZoneDisplayProps;
	}
	export const EuiDatePopoverButton: FunctionComponent<EuiDatePopoverButtonProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/date_popover' {
	export type { EuiAbsoluteTabProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/absolute_tab';
	export { EuiAbsoluteTab } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/absolute_tab';
	export type { EuiDatePopoverButtonProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_button';
	export { EuiDatePopoverButton } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_button';
	export type { EuiDatePopoverContentProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	export { EuiDatePopoverContent } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	export type { EuiRelativeTabProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/relative_tab';
	export { EuiRelativeTab } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/relative_tab';
	export type { EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_panel.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiQuickSelectPanelStyles: (euiThemeContext: UseEuiTheme) => {
	    euiQuickSelectPanel: import("@emotion/react").SerializedStyles;
	    euiQuickSelectPanel__title: import("@emotion/react").SerializedStyles;
	    euiQuickSelectPanel__section: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_panel' {
	import { FunctionComponent, ReactNode } from 'react';
	import type { CommonProps } from '@elastic/eui/src/components/common';
	type EuiQuickSelectPanelProps = CommonProps & {
	    component?: 'div' | 'fieldset';
	    title?: ReactNode;
	    titleId?: string;
	    children?: ReactNode;
	};
	export const EuiQuickSelectPanel: FunctionComponent<EuiQuickSelectPanelProps>;
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/commonly_used_time_ranges' {
	import { FunctionComponent } from 'react';
	import { DurationRange, ApplyTime } from '@elastic/eui/src/components/date_picker/types';
	export interface EuiCommonlyUsedTimeRangesProps {
	    applyTime: ApplyTime;
	    commonlyUsedRanges: DurationRange[];
	}
	export const EuiCommonlyUsedTimeRanges: FunctionComponent<EuiCommonlyUsedTimeRangesProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_popover.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiQuickSelectPopoverStyles: (euiThemeContext: UseEuiTheme) => {
	    euiQuickSelectPopover: import("@emotion/react").SerializedStyles;
	    euiQuickSelectPopoverButton: import("@emotion/react").SerializedStyles;
	    euiQuickSelectPopoverButton__content: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_utils' {
	import { QuickSelect } from '@elastic/eui/src/components/date_picker/types';
	/**
	 * This function returns time value, time unit and time tense for a given time string.
	 *
	 * For example: for `now-40m` it will parse output as time value to `40` time unit to `m` and time unit to `last`.
	 *
	 * If given a datetime string it will return a default value.
	 *
	 * If the given string is in the format such as `now/d` it will parse the string to moment object and find the time value, time unit and time tense using moment
	 *
	 * This function accepts two strings start and end time. I the start value is now then it uses the end value to parse.
	 */
	export const parseTimeParts: (start: string, end: string) => QuickSelect;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select' {
	import React, { Component, ChangeEventHandler, KeyboardEventHandler } from 'react';
	import moment from 'moment';
	import { ApplyTime, QuickSelect } from '@elastic/eui/src/components/date_picker/types';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	type EuiQuickSelectState = QuickSelect;
	export interface EuiQuickSelectProps {
	    applyTime: ApplyTime;
	    start: string;
	    end: string;
	    prevQuickSelect?: EuiQuickSelectState;
	    timeOptions: TimeOptions;
	}
	export class EuiQuickSelect extends Component<EuiQuickSelectProps, EuiQuickSelectState> {
	    constructor(props: EuiQuickSelectProps);
	    generateId: (idSuffix?: string) => string;
	    timeSelectionId: string;
	    legendId: string;
	    onTimeTenseChange: ChangeEventHandler<HTMLSelectElement>;
	    onTimeValueChange: ChangeEventHandler<HTMLInputElement>;
	    onTimeUnitsChange: ChangeEventHandler<HTMLSelectElement>;
	    handleKeyDown: KeyboardEventHandler<HTMLElement>;
	    applyQuickSelect: () => void;
	    getBounds: () => {
	        min: moment.Moment;
	        max: moment.Moment;
	    };
	    stepForward: () => void;
	    stepBackward: () => void;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/recently_used' {
	import { FunctionComponent } from 'react';
	import { DurationRange, ApplyTime } from '@elastic/eui/src/components/date_picker/types';
	export interface EuiRecentlyUsedProps {
	    applyTime: ApplyTime;
	    commonlyUsedRanges: DurationRange[];
	    dateFormat: string;
	    recentlyUsedRanges?: DurationRange[];
	}
	export const EuiRecentlyUsed: FunctionComponent<EuiRecentlyUsedProps>;

}
declare module '@elastic/eui/src/components/date_picker/auto_refresh/refresh_interval' {
	import React from 'react';
	import { Milliseconds, RefreshUnitsOptions, ApplyRefreshInterval } from '@elastic/eui/src/components/date_picker/types';
	export type EuiRefreshIntervalProps = {
	    /**
	     * Is refresh paused or running.
	     */
	    isPaused?: boolean;
	    /**
	     * Refresh interval in milliseconds.
	     */
	    refreshInterval?: Milliseconds;
	    /**
	     * Allows specifying a minimum interval in milliseconds
	     */
	    minInterval?: Milliseconds;
	    /**
	     * By default, refresh interval units will be rounded up to next largest unit of time
	     * (for example, 90 seconds will become 2m).
	     *
	     * If you do not want this behavior, you can manually control the rendered unit via this prop.
	     */
	    intervalUnits?: RefreshUnitsOptions;
	    /**
	     * Passes back the updated state of `isPaused`, `refreshInterval`, and `intervalUnits`.
	     */
	    onRefreshChange: ApplyRefreshInterval;
	};
	export const EuiRefreshInterval: {
	    ({ isPaused, refreshInterval, minInterval, intervalUnits, onRefreshChange, }: EuiRefreshIntervalProps): React.JSX.Element;
	    displayName: string;
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_popover' {
	import { FunctionComponent, ReactNode, ReactElement } from 'react';
	import { EuiFormAppendPrependButtonProps } from '@elastic/eui/src/components/form';
	import { EuiQuickSelect } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select';
	import { EuiCommonlyUsedTimeRanges } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/commonly_used_time_ranges';
	import { EuiRecentlyUsed } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/recently_used';
	import { EuiRefreshInterval } from '@elastic/eui/src/components/date_picker/auto_refresh/refresh_interval';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	import { DurationRange, ApplyRefreshInterval, RefreshUnitsOptions, ApplyTime, QuickSelect, QuickSelectPanel, Milliseconds } from '@elastic/eui/src/components/date_picker/types';
	export type EuiQuickSelectButtonProps = Partial<Omit<EuiFormAppendPrependButtonProps, 'children' | 'isDisabled'>>;
	export type CustomQuickSelectRenderOptions = {
	    quickSelect: ReactElement<typeof EuiQuickSelect>;
	    commonlyUsedRanges: ReactElement<typeof EuiCommonlyUsedTimeRanges>;
	    recentlyUsedRanges: ReactElement<typeof EuiRecentlyUsed>;
	    refreshInterval?: ReactElement<typeof EuiRefreshInterval>;
	    customQuickSelectPanels?: ReactNode;
	};
	export interface EuiQuickSelectPopoverProps {
	    applyRefreshInterval?: ApplyRefreshInterval;
	    applyTime: ApplyTime;
	    commonlyUsedRanges: DurationRange[];
	    customQuickSelectPanels?: QuickSelectPanel[];
	    customQuickSelectRender?: (options: CustomQuickSelectRenderOptions) => ReactNode;
	    dateFormat: string;
	    end: string;
	    isDisabled: boolean;
	    isPaused: boolean;
	    recentlyUsedRanges: DurationRange[];
	    refreshInterval: Milliseconds;
	    refreshMinInterval?: Milliseconds;
	    intervalUnits?: RefreshUnitsOptions;
	    start: string;
	    timeOptions: TimeOptions;
	    buttonProps?: EuiQuickSelectButtonProps;
	}
	export const EuiQuickSelectPopover: FunctionComponent<EuiQuickSelectPopoverProps>;
	export const EuiQuickSelectPanels: FunctionComponent<Omit<EuiQuickSelectPopoverProps, 'isDisabled' | 'buttonProps'> & {
	    prevQuickSelect?: QuickSelect;
	}>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover' {
	export type { EuiCommonlyUsedTimeRangesProps } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/commonly_used_time_ranges';
	export { EuiCommonlyUsedTimeRanges } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/commonly_used_time_ranges';
	export type { EuiQuickSelectPopoverProps } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_popover';
	export { EuiQuickSelectPopover } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_popover';
	export type { EuiQuickSelectProps } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select';
	export { EuiQuickSelect } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select';
	export { EuiQuickSelectPanel } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_panel';
	export type { EuiRecentlyUsedProps } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/recently_used';
	export { EuiRecentlyUsed } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/recently_used';

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/async_interval' {
	export class AsyncInterval {
	    timeoutId: number | null;
	    isStopped: boolean;
	    __pendingFn: Function;
	    constructor(fn: Function, refreshInterval: number);
	    setAsyncInterval: (fn: Function, milliseconds: number) => void;
	    stop: () => void;
	}

}
declare module '@elastic/eui/src/components/date_picker/date_picker_range.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiDatePickerRangeStyles: () => {
	    euiDatePickerRange: import("@emotion/react").SerializedStyles;
	};
	export const euiDatePickerRangeInlineStyles: (euiThemeContext: UseEuiTheme) => {
	    euiDatePickerRangeInline: import("@emotion/react").SerializedStyles;
	    responsive: import("@emotion/react").SerializedStyles;
	    responsiveWithTimeSelect: import("@emotion/react").SerializedStyles;
	    shadow: import("@emotion/react").SerializedStyles;
	    formLayout: {
	        noShadow: import("@emotion/react").SerializedStyles;
	        shadow: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/date_picker/date_picker_range' {
	import { FocusEventHandler, FunctionComponent, ReactNode, ReactElement } from 'react';
	import { EuiFormControlLayoutDelimitedProps } from '@elastic/eui/src/components/form';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiDatePickerProps } from '@elastic/eui/src/components/date_picker/date_picker';
	export type EuiDatePickerRangeProps = CommonProps & Pick<EuiFormControlLayoutDelimitedProps, 'isLoading' | 'isInvalid' | 'readOnly' | 'fullWidth' | 'compressed' | 'prepend' | 'append' | 'delimiter'> & {
	    /**
	     * Including any children will replace all innards with the provided children
	     */
	    children?: ReactNode;
	    /**
	     * The end date `EuiDatePicker` element
	     */
	    endDateControl?: ReactElement;
	    /**
	     * The start date `EuiDatePicker` element
	     */
	    startDateControl?: ReactElement;
	    /**
	     * Pass either an icon type or set to `false` to remove icon entirely
	     */
	    iconType?: boolean | IconType;
	    /**
	     * Define the side the icon should be displayed on. Applies only if `iconType` is defined as `IconType`.
	     */
	    iconSide?: 'left' | 'right';
	    /**
	     * Won't apply any additional props to start and end date components
	     */
	    isCustom?: boolean;
	    /**
	     * Passes through to each control
	     */
	    disabled?: boolean;
	    /**
	     * Displays both date picker calendars directly on the page.
	     * Will not render `iconType`, `fullWidth`, `prepend`, or `append`.
	     *
	     * Passes through to each control if `isCustom` is not set.
	     */
	    inline?: EuiDatePickerProps['inline'];
	    /**
	     * Allows turning the shadow off if using the `inline` prop
	     */
	    shadow?: EuiDatePickerProps['shadow'];
	    /**
	     * Triggered whenever the start or end controls are blurred
	     */
	    onBlur?: FocusEventHandler<HTMLInputElement>;
	    /**
	     * Triggered whenever the start or end controls are focused
	     */
	    onFocus?: FocusEventHandler<HTMLInputElement>;
	};
	export const EuiDatePickerRange: FunctionComponent<EuiDatePickerRangeProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/pretty_interval' {
	 const MS_INTERVALS: {
	    readonly s: 1000;
	    readonly m: number;
	    readonly h: number;
	    readonly d: number;
	};
	type IntervalUnitId = keyof typeof MS_INTERVALS;
	export const usePrettyInterval: (isPaused: boolean, intervalInMs: number, options?: {
	    shortHand?: boolean;
	    unit?: IntervalUnitId;
	}) => string;
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/time_window_buttons' {
	import React from 'react';
	import { ShortDate, ApplyTime } from '@elastic/eui/src/components/date_picker/types';
	export const ZOOM_FACTOR_DEFAULT = 0.5;
	export const ZOOM_DELTA_FALLBACK_MS = 500;
	export interface EuiTimeWindowButtonsConfig {
	    /**
	     * Show button for zooming out
	     * @default true
	     */
	    showZoomOut?: boolean;
	    /**
	     * Show button for zooming in.
	     * Defaults to false because it's a less common use case
	     * @default false
	     */
	    showZoomIn?: boolean;
	    /**
	     * Show buttons for shifting the time window forward and backward
	     * @default true
	     */
	    showShiftArrows?: boolean;
	    /**
	     * How much the time window is increased when zooming.
	     * A number between 0 and 1 e.g. 0.25, or a string representing a percentage e.g. 25%
	     * @default 0.5
	     * */
	    zoomFactor?: number | string;
	}
	export type EuiTimeWindowButtonsProps = EuiTimeWindowButtonsConfig & {
	    applyTime: ApplyTime;
	    start: ShortDate;
	    end: ShortDate;
	    compressed?: boolean;
	    isDisabled?: boolean;
	};
	/**
	 * Button group with time window controls for shifting the time window
	 * forwards and backwards, and zooming out.
	 */
	export const EuiTimeWindowButtons: React.FC<EuiTimeWindowButtonsProps>;
	/**
	 * Partly adapted from date_picker/super_date_picker/quick_select_popover/quick_select.tsx
	 */
	export function useEuiTimeWindow(start: ShortDate, end: ShortDate, apply: ApplyTime, options?: {
	    zoomFactor?: EuiTimeWindowButtonsConfig['zoomFactor'];
	}): {
	    displayInterval: string;
	    isInvalid: boolean;
	    stepForward: () => void;
	    stepBackward: () => void;
	    expandWindow: () => void;
	    shrinkWindow: () => void;
	    isWindowDurationZero: boolean;
	};

}
declare module '@elastic/eui/src/components/responsive/hide_for' {
	import { ReactNode, FunctionComponent } from 'react';
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	export type EuiHideForBreakpoints = EuiBreakpointSize;
	export interface EuiHideForProps {
	    /**
	     * Required otherwise nothing ever gets returned
	     */
	    children: ReactNode;
	    /**
	     * List of all the responsive sizes to hide the children for.
	     * Array of {@link EuiBreakpointSize}
	     */
	    sizes: EuiHideForBreakpoints[] | 'all' | 'none';
	}
	export const EuiHideFor: FunctionComponent<EuiHideForProps>;

}
declare module '@elastic/eui/src/components/responsive/show_for' {
	import { ReactNode, FunctionComponent } from 'react';
	import { EuiBreakpointSize } from '@elastic/eui/src/services';
	export type EuiShowForBreakpoints = EuiBreakpointSize;
	export interface EuiShowForProps {
	    /**
	     * Required otherwise nothing ever gets returned
	     */
	    children: ReactNode;
	    /**
	     * List of all the responsive sizes to show the children for.
	     * Array of {@link EuiBreakpointSize}
	     */
	    sizes: EuiShowForBreakpoints[] | 'all' | 'none';
	}
	export const EuiShowFor: FunctionComponent<EuiShowForProps>;

}
declare module '@elastic/eui/src/components/responsive' {
	export type { EuiHideForProps } from '@elastic/eui/src/components/responsive/hide_for';
	export { EuiHideFor } from '@elastic/eui/src/components/responsive/hide_for';
	export type { EuiShowForProps } from '@elastic/eui/src/components/responsive/show_for';
	export { EuiShowFor } from '@elastic/eui/src/components/responsive/show_for';

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/super_update_button' {
	import React, { Component, MouseEventHandler, ElementRef, ReactNode } from 'react';
	import { EuiButtonProps } from '@elastic/eui/src/components/button';
	import { EuiToolTip, EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	import { EuiBreakpointSize } from '@elastic/eui/src/services/breakpoint';
	type ToolTipRef = ElementRef<typeof EuiToolTip> | null;
	type EuiSuperUpdateButtonInternalProps = {
	    isDisabled?: boolean;
	    isLoading?: boolean;
	    needsUpdate?: boolean;
	    onClick: MouseEventHandler<HTMLButtonElement>;
	};
	export type EuiSuperUpdateButtonProps = {
	    /**
	     * Overrides the default button label with a custom React node.
	     *
	     * When defined, you're responsible for updating the custom label
	     * when the data needs updating (the `needsUpdate` prop)
	     * or is loading (the `isLoading` prop).
	     */
	    children?: ReactNode;
	    /**
	     * Show the "Click to apply" tooltip
	     */
	    showTooltip?: boolean;
	    /**
	     * Passes props to `EuiToolTip`
	     */
	    toolTipProps?: Partial<EuiToolTipProps>;
	    /**
	     * Returns an IconButton instead
	     */
	    iconOnly?: boolean;
	    /**
	     * Forces state to be `iconOnly` when within provided breakpoints.
	     * Remove completely with `false` or provide your own list of breakpoints.
	     */
	    responsive?: false | EuiBreakpointSize[];
	} & Partial<Omit<EuiButtonProps, 'isDisabled' | 'isLoading' | 'onClick' | 'children'>>;
	export class EuiSuperUpdateButton extends Component<EuiSuperUpdateButtonInternalProps & EuiSuperUpdateButtonProps> {
	    static defaultProps: {
	        needsUpdate: boolean;
	        isLoading: boolean;
	        isDisabled: boolean;
	        showTooltip: boolean;
	        responsive: string[];
	        fill: boolean;
	    };
	    _isMounted: boolean;
	    tooltipTimeout: number | undefined;
	    tooltip: ToolTipRef;
	    componentWillUnmount(): void;
	    componentDidMount(): void;
	    componentDidUpdate(): void;
	    setTootipRef: (node: ToolTipRef) => void;
	    showTooltip: () => void;
	    hideTooltip: () => void;
	    render(): React.JSX.Element;
	    private renderButtonContent;
	    private renderTooltipContent;
	}
	export {};

}
declare module '@elastic/eui/src/components/date_picker/auto_refresh/auto_refresh' {
	import { FunctionComponent } from 'react';
	import { EuiFieldTextProps } from '@elastic/eui/src/components/form';
	import { CommonEuiButtonEmptyProps } from '@elastic/eui/src/components/button/button_empty/button_empty';
	import { EuiRefreshIntervalProps } from '@elastic/eui/src/components/date_picker/auto_refresh/refresh_interval';
	export type EuiAutoRefreshSharedProps = EuiRefreshIntervalProps & {
	    isDisabled?: boolean;
	};
	export type EuiAutoRefreshProps = EuiAutoRefreshSharedProps & {
	    /**
	     * The input is `readOnly` by default because the input value is handled by the popover form.
	     */
	    readOnly?: EuiFieldTextProps['readOnly'];
	} & Omit<EuiFieldTextProps, 'icon' | 'prepend' | 'controlOnly' | 'readOnly'>;
	export const EuiAutoRefresh: FunctionComponent<EuiAutoRefreshProps>;
	export type EuiAutoRefreshButtonProps = EuiAutoRefreshSharedProps & {
	    /**
	     * Reduces the time unit to a single letter
	     */
	    shortHand?: boolean;
	} & Omit<CommonEuiButtonEmptyProps, 'isSelected' | 'iconType' | 'iconSide' | 'iconSize' | 'onClick' | 'type'>;
	export const EuiAutoRefreshButton: FunctionComponent<EuiAutoRefreshButtonProps>;

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/super_date_picker.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSuperDatePickerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSuperDatePicker: import("@emotion/react").SerializedStyles;
	    widths: {
	        restricted: import("@emotion/react").SerializedStyles;
	        full: import("@emotion/react").SerializedStyles;
	        auto: import("@emotion/react").SerializedStyles;
	    };
	    noUpdateButton: {
	        restricted: string;
	        auto: string;
	        full: string;
	    };
	    isAutoRefreshOnly: {
	        restricted: string;
	        auto: string;
	        full: string;
	    };
	    isQuickSelectOnly: import("@emotion/react").SerializedStyles;
	    euiSuperDatePicker__range: import("@emotion/react").SerializedStyles;
	    euiSuperDatePicker__rangeInput: import("@emotion/react").SerializedStyles;
	    euiSuperDatePicker__prettyDurationTooltip: import("@emotion/react").SerializedStyles;
	    states: {
	        euiSuperDatePicker__formControlLayout: import("@emotion/react").SerializedStyles;
	        default: import("@emotion/react").SerializedStyles;
	        disabled: import("@emotion/react").SerializedStyles;
	        invalid: import("@emotion/react").SerializedStyles;
	        needsUpdating: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker/super_date_picker' {
	import React, { Component, FocusEventHandler, FunctionComponent, ReactNode } from 'react';
	import moment, { LocaleSpecifier } from 'moment';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { ShortDate, Milliseconds, DurationRange, ApplyTime, ApplyRefreshInterval, RefreshUnitsOptions, QuickSelectPanel } from '@elastic/eui/src/components/date_picker/types';
	import { TimeOptions } from '@elastic/eui/src/components/date_picker/super_date_picker/time_options';
	import { type EuiTimeWindowButtonsConfig } from '@elastic/eui/src/components/date_picker/super_date_picker/time_window_buttons';
	import { AsyncInterval } from '@elastic/eui/src/components/date_picker/super_date_picker/async_interval';
	import { EuiSuperUpdateButtonProps } from '@elastic/eui/src/components/date_picker/super_date_picker/super_update_button';
	import { CustomQuickSelectRenderOptions, EuiQuickSelectButtonProps } from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover/quick_select_popover';
	import { type EuiTimeZoneDisplayProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/timezone_display';
	import { EuiDatePopoverContentProps } from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover/date_popover_content';
	import { euiSuperDatePickerStyles } from '@elastic/eui/src/components/date_picker/super_date_picker/super_date_picker.styles';
	export interface OnTimeChangeProps extends DurationRange {
	    isInvalid: boolean;
	    isQuickSelection: boolean;
	}
	export interface OnRefreshProps extends DurationRange {
	    refreshInterval: number;
	}
	export type EuiSuperDatePickerProps = CommonProps & {
	    commonlyUsedRanges?: DurationRange[];
	    customQuickSelectPanels?: QuickSelectPanel[];
	    /**
	     * An optional render prop function that allows customizing the display of the Quick Select menu.
	     * This function passes all default quick select panels within an object, allowing you to
	     * re-order panels, omit certain panels entirely, or pass in your own fully custom content.
	     */
	    customQuickSelectRender?: (options: CustomQuickSelectRenderOptions) => ReactNode;
	    /**
	     * Specifies the formatted used when displaying dates and/or datetimes
	     * @default 'MMM D, YYYY @ HH:mm:ss.SSS'
	     */
	    dateFormat?: string;
	    /**
	     * Set isAutoRefreshOnly to true to limit the component to only display auto refresh content.
	     */
	    isAutoRefreshOnly?: boolean;
	    /**
	     * Accepts either a true/false boolean or an object configuration.
	     *
	     * The configuration will render the component as disabled, and allow you to
	     * customize the displayed disabled text.
	     */
	    isDisabled?: boolean | {
	        display: ReactNode;
	    };
	    isLoading?: boolean;
	    /**
	     * @default true
	     */
	    isPaused?: boolean;
	    /**
	     * Sets the overall width by adding sensible min and max widths.
	     * - `auto`: fits width to internal content / time string.
	     * - `restricted`: static width that fits the longest possible time string.
	     * - `full`: expands to 100% of the container.
	     * @default 'restricted'
	     */
	    width?: 'restricted' | 'full' | 'auto';
	    /**
	     * Reduces overall height to compressed form size
	     */
	    compressed?: boolean;
	    /**
	     * Used to localize e.g. month names, passed to `moment`
	     */
	    locale?: LocaleSpecifier;
	    /**
	     * Triggered whenever the EuiSuperDatePicker's dates are focused
	     */
	    onFocus?: FocusEventHandler;
	    /**
	     * Callback for when the refresh interval is fired.
	     * EuiSuperDatePicker will only manage a refresh interval timer when onRefresh callback is supplied
	     * If a promise is returned, the next refresh interval will not start until the promise has resolved.
	     * If the promise rejects the refresh interval will stop and the error thrown
	     */
	    onRefresh?: (props: OnRefreshProps) => void;
	    /**
	     * Callback for when the refresh interval changes.
	     * Supply onRefreshChange to show refresh interval inputs in quick select popover
	     */
	    onRefreshChange?: ApplyRefreshInterval;
	    /**
	     * Callback for when the time changes.
	     */
	    onTimeChange: (props: OnTimeChangeProps) => void;
	    recentlyUsedRanges?: DurationRange[];
	    /**
	     * Refresh interval in milliseconds
	     * @default 1000
	     */
	    refreshInterval?: Milliseconds;
	    /**
	     * Minimum refresh interval in milliseconds
	     * @default 0
	     */
	    refreshMinInterval?: Milliseconds;
	    /**
	     * By default, refresh interval units will be rounded up to next largest unit of time
	     * (for example, 90 seconds will become 2m).
	     *
	     * If you do not want this behavior, you will need to store the user-set `intervalUnits`
	     * (passed by `onRefreshChange`) and manually control it via this prop.
	     */
	    refreshIntervalUnits?: RefreshUnitsOptions;
	    /**
	     * @default 'now-15m'
	     */
	    start?: ShortDate;
	    /**
	     * @default 'now'
	     */
	    end?: ShortDate;
	    /**
	     * Defines min. date accepted as a selection (in moment format)
	     */
	    minDate?: moment.Moment;
	    /**
	     * Defines max. date accepted as a selection (in moment format)
	     */
	    maxDate?: moment.Moment;
	    /**
	     * Specifies the formatted used when displaying times
	     * @default 'HH:mm'
	     */
	    timeFormat?: string;
	    utcOffset?: number;
	    /**
	     * Set showUpdateButton to false to immediately invoke onTimeChange for all start and end changes.
	     * @default true
	     */
	    showUpdateButton?: boolean | 'iconOnly';
	    /**
	     * Set to true to display buttons for time shifting and zooming out,
	     * next to the top-level control.
	     */
	    showTimeWindowButtons?: boolean | EuiTimeWindowButtonsConfig;
	    /**
	     * Hides the actual input reducing to just the quick select button.
	     */
	    isQuickSelectOnly?: boolean;
	    /**
	     * Props passed to the update button {@link EuiSuperUpdateButtonProps}
	     */
	    updateButtonProps?: EuiSuperUpdateButtonProps;
	    /**
	     * Props passed to the quick select button {@link EuiQuickSelectButtonProps}
	     */
	    quickSelectButtonProps?: EuiQuickSelectButtonProps;
	    /**
	     * By default, relative units will be rounded up to next largest unit of time
	     * (for example, 90 minutes will become ~ 2 hours).
	     *
	     * If you do not want this behavior and instead wish to keep the exact units
	     * input by the user, set this flag to `false`.
	     */
	    canRoundRelativeUnits?: boolean;
	    /**
	     * Props passed to the time zone display in the popovers {@link EuiTimeZoneDisplayProps}
	     *
	     * Setting `timeZoneDisplayProps.timeZone` with a valid time zone name will make
	     * the time zone information be visible below the start and end input fields.
	     * This is informational only, it will not affect how date/times are handled.
	     */
	    timeZoneDisplayProps?: EuiTimeZoneDisplayProps;
	};
	type EuiSuperDatePickerInternalProps = EuiSuperDatePickerProps & {
	    memoizedStyles: ReturnType<typeof euiSuperDatePickerStyles>;
	    timeOptions: TimeOptions;
	    commonlyUsedRanges: DurationRange[];
	    recentlyUsedRanges: DurationRange[];
	    start: ShortDate;
	    end: ShortDate;
	    refreshInterval: Milliseconds;
	    dateFormat: string;
	    timeFormat: string;
	    isPaused: boolean;
	};
	interface EuiSuperDatePickerState {
	    end: ShortDate;
	    hasChanged: boolean;
	    isEndDatePopoverOpen: boolean;
	    isInvalid: boolean;
	    isStartDatePopoverOpen: boolean;
	    prevProps: {
	        end: ShortDate;
	        start: ShortDate;
	    };
	    showPrettyDuration: boolean;
	    start: ShortDate;
	}
	export class EuiSuperDatePickerInternal extends Component<EuiSuperDatePickerInternalProps, EuiSuperDatePickerState> {
	    static defaultProps: {
	        dateFormat: string;
	        end: string;
	        isAutoRefreshOnly: boolean;
	        isDisabled: boolean;
	        isPaused: boolean;
	        recentlyUsedRanges: never[];
	        refreshInterval: number;
	        showUpdateButton: boolean;
	        canRoundRelativeUnits: boolean;
	        start: string;
	        timeFormat: string;
	        width: string;
	    };
	    asyncInterval?: AsyncInterval;
	    state: EuiSuperDatePickerState;
	    static getDerivedStateFromProps(nextProps: EuiSuperDatePickerInternalProps, prevState: EuiSuperDatePickerState): {
	        prevProps: {
	            start: string;
	            end: string;
	        };
	        start: string;
	        end: string;
	        isInvalid: boolean;
	        hasChanged: boolean;
	        showPrettyDuration: boolean;
	    } | null;
	    setTime: ({ end, start }: DurationRange) => void;
	    componentDidMount: () => void;
	    componentDidUpdate: () => void;
	    componentWillUnmount: () => void;
	    setStart: EuiDatePopoverContentProps['onChange'];
	    setEnd: EuiDatePopoverContentProps['onChange'];
	    applyTime: () => void;
	    applyQuickTime: ApplyTime;
	    hidePrettyDuration: () => void;
	    onStartDatePopoverToggle: () => void;
	    onStartDatePopoverClose: () => void;
	    onEndDatePopoverToggle: () => void;
	    onEndDatePopoverClose: () => void;
	    onRefreshChange: ApplyRefreshInterval;
	    stopInterval: () => void;
	    startInterval: (refreshInterval: number) => void;
	    renderQuickSelect: () => React.JSX.Element;
	    renderDatePickerRange: () => React.JSX.Element;
	    handleClickUpdateButton: () => void;
	    renderTimeWindowButtons: () => React.JSX.Element | null;
	    renderUpdateButton: () => React.JSX.Element | null;
	    render(): React.JSX.Element;
	}
	export const EuiSuperDatePicker: FunctionComponent<EuiSuperDatePickerProps>;
	export {};

}
declare module '@elastic/eui/src/components/date_picker/super_date_picker' {
	export * from '@elastic/eui/src/components/date_picker/super_date_picker/date_popover';
	export * from '@elastic/eui/src/components/date_picker/super_date_picker/quick_select_popover';
	export { AsyncInterval } from '@elastic/eui/src/components/date_picker/super_date_picker/async_interval';
	export type { EuiSuperDatePickerProps, OnTimeChangeProps, OnRefreshProps, } from '@elastic/eui/src/components/date_picker/super_date_picker/super_date_picker';
	export { EuiSuperDatePicker } from '@elastic/eui/src/components/date_picker/super_date_picker/super_date_picker';
	export type { EuiSuperUpdateButtonProps } from '@elastic/eui/src/components/date_picker/super_date_picker/super_update_button';
	export { EuiSuperUpdateButton } from '@elastic/eui/src/components/date_picker/super_date_picker/super_update_button';
	export type { EuiTimeWindowButtonsConfig } from '@elastic/eui/src/components/date_picker/super_date_picker/time_window_buttons';
	export { useEuiTimeWindow } from '@elastic/eui/src/components/date_picker/super_date_picker/time_window_buttons';
	export { PrettyDuration, usePrettyDuration } from '@elastic/eui/src/components/date_picker/super_date_picker/pretty_duration';

}
declare module '@elastic/eui/src/components/date_picker/auto_refresh' {
	export type { EuiAutoRefreshProps, EuiAutoRefreshButtonProps, EuiAutoRefreshSharedProps, } from '@elastic/eui/src/components/date_picker/auto_refresh/auto_refresh';
	export { EuiAutoRefresh, EuiAutoRefreshButton } from '@elastic/eui/src/components/date_picker/auto_refresh/auto_refresh';
	export type { EuiRefreshIntervalProps } from '@elastic/eui/src/components/date_picker/auto_refresh/refresh_interval';
	export { EuiRefreshInterval } from '@elastic/eui/src/components/date_picker/auto_refresh/refresh_interval';

}
declare module '@elastic/eui/src/components/date_picker' {
	export * from '@elastic/eui/src/components/date_picker/super_date_picker';
	export * from '@elastic/eui/src/components/date_picker/auto_refresh';
	export type { EuiDatePickerProps } from '@elastic/eui/src/components/date_picker/date_picker';
	export { EuiDatePicker } from '@elastic/eui/src/components/date_picker/date_picker';
	export type { EuiDatePickerRangeProps } from '@elastic/eui/src/components/date_picker/date_picker_range';
	export { EuiDatePickerRange } from '@elastic/eui/src/components/date_picker/date_picker_range';
	export type { ApplyTime, DurationRange as EuiSuperDatePickerCommonRange, DurationRange as EuiSuperDatePickerDurationRange, DurationRange as EuiSuperDatePickerRecentRange, TimeUnitId, TimeUnitFromNowId, TimeUnitLabel, TimeUnitLabelPlural, AbsoluteDateMode, RelativeDateMode, NowDateMode, DateMode, OnRefreshChangeProps, RefreshUnitsOptions, ShortDate, RelativeParts, RelativeOption, QuickSelect, QuickSelectPanel as EuiSuperDatePickerQuickSelectPanel, } from '@elastic/eui/src/components/date_picker/types';

}
declare module '@elastic/eui/src/components/delay_hide/delay_hide' {
	import { Component, ReactNode } from 'react';
	export interface EuiDelayHideProps {
	    hide: boolean;
	    minimumDuration: number;
	    render: () => ReactNode;
	}
	interface EuiDelayHideState {
	    hide: boolean;
	    countdownExpired?: boolean;
	}
	export class EuiDelayHide extends Component<EuiDelayHideProps, EuiDelayHideState> {
	    static defaultProps: {
	        hide: boolean;
	        minimumDuration: number;
	    };
	    static getDerivedStateFromProps(nextProps: EuiDelayHideProps, prevState: EuiDelayHideState): {
	        hide: boolean;
	        countdownExpired: boolean | undefined;
	    };
	    state: {
	        hide: boolean;
	        countdownExpired: boolean;
	    };
	    private timeoutId?;
	    componentDidMount(): void;
	    componentDidUpdate(prevProps: EuiDelayHideProps): void;
	    componentWillUnmount(): void;
	    startCountdown: () => void;
	    finishCountdown: () => void;
	    render(): ReactNode;
	}
	export {};

}
declare module '@elastic/eui/src/components/delay_hide' {
	export type { EuiDelayHideProps } from '@elastic/eui/src/components/delay_hide/delay_hide';
	export { EuiDelayHide } from '@elastic/eui/src/components/delay_hide/delay_hide';

}
declare module '@elastic/eui/src/components/empty_prompt/empty_prompt.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiEmptyPromptStyles: (euiThemeContext: UseEuiTheme) => {
	    euiEmptyPrompt: import("@emotion/react").SerializedStyles;
	    vertical: import("@emotion/react").SerializedStyles;
	    horizontal: import("@emotion/react").SerializedStyles;
	    main: {
	        horizontalPadding: {
	            none: null;
	            s: import("@emotion/react").SerializedStyles;
	            m: import("@emotion/react").SerializedStyles;
	            l: import("@emotion/react").SerializedStyles;
	        };
	        none: null;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        euiEmptyPrompt__main: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	    };
	    content: {
	        euiEmptyPrompt__content: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	    };
	    icon: {
	        euiEmptyPrompt__icon: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	    };
	    actions: {
	        euiEmptyPrompt__actions: import("@emotion/react").SerializedStyles;
	        vertical: import("@emotion/react").SerializedStyles;
	        horizontal: import("@emotion/react").SerializedStyles;
	    };
	    footer: {
	        none: null;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	        euiEmptyPrompt__footer: import("@emotion/react").SerializedStyles;
	        roundedBorders: import("@emotion/react").SerializedStyles;
	        transparent: import("@emotion/react").SerializedStyles;
	        plain: import("@emotion/react").SerializedStyles;
	        subdued: import("@emotion/react").SerializedStyles;
	        highlighted: import("@emotion/react").SerializedStyles;
	        primary: import("@emotion/react").SerializedStyles;
	        accent: import("@emotion/react").SerializedStyles;
	        accentSecondary: import("@emotion/react").SerializedStyles;
	        danger: import("@emotion/react").SerializedStyles;
	        risk: import("@emotion/react").SerializedStyles;
	        warning: import("@emotion/react").SerializedStyles;
	        success: import("@emotion/react").SerializedStyles;
	        neutral: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/empty_prompt/empty_prompt' {
	import { FunctionComponent, ReactElement, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTitleSize } from '@elastic/eui/src/components/title';
	import { IconColor, IconType } from '@elastic/eui/src/components/icon';
	import { _EuiPanelDivlike } from '@elastic/eui/src/components/panel/panel';
	export const PADDING_SIZES: readonly ["none", "s", "m", "l"];
	export type PaddingSize = (typeof PADDING_SIZES)[number];
	export type EuiEmptyPromptProps = CommonProps & Omit<_EuiPanelDivlike, 'borderRadius' | 'grow' | 'panelRef' | 'paddingSize' | 'title' | 'element'> & {
	    iconType?: IconType;
	    /**
	     * Color for `iconType` when passed as an `IconType`
	     */
	    iconColor?: IconColor;
	    /**
	     * Custom icon replacing the one generated by `iconType`
	     */
	    icon?: ReactNode;
	    /**
	     * Requires passing a single element that gets wrapped in an EuiTitle.
	     * Recommendation is a heading, preferrably an `<h2>` if in its own section
	     */
	    title?: ReactElement<any>;
	    /**
	     * Choose from one of the `EuiTitle.size` options
	     */
	    titleSize?: EuiTitleSize;
	    /**
	     * Gets wrapped in a subdued EuiText block.
	     * Recommendation is to pass typical text elements like `<p>`
	     */
	    body?: ReactNode;
	    /**
	     * Pass a single or an array of actions (buttons) that get stacked at the bottom.
	     * Recommendation is to pass the primary action first and secondary actions as empty buttons
	     */
	    actions?: ReactNode;
	    /**
	     * Optionally provide a footer. Accepts any combination of elements.
	     */
	    footer?: ReactNode;
	    /**
	     * Sets the layout. When `horizontal` the icon goes to the right column.
	     */
	    layout?: 'vertical' | 'horizontal';
	    /**
	     * Padding applied around the content and footer.
	     */
	    paddingSize?: PaddingSize;
	};
	export const EuiEmptyPrompt: FunctionComponent<EuiEmptyPromptProps>;

}
declare module '@elastic/eui/src/components/empty_prompt' {
	export type { EuiEmptyPromptProps } from '@elastic/eui/src/components/empty_prompt/empty_prompt';
	export { EuiEmptyPrompt } from '@elastic/eui/src/components/empty_prompt/empty_prompt';

}
declare module '@elastic/eui/src/components/error_boundary/error_boundary.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiErrorBoundaryStyles: (euiThemeContext: UseEuiTheme) => {
	    euiErrorBoundary: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/error_boundary/error_boundary' {
	import React, { Component, FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	interface EuiErrorBoundaryState {
	    hasError: boolean;
	    errorMessage?: string;
	}
	export type EuiErrorBoundaryProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'onError'> & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * Callback that fires when an error is caught. Passes back the full error
	     */
	    onError?: (error: Error) => void;
	};
	export class EuiErrorBoundary extends Component<EuiErrorBoundaryProps, EuiErrorBoundaryState> {
	    constructor(props: EuiErrorBoundaryProps);
	    componentDidCatch(error: Error): void;
	    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
	}
	/**
	 * Split out into a separate styling-only component for easier use of hooks,
	 * and also for internal re-use by EUI's docs/playgrounds
	 */
	export const EuiErrorMessage: FunctionComponent<CommonProps & {
	    errorMessage?: string;
	}>;
	export {};

}
declare module '@elastic/eui/src/components/error_boundary' {
	export type { EuiErrorBoundaryProps } from '@elastic/eui/src/components/error_boundary/error_boundary';
	export { EuiErrorBoundary } from '@elastic/eui/src/components/error_boundary/error_boundary';

}
declare module '@elastic/eui/src/components/expression/expression.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiExpressionStyles: (euiThemeContext: UseEuiTheme) => {
	    euiExpression: import("@emotion/react").SerializedStyles;
	    columns: import("@emotion/react").SerializedStyles;
	    truncate: import("@emotion/react").SerializedStyles;
	    isClickable: import("@emotion/react").SerializedStyles;
	    isActive: {
	        base: import("@emotion/react").SerializedStyles;
	        subdued: import("@emotion/react").SerializedStyles;
	        primary: import("@emotion/react").SerializedStyles;
	        success: import("@emotion/react").SerializedStyles;
	        warning: import("@emotion/react").SerializedStyles;
	        danger: import("@emotion/react").SerializedStyles;
	        accent: import("@emotion/react").SerializedStyles;
	    };
	    subdued: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	};
	export const euiExpressionDescriptionStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiExpression__description: import("@emotion/react").SerializedStyles;
	    truncate: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    isUppercase: import("@emotion/react").SerializedStyles;
	    columns: import("@emotion/react").SerializedStyles;
	};
	export const euiExpressionValueStyles: {
	    euiExpression__value: import("@emotion/react").SerializedStyles;
	    truncate: import("@emotion/react").SerializedStyles;
	    columns: import("@emotion/react").SerializedStyles;
	};
	export const euiExpressionIconStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiExpression__icon: import("@emotion/react").SerializedStyles;
	    columns: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/expression/expression' {
	import { ButtonHTMLAttributes, HTMLAttributes, MouseEventHandler, ReactNode, FunctionComponent } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export const COLORS: readonly ["subdued", "primary", "success", "accent", "warning", "danger"];
	export type ExpressionColor = (typeof COLORS)[number];
	export type EuiExpressionProps = CommonProps & {
	    /**
	     * First part of the expression
	     */
	    description: ReactNode;
	    descriptionProps?: CommonProps & HTMLAttributes<HTMLSpanElement>;
	    /**
	     * Second part of the expression
	     */
	    value?: ReactNode;
	    valueProps?: CommonProps & HTMLAttributes<HTMLSpanElement>;
	    /**
	     * Color of the `description`
	     */
	    color?: ExpressionColor;
	    /**
	     * Should the `description` auto-uppercase?
	     */
	    uppercase?: boolean;
	    /**
	     * Adds an solid border at the bottom
	     */
	    isActive?: boolean;
	    /**
	     * Turns the component into a button and adds an editable style border at the bottom
	     */
	    onClick?: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Sets the display style for the expression. Defaults to `inline`
	     */
	    display?: 'inline' | 'columns';
	    /**
	     * Forces color to display as `danger` and shows an `error` icon
	     */
	    isInvalid?: boolean;
	    /**
	     * Sets a custom width for the description when using the columns layout.
	     * Set to a number for a custom width in `px`.
	     * Set to a string for a custom width in custom measurement.
	     * Defaults to `20%`
	     */
	    descriptionWidth?: number | string;
	    /**
	     * Sets how to handle the wrapping of long text.
	     */
	    textWrap?: 'break-word' | 'truncate';
	};
	type Buttonlike = EuiExpressionProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value'> & {
	    onClick: MouseEventHandler<HTMLButtonElement>;
	};
	type Spanlike = EuiExpressionProps & Omit<HTMLAttributes<HTMLSpanElement>, 'value'>;
	export const EuiExpression: FunctionComponent<ExclusiveUnion<Buttonlike, Spanlike>>;
	export {};

}
declare module '@elastic/eui/src/components/expression' {
	export type { EuiExpressionProps } from '@elastic/eui/src/components/expression/expression';
	export { EuiExpression } from '@elastic/eui/src/components/expression/expression';

}
declare module '@elastic/eui/src/components/filter_group/filter_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFilterButtonDisplay: (euiThemeContext: UseEuiTheme) => {
	    flex: string;
	    minInlineSize: string;
	};
	export const euiFilterButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFilterButton: import("@emotion/react").SerializedStyles;
	    buttonType: {
	        default: import("@emotion/react").SerializedStyles;
	        toggle: import("@emotion/react").SerializedStyles;
	    };
	    withNext: import("@emotion/react").SerializedStyles;
	    noGrow: import("@emotion/react").SerializedStyles;
	    hasNotification: import("@emotion/react").SerializedStyles;
	    hasActiveFilters: import("@emotion/react").SerializedStyles;
	};
	export const euiFilterButtonWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    wrapper: import("@emotion/react").SerializedStyles;
	    hasToggle: import("@emotion/react").SerializedStyles;
	};
	export const euiFilterButtonChildStyles: (euiThemeContext: UseEuiTheme) => {
	    content: {
	        euiFilterButton__content: import("@emotion/react").SerializedStyles;
	        hasIcon: import("@emotion/react").SerializedStyles;
	    };
	    text: {
	        euiFilterButton__text: import("@emotion/react").SerializedStyles;
	        hasNotification: import("@emotion/react").SerializedStyles;
	    };
	    notification: {
	        euiFilterButton__notification: import("@emotion/react").SerializedStyles;
	        disabled: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/filter_group/filter_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFilterGroupStyles: (euiThemeContext: UseEuiTheme) => {
	    euiFilterGroup: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    uncompressed: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	    /**
	     * Not used in EuiFilterGroup directly, but used by EuiSearchBar and consumers
	     * A fixed width is required because of the shift in widths that can be caused
	     * by the loading animation that precedes the results.
	     */
	    euiFilterGroup__popoverPanel: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/filter_group/filter_group' {
	import { HTMLAttributes, ReactNode, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiFilterGroupProps = HTMLAttributes<HTMLDivElement> & CommonProps & {
	    children?: ReactNode;
	    /**
	     * Expand the whole bar to fill its parent's width
	     */
	    fullWidth?: boolean;
	    /**
	     *  When `true`, creates a shorter height filter group matching that of `compressed` form controls
	     */
	    compressed?: boolean;
	};
	export const EuiFilterGroup: FunctionComponent<EuiFilterGroupProps>;

}
declare module '@elastic/eui/src/components/filter_group/filter_button' {
	import { FunctionComponent } from 'react';
	import { _EuiButtonColor } from '@elastic/eui/src/global_styling';
	import { type EuiDisabledProps } from '@elastic/eui/src/services/hooks/useEuiDisabledElement';
	import { DistributiveOmit } from '@elastic/eui/src/components/common';
	import { BadgeNotificationColor } from '@elastic/eui/src/components/badge/notification_badge/badge_notification';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button/button_empty';
	export type EuiFilterButtonProps = {
	    /**
	     * Highlights active filters
	     */
	    hasActiveFilters?: boolean;
	    /**
	     * Pass the total number of filters available and it will
	     * add a subdued notification badge showing the number
	     */
	    numFilters?: number;
	    /**
	     * The number of active (selected) filters.
	     * The value will be displayed as a bright notification badge.
	     *
	     * Accepted values are integers and percentages (e.g., 20%).
	     * Passing other values is not supported and may break the layout.
	     *
	     * @example 10
	     * @example '20%'
	     */
	    numActiveFilters?: number | string;
	    /**
	     * Switches between toggle and regular button
	     * @default false
	     */
	    isToggle?: boolean;
	    /**
	     * Applies a visual state to the button.
	     * Automatically applies `aria-pressed` when used with `isToggle={true}`.
	     * Otherwise applies `aria-expanded` when used with `isToggle={false}` and
	     * `iconType="chevronSingleDown"` as trigger button for e.g. a popover.
	     */
	    isSelected?: boolean;
	    /**
	     * Should the button grow to fill its container, best used for dropdown buttons
	     */
	    grow?: boolean;
	    /**
	     * Remove border after button, good for opposite filters
	     */
	    withNext?: boolean;
	    /**
	     * Change color of the counter badge
	     */
	    badgeColor?: BadgeNotificationColor;
	    /**
	     * Any of the named color palette options.
	     *
	     * Do not use the following colors for standalone buttons directly,
	     * they exist to serve other components:
	     *  - accent
	     *  - warning
	     */
	    color?: _EuiButtonColor;
	} & DistributiveOmit<EuiButtonEmptyProps, 'flush' | 'size' | 'color' | 'isSelected'> & EuiDisabledProps;
	export const EuiFilterButton: FunctionComponent<EuiFilterButtonProps>;

}
declare module '@elastic/eui/src/components/filter_group' {
	export type { EuiFilterGroupProps } from '@elastic/eui/src/components/filter_group/filter_group';
	export { EuiFilterGroup } from '@elastic/eui/src/components/filter_group/filter_group';
	export type { EuiFilterButtonProps } from '@elastic/eui/src/components/filter_group/filter_button';
	export { EuiFilterButton } from '@elastic/eui/src/components/filter_group/filter_button';
	export type { EuiFilterSelectItemProps, FilterChecked, } from '@elastic/eui/src/components/filter_group/filter_select_item';
	export { EuiFilterSelectItem } from '@elastic/eui/src/components/filter_group/filter_select_item';

}
declare module '@elastic/eui/src/components/facet/facet_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFacetButtonStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiFacetButton: import("@emotion/react").SerializedStyles;
	};
	export const euiFacetButtonTextStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiFacetButton__text: import("@emotion/react").SerializedStyles;
	    isSelected: import("@emotion/react").SerializedStyles;
	    unSelected: import("@emotion/react").SerializedStyles;
	};
	export const euiFacetButton__disabled: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/facet/facet_button' {
	import { FunctionComponent, HTMLAttributes, ReactNode, RefCallback } from 'react';
	import { EuiButtonDisplayCommonProps } from '@elastic/eui/src/components/button/button_display/_button_display';
	export interface EuiFacetButtonProps extends EuiButtonDisplayCommonProps, HTMLAttributes<HTMLButtonElement> {
	    buttonRef?: RefCallback<HTMLButtonElement>;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * Any node, but preferably a `EuiIcon` or `EuiAvatar`
	     */
	    icon?: ReactNode;
	    isDisabled?: boolean;
	    /**
	     * Adds/swaps for loading spinner & disables
	     */
	    isLoading?: boolean;
	    /**
	     * Changes visual of button to indicate it's currently selected
	     */
	    isSelected?: boolean;
	    /**
	     * Adds a notification indicator for displaying the quantity provided
	     */
	    quantity?: number;
	}
	export const EuiFacetButton: FunctionComponent<EuiFacetButtonProps>;

}
declare module '@elastic/eui/src/components/facet/facet_group.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiFacetGroupStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiFacetGroup: import("@emotion/react").SerializedStyles;
	    horizontal: import("@emotion/react").SerializedStyles;
	    vertical: import("@emotion/react").SerializedStyles;
	    gutterSizes: {
	        vertical: {
	            none: import("@emotion/react").SerializedStyles;
	            s: import("@emotion/react").SerializedStyles;
	            m: import("@emotion/react").SerializedStyles;
	            l: import("@emotion/react").SerializedStyles;
	        };
	        horizontal: {
	            none: import("@emotion/react").SerializedStyles;
	            s: import("@emotion/react").SerializedStyles;
	            m: import("@emotion/react").SerializedStyles;
	            l: import("@emotion/react").SerializedStyles;
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/facet/facet_group' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const LAYOUTS: readonly ["vertical", "horizontal"];
	export type EuiFacetGroupLayout = (typeof LAYOUTS)[number];
	export const GUTTER_SIZES: readonly ["none", "s", "m", "l"];
	export type EuiFacetGroupGutterSizes = (typeof GUTTER_SIZES)[number];
	export type EuiFacetGroupProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * Vertically in a column, or horizontally in one wrapping line
	     */
	    layout?: EuiFacetGroupLayout;
	    /**
	     * Distance between facet buttons.
	     * Horizontal layout always adds more distance horizontally between buttons.
	     */
	    gutterSize?: EuiFacetGroupGutterSizes;
	};
	export const EuiFacetGroup: FunctionComponent<EuiFacetGroupProps>;

}
declare module '@elastic/eui/src/components/facet' {
	export type { EuiFacetButtonProps } from '@elastic/eui/src/components/facet/facet_button';
	export { EuiFacetButton } from '@elastic/eui/src/components/facet/facet_button';
	export type { EuiFacetGroupProps } from '@elastic/eui/src/components/facet/facet_group';
	export { EuiFacetGroup } from '@elastic/eui/src/components/facet/facet_group';

}
declare module '@elastic/eui/src/components/header/header_breadcrumbs/header_breadcrumbs.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderBreadcrumbsStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiHeaderBreadcrumbs: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_breadcrumbs/header_breadcrumbs' {
	import { FunctionComponent } from 'react';
	import { EuiBreadcrumbsProps } from '@elastic/eui/src/components/breadcrumbs';
	export const EuiHeaderBreadcrumbs: FunctionComponent<EuiBreadcrumbsProps>;

}
declare module '@elastic/eui/src/components/header/header_breadcrumbs' {
	export { EuiHeaderBreadcrumbs } from '@elastic/eui/src/components/header/header_breadcrumbs/header_breadcrumbs';

}
declare module '@elastic/eui/src/components/header/header_section/header_section.styles' {
	export const euiHeaderSectionStyles: () => {
	    euiHeaderSection: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_section/header_section' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiHeaderSectionProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    side?: 'left' | 'right';
	    grow?: boolean;
	};
	export const EuiHeaderSection: FunctionComponent<EuiHeaderSectionProps>;

}
declare module '@elastic/eui/src/components/header/header_section/header_section_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderSectionItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHeaderSectionItem: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_section/header_section_item' {
	import { FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiHeaderSectionItemProps = CommonProps & {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	};
	/**
	 * Header items are small icon links that pop up menus
	 */
	export const EuiHeaderSectionItem: FunctionComponent<EuiHeaderSectionItemProps>;

}
declare module '@elastic/eui/src/components/header/header_section/header_section_item_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderSectionItemButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHeaderSectionItemButton: import("@emotion/react").SerializedStyles;
	    euiHeaderSectionItemButton__content: import("@emotion/react").SerializedStyles;
	    notification: {
	        euiHeaderSectionItemButton__notification: import("@emotion/react").SerializedStyles;
	        dot: import("@emotion/react").SerializedStyles;
	        badge: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/header/header_section/header_section_item_button' {
	import React, { PropsWithChildren } from 'react';
	import { EuiNotificationBadgeProps } from '@elastic/eui/src/components/badge/notification_badge/badge_notification';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	export type EuiHeaderSectionItemButtonProps = PropsWithChildren & EuiButtonEmptyProps & {
	    /**
	     * Inserts the node into a EuiBadgeNotification and places it appropriately against the button.
	     * Or pass `true` to render a simple dot
	     */
	    notification?: EuiNotificationBadgeProps['children'] | boolean;
	    /**
	     * Changes the color of the notification background
	     */
	    notificationColor?: EuiNotificationBadgeProps['color'];
	};
	export type EuiHeaderSectionItemButtonRef = (HTMLButtonElement & {
	    euiAnimate: () => void;
	}) | null;
	export const EuiHeaderSectionItemButton: React.ForwardRefExoticComponent<EuiHeaderSectionItemButtonProps & React.RefAttributes<EuiHeaderSectionItemButtonRef>>;

}
declare module '@elastic/eui/src/components/header/header_section' {
	export type { EuiHeaderSectionProps } from '@elastic/eui/src/components/header/header_section/header_section';
	export { EuiHeaderSection } from '@elastic/eui/src/components/header/header_section/header_section';
	export type { EuiHeaderSectionItemProps } from '@elastic/eui/src/components/header/header_section/header_section_item';
	export { EuiHeaderSectionItem } from '@elastic/eui/src/components/header/header_section/header_section_item';
	export type { EuiHeaderSectionItemButtonProps } from '@elastic/eui/src/components/header/header_section/header_section_item_button';
	export { EuiHeaderSectionItemButton } from '@elastic/eui/src/components/header/header_section/header_section_item_button';

}
declare module '@elastic/eui/src/components/header/header' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiBreadcrumb, EuiBreadcrumbsProps } from '@elastic/eui/src/components/breadcrumbs';
	import { EuiHeaderSectionItemProps } from '@elastic/eui/src/components/header/header_section';
	type EuiHeaderSectionItemType = EuiHeaderSectionItemProps['children'];
	export interface EuiHeaderSections {
	    /**
	     * An array of items that will be wrapped in a {@link EuiHeaderSectionItem}
	     */
	    items?: EuiHeaderSectionItemType[];
	    /**
	     * Breadcrumbs in the header cannot be wrapped in a {@link EuiHeaderSection} in order for truncation to work.
	     * Simply pass the array of EuiBreadcrumb objects
	     */
	    breadcrumbs?: EuiBreadcrumb[];
	    /**
	     * Other props to pass to {@link EuiHeaderBreadcrumbs}
	     */
	    breadcrumbProps?: Omit<EuiBreadcrumbsProps, 'breadcrumbs'>;
	}
	export type EuiHeaderProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * An array of objects to wrap in a {@link EuiHeaderSection}.
	     * Each section is spaced using `space-between`.
	     * See {@link EuiHeaderSections} for object details.
	     * This prop disregards the prop `children` if both are passed.
	     */
	    sections?: EuiHeaderSections[];
	    /**
	     * Helper that positions the header against the window body and
	     * adds the correct amount of top padding to the window when in `fixed` mode
	     */
	    position?: 'static' | 'fixed';
	    /**
	     * The `default` will inherit its coloring from the light or dark theme.
	     * Or, force the header into pseudo `dark` theme for all themes.
	     */
	    theme?: 'default' | 'dark';
	};
	export const EuiHeader: FunctionComponent<EuiHeaderProps>;
	/**
	 * Fixed headers - logic around dynamically calculating the total
	 * page offset and setting the `top` position of subsequent headers
	 */
	export let euiFixedHeadersCount: number;
	export const EuiFixedHeader: FunctionComponent<EuiHeaderProps>;
	export {};

}
declare module '@elastic/eui/src/components/header/header_alert/header_alert.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderAlertStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHeaderAlert: import("@emotion/react").SerializedStyles;
	    euiHeaderAlert__title: import("@emotion/react").SerializedStyles;
	    euiHeaderAlert__text: import("@emotion/react").SerializedStyles;
	    euiHeaderAlert__action: import("@emotion/react").SerializedStyles;
	    euiHeaderAlert__date: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_alert/header_alert' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiHeaderAlertProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
	    /**
	     * Adds a link to the alert.
	     */
	    action?: ReactNode;
	    date: ReactNode;
	    text?: ReactNode;
	    title: ReactNode;
	    /**
	     * Accepts an `EuiBadge` that displays on the alert
	     */
	    badge?: ReactNode;
	};
	export const EuiHeaderAlert: FunctionComponent<EuiHeaderAlertProps>;

}
declare module '@elastic/eui/src/components/header/header_alert' {
	export type { EuiHeaderAlertProps } from '@elastic/eui/src/components/header/header_alert/header_alert';
	export { EuiHeaderAlert } from '@elastic/eui/src/components/header/header_alert/header_alert';

}
declare module '@elastic/eui/src/components/header/header_links/header_link' {
	import { FunctionComponent } from 'react';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	export type EuiHeaderLinkProps = EuiButtonEmptyProps & {
	    /**
	     * Simple prop to update color based on active state.
	     * Can be overridden with `color`
	     */
	    isActive?: boolean;
	};
	export const EuiHeaderLink: FunctionComponent<EuiHeaderLinkProps>;

}
declare module '@elastic/eui/src/components/header/header_links/header_links.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderLinksStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiHeaderLinks: import("@emotion/react").SerializedStyles;
	    euiHeaderLinks__list: import("@emotion/react").SerializedStyles;
	    gutterSizes: {
	        xxs: import("@emotion/react").SerializedStyles;
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	    euiHeaderLinks__mobileList: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_links/header_links' {
	import { ReactNode, HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	import { EuiHeaderSectionItemButtonProps } from '@elastic/eui/src/components/header/header_section';
	import { EuiBreakpointSize } from '@elastic/eui/src/services/breakpoint';
	export const GUTTER_SIZES: readonly ["xxs", "xs", "s", "m", "l"];
	type EuiHeaderLinksGutterSize = (typeof GUTTER_SIZES)[number];
	type EuiHeaderLinksPopoverButtonProps = Partial<EuiHeaderSectionItemButtonProps> & {
	    iconType?: IconType;
	};
	export type EuiHeaderLinksProps = CommonProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
	    /**
	     * Takes any rendered node(s), typically of `EuiHeaderLink`s.
	     *
	     * Optionally takes a render function that will pass a callback allowing you
	     * to close the mobile popover from within your popover content.
	     */
	    children?: ReactNode | ((closeMobilePopover: () => void) => ReactNode);
	    /**
	     * Spacing between direct children
	     */
	    gutterSize?: EuiHeaderLinksGutterSize;
	    /**
	     * A list of named breakpoints at which to show the popover version
	     */
	    popoverBreakpoints?: EuiBreakpointSize[] | 'all' | 'none';
	    /**
	     * Extend the functionality of the EuiPopover.button which is a EuiHeaderSectionItemButton.
	     * With the addition of `iconType` to change the display icon which defaults to `apps`
	     */
	    popoverButtonProps?: EuiHeaderLinksPopoverButtonProps;
	    /**
	     * Extend the functionality of the EuiPopover
	     */
	    popoverProps?: Omit<EuiPopoverProps, 'button' | 'closePopover'>;
	};
	export const EuiHeaderLinks: FunctionComponent<EuiHeaderLinksProps>;
	export {};

}
declare module '@elastic/eui/src/components/header/header_links' {
	export type { EuiHeaderLinkProps } from '@elastic/eui/src/components/header/header_links/header_link';
	export { EuiHeaderLink } from '@elastic/eui/src/components/header/header_links/header_link';
	export type { EuiHeaderLinksProps } from '@elastic/eui/src/components/header/header_links/header_links';
	export { EuiHeaderLinks } from '@elastic/eui/src/components/header/header_links/header_links';

}
declare module '@elastic/eui/src/components/header/header_logo/header_logo.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHeaderLogoStyles: (euiThemeContext: UseEuiTheme) => {
	    euiHeaderLogo: import("@emotion/react").SerializedStyles;
	    euiHeaderLogo__text: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/header/header_logo/header_logo' {
	import { FunctionComponent, AnchorHTMLAttributes, ReactNode } from 'react';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiHeaderLogoProps = CommonProps & AnchorHTMLAttributes<HTMLAnchorElement> & {
	    href?: string;
	    rel?: string;
	    target?: string;
	    iconType?: IconType;
	    iconTitle?: string;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	};
	export const EuiHeaderLogo: FunctionComponent<EuiHeaderLogoProps>;

}
declare module '@elastic/eui/src/components/header/header_logo' {
	export type { EuiHeaderLogoProps } from '@elastic/eui/src/components/header/header_logo/header_logo';
	export { EuiHeaderLogo } from '@elastic/eui/src/components/header/header_logo/header_logo';

}
declare module '@elastic/eui/src/components/header' {
	export type { EuiHeaderProps, EuiHeaderSections } from '@elastic/eui/src/components/header/header';
	export { EuiHeader } from '@elastic/eui/src/components/header/header';
	export type { EuiHeaderAlertProps } from '@elastic/eui/src/components/header/header_alert';
	export { EuiHeaderAlert } from '@elastic/eui/src/components/header/header_alert';
	export { EuiHeaderBreadcrumbs } from '@elastic/eui/src/components/header/header_breadcrumbs';
	export type { EuiHeaderLinkProps, EuiHeaderLinksProps } from '@elastic/eui/src/components/header/header_links';
	export { EuiHeaderLink, EuiHeaderLinks } from '@elastic/eui/src/components/header/header_links';
	export type { EuiHeaderLogoProps } from '@elastic/eui/src/components/header/header_logo';
	export { EuiHeaderLogo } from '@elastic/eui/src/components/header/header_logo';
	export type { EuiHeaderSectionItemButtonProps } from '@elastic/eui/src/components/header/header_section';
	export { EuiHeaderSection, EuiHeaderSectionItem, EuiHeaderSectionItemButton, } from '@elastic/eui/src/components/header/header_section';

}
declare module '@elastic/eui/src/components/health/health.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiHealthStyles: (euiTheme: UseEuiTheme) => {
	    euiHealth: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    inherit: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/health/health' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconColor } from '@elastic/eui/src/components/icon';
	export const TEXT_SIZES: readonly ["xs", "s", "m", "inherit"];
	export type EuiHealthProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'color'> & {
	    /**
	     * Sets the color of the dot icon.
	     * It accepts any `IconColor`: `default`, `primary`, `success`, `accent`, `warning`, `danger`, `text`,
	     * `subdued` or `ghost`; or any valid CSS color value as a `string`
	     */
	    color?: IconColor;
	    /**
	     * Matches the text scales of EuiText.
	     * The `inherit` style will get its font size from the parent element
	     */
	    textSize?: (typeof TEXT_SIZES)[number];
	};
	export const EuiHealth: FunctionComponent<EuiHealthProps>;

}
declare module '@elastic/eui/src/components/health' {
	export type { EuiHealthProps } from '@elastic/eui/src/components/health/health';
	export { EuiHealth } from '@elastic/eui/src/components/health/health';

}
declare module '@elastic/eui/src/components/image/image_types' {
	import { HTMLAttributes, ReactNode, ImgHTMLAttributes, PropsWithChildren } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	export const SIZES: readonly ["s", "m", "l", "xl", "fullWidth", "original"];
	export type EuiImageSize = (typeof SIZES)[number]; const FLOATS: readonly ["left", "right"];
	export type EuiImageWrapperFloat = (typeof FLOATS)[number]; const MARGINS: readonly ["s", "m", "l", "xl"];
	export type EuiImageWrapperMargin = (typeof MARGINS)[number];
	export type EuiImageButtonIconColor = 'light' | 'dark';
	type _EuiImageSrcOrUrl = ExclusiveUnion<{
	    /**
	     * Requires either `src` or `url` but defaults to using `src` if both are provided
	     */
	    src: string;
	}, {
	    url: string;
	}>;
	export type EuiImageProps = CommonProps & Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'alt'> & _EuiImageSrcOrUrl & {
	    /**
	     * Alt text should describe the image to aid screen reader users. See
	     * https://webaim.org/techniques/alttext/ for a guide on writing
	     * effective alt text.
	     *
	     * If no meaningful description exists, or if the image is adequately
	     * described by the surrounding text, pass an empty string.
	     */
	    alt: string;
	    /**
	     * Provides a visible caption to the image
	     */
	    caption?: ReactNode;
	    /**
	     * Accepts `s` / `m` / `l` / `xl` / `original` / `fullWidth` / or a CSS size of `number` or `string`.
	     * `fullWidth` will set the figure to stretch to 100% of its container.
	     * `string` and `number` types will max both the width or height, whichever is greater.
	     */
	    size?: EuiImageSize | number | string;
	    /**
	     * Float the image to the left or right. Useful in large text blocks.
	     */
	    float?: EuiImageWrapperFloat;
	    /**
	     * Margin around the image.
	     */
	    margin?: EuiImageWrapperMargin;
	    /**
	     * When set to `true` (default) will apply a slight shadow to the image
	     */
	    hasShadow?: boolean;
	    /**
	     * When set to `true` will make the image clickable to a larger version
	     */
	    allowFullScreen?: boolean;
	    /**
	     * Callback when the image is clicked and `allowFullScreen` is `true`
	     */
	    onFullScreen?: (isFullScreen: boolean) => void;
	    /**
	     * Changes the color of the icon that floats above the image when it can be clicked to fullscreen.
	     * The default value of `light` is fine unless your image has a white background, in which case you should change it to `dark`.
	     */
	    fullScreenIconColor?: EuiImageButtonIconColor;
	    /**
	     * Props to add to the wrapping figure element
	     */
	    wrapperProps?: CommonProps & HTMLAttributes<HTMLDivElement>;
	};
	export type EuiImageWrapperProps = PropsWithChildren & Pick<EuiImageProps, 'alt' | 'caption' | 'float' | 'margin' | 'hasShadow' | 'wrapperProps' | 'fullScreenIconColor' | 'allowFullScreen' | 'onFullScreen'> & {
	    isFullWidth: boolean;
	    setIsFullScreen: (isFullScreen: boolean) => void;
	};
	export type EuiImageButtonProps = PropsWithChildren & Pick<EuiImageProps, 'hasShadow' | 'fullScreenIconColor'> & {
	    hasAlt: boolean;
	    onClick: () => void;
	    onKeyDown?: (e: React.KeyboardEvent) => void;
	    isFullWidth: boolean;
	    isFullScreen?: boolean;
	};
	export type EuiImageCaptionProps = Pick<EuiImageProps, 'caption'> & {
	    isOnOverlayMask?: boolean;
	};
	export {};

}
declare module '@elastic/eui/src/components/image/image_wrapper.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiImageWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiImageWrapper: import("@emotion/react").SerializedStyles;
	    allowFullScreen: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/image/image_button.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiImageButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiImageButton: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    shadowHover: import("@emotion/react").SerializedStyles;
	    hasShadowHover: import("@emotion/react").SerializedStyles;
	};
	export const euiImageButtonIconStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiImageButton__icon: import("@emotion/react").SerializedStyles;
	    openFullScreen: import("@emotion/react").SerializedStyles;
	    closeFullScreen: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/image/image_button' {
	import { FunctionComponent } from 'react';
	import type { EuiImageButtonProps } from '@elastic/eui/src/components/image/image_types';
	export const EuiImageButton: FunctionComponent<EuiImageButtonProps>;

}
declare module '@elastic/eui/src/components/image/image_caption.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiImageCaptionStyles: (euiThemeContext: UseEuiTheme) => {
	    euiImageCaption: import("@emotion/react").SerializedStyles;
	    isOnOverlayMask: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/image/image_caption' {
	import React from 'react';
	export const EuiImageCaption: React.ForwardRefExoticComponent<Pick<import ("@elastic/eui/src/components/image/image_types").EuiImageProps, "caption"> & {
	    isOnOverlayMask?: boolean;
	} & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/image/image_wrapper' {
	import { FunctionComponent } from 'react';
	import type { EuiImageWrapperProps } from '@elastic/eui/src/components/image/image_types';
	export const EuiImageWrapper: FunctionComponent<EuiImageWrapperProps>;

}
declare module '@elastic/eui/src/components/image/image.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiImageStyles: (euiThemeContext: UseEuiTheme) => {
	    euiImage: import("@emotion/react").SerializedStyles;
	    isFullScreen: import("@emotion/react").SerializedStyles;
	    hasShadow: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	    original: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	    customSize: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/image/image_fullscreen_wrapper.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiImageFullscreenWrapperStyles: (euiThemeContext: UseEuiTheme) => {
	    euiImageFullscreenWrapper: import("@emotion/react").SerializedStyles;
	    fullWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/image/image_fullscreen_wrapper' {
	import { FunctionComponent } from 'react';
	import type { EuiImageWrapperProps } from '@elastic/eui/src/components/image/image_types';
	export const EuiImageFullScreenWrapper: FunctionComponent<EuiImageWrapperProps>;

}
declare module '@elastic/eui/src/components/image/image' {
	import { FunctionComponent } from 'react';
	import type { EuiImageProps } from '@elastic/eui/src/components/image/image_types';
	export const EuiImage: FunctionComponent<EuiImageProps>;

}
declare module '@elastic/eui/src/components/image' {
	export type { EuiImageProps } from '@elastic/eui/src/components/image/image_types';
	export { EuiImage } from '@elastic/eui/src/components/image/image';

}
declare module '@elastic/eui/src/components/skeleton/skeleton_loading' {
	import { FunctionComponent, HTMLAttributes, ReactElement } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiScreenReaderLiveProps } from '@elastic/eui/src/components/accessibility/screen_reader_live';
	export type _EuiSkeletonAriaProps = {
	    /**
	     * When true, shows the loading skeleton component.
	     * When false, shows any `children` and announces to screen readers that your content has loaded.
	     */
	    isLoading?: boolean;
	    /**
	     * Label your loading sections to provide more helpful context to screen readers.
	     * For example, pass "API keys" to have screen readers read "Loading API keys" and "Loaded API keys".
	     */
	    contentAriaLabel?: string;
	    /**
	     * Makes a live screen reader announcement when `isLoading` is true
	     * @default false
	     */
	    announceLoadingStatus?: boolean;
	    /**
	     * Makes a live screen reader announcement when `isLoading` is false
	     * @default true
	     */
	    announceLoadedStatus?: boolean;
	    /**
	     * Optional props to pass to the `aria-live` region that announces the loading status to screen readers.
	     * Accepts any `EuiScreenReaderLive` props.
	     */
	    ariaLiveProps?: Partial<EuiScreenReaderLiveProps>;
	    /**
	     * Optional props to pass to the `aria-busy` wrapper around the skeleton content
	     */
	    ariaWrapperProps?: HTMLAttributes<HTMLDivElement>;
	};
	export type EuiSkeletonLoadingProps = CommonProps & _EuiSkeletonAriaProps['ariaWrapperProps'] & Omit<_EuiSkeletonAriaProps, 'ariaWrapperProps'> & {
	    /**
	     * Content to display when loading
	     */
	    loadingContent: ReactElement;
	    /**
	     * Content to display when loaded
	     */
	    loadedContent: any;
	};
	export const EuiSkeletonLoading: FunctionComponent<EuiSkeletonLoadingProps>;

}
declare module '@elastic/eui/src/components/skeleton/utils' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	type AnimationOptions = {
	    slideSize?: string;
	    gradientSize?: string;
	};
	export const euiSkeletonGradientAnimation: ({ euiTheme, highContrastMode }: UseEuiTheme, { slideSize, gradientSize }?: AnimationOptions) => import("@emotion/react").SerializedStyles;
	export {};

}
declare module '@elastic/eui/src/components/skeleton/skeleton_circle.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSkeletonCircleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSkeletonCircle: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    xl: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/skeleton/skeleton_circle' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiSkeletonAriaProps } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export const SIZES: readonly ["s", "m", "l", "xl"];
	export type SkeletonCircleSize = (typeof SIZES)[number];
	export type EuiSkeletonCircleProps = HTMLAttributes<HTMLDivElement> & CommonProps & _EuiSkeletonAriaProps & {
	    size?: SkeletonCircleSize;
	};
	export const EuiSkeletonCircle: FunctionComponent<EuiSkeletonCircleProps>;

}
declare module '@elastic/eui/src/components/skeleton/skeleton_text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSkeletonTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSkeletonText: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    relative: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/skeleton/skeleton_text' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { TextSize } from '@elastic/eui/src/components/text/text';
	import { _EuiSkeletonAriaProps } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export const LINES: readonly [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
	export type LineRange = (typeof LINES)[number];
	export type EuiSkeletonTextProps = CommonProps & HTMLAttributes<HTMLDivElement> & _EuiSkeletonAriaProps & {
	    /**
	     * Number of lines to display (between 1 to 10)
	     */
	    lines?: LineRange;
	    /**
	     * EuiText size to render
	     */
	    size?: TextSize;
	};
	export const EuiSkeletonText: FunctionComponent<EuiSkeletonTextProps>;

}
declare module '@elastic/eui/src/components/skeleton/skeleton_rectangle.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSkeletonRectangleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSkeletonRectangle: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/skeleton/skeleton_rectangle' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiSkeletonAriaProps } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export const RADIUS: readonly ["s", "m", "none"];
	export type SkeletonRectangleBorderRadius = (typeof RADIUS)[number];
	export type EuiSkeletonRectangleProps = HTMLAttributes<HTMLDivElement> & CommonProps & _EuiSkeletonAriaProps & {
	    width?: string | number;
	    height?: string | number;
	    borderRadius?: SkeletonRectangleBorderRadius;
	};
	export const EuiSkeletonRectangle: FunctionComponent<EuiSkeletonRectangleProps>;

}
declare module '@elastic/eui/src/components/skeleton/skeleton_title.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSkeletonTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSkeletonTitle: import("@emotion/react").SerializedStyles;
	    l: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    xxs: import("@emotion/react").SerializedStyles;
	    xxxs: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/skeleton/skeleton_title' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTitleSize } from '@elastic/eui/src/components/title';
	import { _EuiSkeletonAriaProps } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export type EuiSkeletonTitleProps = HTMLAttributes<HTMLDivElement> & CommonProps & _EuiSkeletonAriaProps & {
	    /**
	     * EuiTitle size to render
	     */
	    size?: EuiTitleSize;
	};
	export const EuiSkeletonTitle: FunctionComponent<EuiSkeletonTitleProps>;

}
declare module '@elastic/eui/src/components/skeleton' {
	export type { EuiSkeletonLoadingProps } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export { EuiSkeletonLoading } from '@elastic/eui/src/components/skeleton/skeleton_loading';
	export type { EuiSkeletonCircleProps } from '@elastic/eui/src/components/skeleton/skeleton_circle';
	export { EuiSkeletonCircle } from '@elastic/eui/src/components/skeleton/skeleton_circle';
	export type { EuiSkeletonTextProps } from '@elastic/eui/src/components/skeleton/skeleton_text';
	export { EuiSkeletonText } from '@elastic/eui/src/components/skeleton/skeleton_text';
	export type { EuiSkeletonRectangleProps } from '@elastic/eui/src/components/skeleton/skeleton_rectangle';
	export { EuiSkeletonRectangle } from '@elastic/eui/src/components/skeleton/skeleton_rectangle';
	export type { EuiSkeletonTitleProps } from '@elastic/eui/src/components/skeleton/skeleton_title';
	export { EuiSkeletonTitle } from '@elastic/eui/src/components/skeleton/skeleton_title';

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_form.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiInlineEditReadModeStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiInlineEditReadMode: import("@emotion/react").SerializedStyles;
	    isReadOnly: import("@emotion/react").SerializedStyles;
	    hasPlaceholder: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_form' {
	import React, { ReactNode, FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiFormRowProps, EuiFieldTextProps } from '@elastic/eui/src/components/form';
	import { EuiButtonIconPropsForButton } from '@elastic/eui/src/components/button/button_icon';
	import { EuiButtonEmptyPropsForButton } from '@elastic/eui/src/components/button/button_empty/button_empty';
	export type EuiInlineEditCommonProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & CommonProps & {
	    placeholder?: string;
	    /**
	     * Callback that fires when a user clicks the save button.
	     * Passes the current edited text value as an argument.
	     *
	     * To validate the value of the edited text, pass back a boolean flag.
	     * If `false`, EuiInlineEdit will remain in edit mode, where loading or invalid states can be set.
	     * If `true`, EuiInlineEdit will return to read mode.
	     */
	    onSave?: (value: string) => void | boolean | Promise<boolean | void>;
	    /**
	     * Form label that appears above the form control.
	     * This is required for accessibility because there is no visual label on the input.
	     */
	    inputAriaLabel: string;
	    /**
	     * Starts the component in edit mode
	     */
	    startWithEditOpen?: boolean;
	    /**
	     * Props that will be applied directly to the `EuiEmptyButton` displayed in read mode
	     */
	    readModeProps?: Partial<EuiButtonEmptyPropsForButton>;
	    /**
	     * Multiple props objects that can be applied directly to various child components displayed in edit mode.
	     * - `formRowProps` will be passed to `EuiFormRow`
	     * - `inputProps` will be passed to `EuiFieldText`
	     * - `saveButtonProps` & `cancelButtonProps` will be passed to their respective `EuiButtonIcon`s
	     */
	    editModeProps?: {
	        formRowProps?: Partial<EuiFormRowProps>;
	        inputProps?: Partial<EuiFieldTextProps>;
	        saveButtonProps?: Partial<EuiButtonIconPropsForButton>;
	        cancelButtonProps?: Partial<EuiButtonIconPropsForButton>;
	    };
	    /**
	     * Loading state - only displayed in edit mode
	     */
	    isLoading?: boolean;
	    /**
	     * Invalid state - only displayed edit mode
	     */
	    isInvalid?: boolean;
	    /**
	     * Locks inline edit in read mode and displays the text value
	     */
	    isReadOnly?: boolean;
	} & ExclusiveUnion<{
	    /**
	     * Initial inline edit text value
	     */
	    defaultValue: string;
	    onCancel?: (previousValue: string) => void;
	}, {
	    /**
	     * To use inline edit as a controlled component, continuously pass the value via this prop
	     */
	    value: string;
	    /**
	     * Callback required to receive and update `value` based on user input
	     */
	    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
	    /**
	     * Callback required to reset `value` to the previous read mode text value.
	     */
	    onCancel: (previousValue: string) => void;
	}>;
	export type EuiInlineEditFormProps = EuiInlineEditCommonProps & {
	    /**
	     * Form sizes
	     */
	    sizes: {
	        compressed: boolean;
	        buttonSize: EuiButtonEmptyPropsForButton['size'];
	        iconSize: EuiButtonEmptyPropsForButton['iconSize'];
	    };
	    /**
	     * Render prop that returns the read mode value as an arg
	     */
	    children: (readModeValue: ReactNode) => ReactNode;
	};
	export const SMALL_SIZE_FORM: {
	    readonly iconSize: "s";
	    readonly compressed: true;
	    readonly buttonSize: "s";
	};
	export const MEDIUM_SIZE_FORM: {
	    readonly iconSize: "m";
	    readonly compressed: false;
	    readonly buttonSize: "m";
	};
	export const EuiInlineEditForm: FunctionComponent<EuiInlineEditFormProps>;

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_text.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiInlineEditTextStyles: (euiThemeContext: UseEuiTheme) => {
	    euiInlineEditText: import("@emotion/react").SerializedStyles;
	    fontSize: {
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_text' {
	import { FunctionComponent } from 'react';
	import { EuiTextProps } from '@elastic/eui/src/components/text';
	import { EuiInlineEditCommonProps } from '@elastic/eui/src/components/inline_edit/inline_edit_form';
	export type EuiInlineEditTextSizes = Exclude<EuiTextProps['size'], 'relative'>;
	export type EuiInlineEditTextProps = EuiInlineEditCommonProps & {
	    /**
	     * Text size level
	     */
	    size?: EuiInlineEditTextSizes;
	};
	export const EuiInlineEditText: FunctionComponent<EuiInlineEditTextProps>;

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_title.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiInlineEditTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiInlineEditTitle: import("@emotion/react").SerializedStyles;
	    fontSize: {
	        xxxs: import("@emotion/react").SerializedStyles;
	        xxs: import("@emotion/react").SerializedStyles;
	        xs: import("@emotion/react").SerializedStyles;
	        s: import("@emotion/react").SerializedStyles;
	        m: import("@emotion/react").SerializedStyles;
	        l: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/inline_edit/inline_edit_title' {
	import { FunctionComponent } from 'react';
	import { EuiTitleSize } from '@elastic/eui/src/components/title';
	import { EuiInlineEditCommonProps } from '@elastic/eui/src/components/inline_edit/inline_edit_form';
	export const HEADINGS: readonly ["h1", "h2", "h3", "h4", "h5", "h6", "span"];
	type Heading = (typeof HEADINGS)[number];
	export type EuiInlineEditTitleProps = EuiInlineEditCommonProps & {
	    /**
	     * Title size level
	     */
	    size?: EuiTitleSize;
	    /**
	     * Level of heading to be used for the title.
	     * Use `span` for text that is not semantically a heading, but should still visually appear as a title.
	     */
	    heading: Heading;
	};
	export const EuiInlineEditTitle: FunctionComponent<EuiInlineEditTitleProps>;
	export {};

}
declare module '@elastic/eui/src/components/inline_edit' {
	export { EuiInlineEditText } from '@elastic/eui/src/components/inline_edit/inline_edit_text';
	export type { EuiInlineEditTextProps } from '@elastic/eui/src/components/inline_edit/inline_edit_text';
	export { EuiInlineEditTitle } from '@elastic/eui/src/components/inline_edit/inline_edit_title';
	export type { EuiInlineEditTitleProps } from '@elastic/eui/src/components/inline_edit/inline_edit_title';

}
declare module '@elastic/eui/src/components/key_pad_menu/key_pad_menu.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiKeyPadMenuVariables: ({ euiTheme }: UseEuiTheme) => {
	    euiKeyPadMenuSize: string;
	    euiKeyPadMenuMarginSize: string;
	};
	export const euiKeyPadMenuStyles: (euiThemeContext: UseEuiTheme) => {
	    euiKeyPadMenu: import("@emotion/react").SerializedStyles;
	    euiKeyPadMenu__legend: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/key_pad_menu/key_pad_menu' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { _EuiFormLegendProps } from '@elastic/eui/src/components/form/form_label/form_label';
	export type _EuiKeyPadMenuCheckableProps = ExclusiveUnion<{
	    /**
	     * Rendered within a `legend` to label the `fieldset`.
	     * To create a visually hidden legend, use `ariaLegend`
	     */
	    legend: ReactNode;
	    /**
	     * Pass through props to a `EuiFormLabel` component, except for `type`
	     */
	    legendProps?: Omit<_EuiFormLegendProps, 'type'>;
	}, {
	    /**
	     * Custom aria-attribute for creating a *visually hidden* legend.
	     * To create a visible legend, use `legend`
	     */
	    ariaLegend: string;
	}>;
	export type EuiKeyPadMenuProps = CommonProps & HTMLAttributes<HTMLElement> & {
	    /**
	     * Renders the the group as a `fieldset`.
	     * Set to `true` to customize the labelling, or pass an {@link _EuiKeyPadMenuCheckableProps} object to add a `legend` or `ariaLegend`
	     */
	    checkable?: _EuiKeyPadMenuCheckableProps | true;
	};
	export const EuiKeyPadMenu: FunctionComponent<EuiKeyPadMenuProps>;

}
declare module '@elastic/eui/src/components/key_pad_menu/key_pad_menu_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiKeyPadMenuItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiKeyPadMenuItem: import("@emotion/react").SerializedStyles;
	    enabled: import("@emotion/react").SerializedStyles;
	    selected: import("@emotion/react").SerializedStyles;
	    disabled: {
	        disabled: import("@emotion/react").SerializedStyles;
	        selected: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiKeyPadMenuItemChildStyles: (euiThemeContext: UseEuiTheme) => {
	    euiKeyPadMenuItem__inner: import("@emotion/react").SerializedStyles;
	    euiKeyPadMenuItem__icon: import("@emotion/react").SerializedStyles;
	    euiKeyPadMenuItem__label: import("@emotion/react").SerializedStyles;
	    euiKeyPadMenuItem__betaBadge: import("@emotion/react").SerializedStyles;
	    euiKeyPadMenuItem__checkableInput: import("@emotion/react").SerializedStyles;
	    showCheckableInputOnInteraction: import("@emotion/react").SerializedStyles;
	    hideCheckableInput: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/key_pad_menu/key_pad_menu_item' {
	import { FunctionComponent, ReactNode, Ref, LabelHTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion, PropsForAnchor, PropsForButton } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export type EuiKeyPadMenuItemCheckableType = 'single' | 'multi';
	export type EuiKeyPadMenuItemCommonProps = {
	    /**
	     * One will be generated if not provided
	     */
	    id?: string;
	    /**
	     * Pass an EuiIcon, preferrably `size="l"`
	     */
	    children: ReactNode;
	    isDisabled?: boolean;
	    /**
	     * Indicate if an item is the current one.
	     * Be sure to use `true` AND `false` when acting as a toggle to ensure the attribute is added for both states
	     */
	    isSelected?: boolean;
	    /**
	     * The text to display beneath the icon
	     */
	    label: ReactNode;
	};
	type EuiKeyPadMenuItemPropsForUncheckable = {
	    /**
	     * Beta badges are unavailable if the item is checkable
	     */
	    checkable?: undefined;
	    /**
	     * Add a badge to the card to label it as "Beta" or other non-GA state
	     */
	    betaBadgeLabel?: string;
	    /**
	     * Supply an icon type if the badge should just be an icon
	     */
	    betaBadgeIconType?: IconType;
	    /**
	     * Add a description to the beta badge (will appear in a tooltip)
	     */
	    betaBadgeTooltipContent?: ReactNode;
	    /**
	     * Extends the wrapping EuiToolTip props when `betaBadgeLabel` is provided
	     */
	    betaBadgeTooltipProps?: Partial<Omit<EuiToolTipProps, 'title' | 'content'>>;
	    /**
	     * Use `onClick` instead when the item is not `checkable`
	     */
	    onChange?: never;
	};
	type EuiKeyPadMenuItemPropsForAnchor = PropsForAnchor<EuiKeyPadMenuItemCommonProps, {
	    buttonRef?: Ref<HTMLAnchorElement>;
	    rel?: string;
	} & EuiKeyPadMenuItemPropsForUncheckable>;
	type EuiKeyPadMenuItemPropsForButton = PropsForButton<EuiKeyPadMenuItemCommonProps, {
	    buttonRef?: Ref<HTMLButtonElement>;
	} & EuiKeyPadMenuItemPropsForUncheckable>;
	type EuiKeyPadMenuItemPropsForCheckable = Omit<LabelHTMLAttributes<HTMLLabelElement>, 'onChange'> & EuiKeyPadMenuItemCommonProps & {
	    /**
	     * Use `onChange` instead when the item is `checkable`
	     */
	    onClick?: never;
	} & ExclusiveUnion<{
	    /**
	     * Type `'single'` renders the item as a `<label>` and
	     * adds a radio element.
	     */
	    checkable: 'single';
	    /**
	     * The `name` attribute for radio inputs;
	     * Required in order to group properly
	     */
	    name: string;
	    /**
	     * The value of the radio input for 'single'
	     */
	    value?: string;
	    /**
	     * Single: Returns the `id` of the clicked option and the `value`
	     */
	    onChange: (id: string, value?: any) => void;
	}, {
	    /**
	     * Type `'multi'` renders the item as a `<label>` and
	     * adds a checkbox.
	     */
	    checkable: 'multi';
	    /**
	     * Multi: Returns the `id` of the clicked option
	     */
	    onChange: (id: string) => void;
	}>;
	export type EuiKeyPadMenuItemProps = CommonProps & ExclusiveUnion<EuiKeyPadMenuItemPropsForCheckable, ExclusiveUnion<EuiKeyPadMenuItemPropsForAnchor, EuiKeyPadMenuItemPropsForButton>>;
	export const EuiKeyPadMenuItem: FunctionComponent<EuiKeyPadMenuItemProps>;
	export {};

}
declare module '@elastic/eui/src/components/key_pad_menu' {
	export type { EuiKeyPadMenuProps } from '@elastic/eui/src/components/key_pad_menu/key_pad_menu';
	export { EuiKeyPadMenu } from '@elastic/eui/src/components/key_pad_menu/key_pad_menu';
	export type { EuiKeyPadMenuItemProps } from '@elastic/eui/src/components/key_pad_menu/key_pad_menu_item';
	export { EuiKeyPadMenuItem } from '@elastic/eui/src/components/key_pad_menu/key_pad_menu_item';

}
declare module '@elastic/eui/src/components/modal/modal.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiModalStyles: (euiThemeContext: UseEuiTheme) => {
	    euiModal: import("@emotion/react").SerializedStyles;
	    defaultMaxWidth: import("@emotion/react").SerializedStyles;
	    confirmation: import("@emotion/react").SerializedStyles;
	    euiModal__closeIcon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/modal/modal' {
	import React, { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
	import { EuiFocusTrapProps } from '@elastic/eui/src/components/focus_trap';
	export interface EuiModalProps extends HTMLAttributes<HTMLDivElement> {
	    className?: string;
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    onClose: (event?: React.KeyboardEvent<HTMLDivElement> | React.MouseEvent<HTMLButtonElement> | MouseEvent | TouchEvent) => void;
	    /**
	     * Sets the max-width of the modal.
	     * Set to `true` to use the default (`euiBreakpoints 'm'`),
	     * set to `false` to not restrict the width,
	     * set to a number for a custom width in px,
	     * set to a string for a custom width in custom measurement.
	     */
	    maxWidth?: boolean | number | string;
	    /**
	     * Specifies what element should initially have focus.
	     * Can be a DOM node, or a selector string (which will be passed to document.querySelector() to find the DOM node), or a function that returns a DOM node.
	     */
	    initialFocus?: HTMLElement | (() => HTMLElement) | string;
	    /**
	     * Identifies a modal dialog to screen readers. Modal dialogs that confirm destructive actions
	     * or need a user's attention should use "alertdialog".
	     */
	    role?: 'dialog' | 'alertdialog';
	    /**
	     * Object of props passed to EuiFocusTrap.
	     * `returnFocus` defines the return focus behavior and provides the possibility to check the available target element or opt out of the behavior in favor of manually returning focus
	     */
	    focusTrapProps?: Pick<EuiFocusTrapProps, 'returnFocus'>;
	    /**
	     * Whether clicking outside the modal should close it.
	     * @default false
	     */
	    outsideClickCloses?: boolean;
	}
	export const EuiModal: FunctionComponent<EuiModalProps>;

}
declare module '@elastic/eui/src/components/modal/modal_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiModalFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiModalFooter: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/modal/modal_footer' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiModalFooterProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps>;
	export const EuiModalFooter: EuiModalFooterProps;

}
declare module '@elastic/eui/src/components/modal/modal_header.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiModalHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiModalHeader: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/modal/modal_header' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiModalHeaderProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps>;
	export const EuiModalHeader: EuiModalHeaderProps;

}
declare module '@elastic/eui/src/components/modal/modal_header_title' {
	import { FunctionComponent, HTMLAttributes, ElementType } from 'react';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	export type EuiModalHeaderTitleProps = FunctionComponent<Omit<EuiTitleProps, 'children'> & HTMLAttributes<HTMLHeadingElement> & {
	    /**
	     * The tag to render. Can be changed to a lower heading
	     * level like `h2` or a container `div`.
	     * @default h1
	     */
	    component?: ElementType;
	}>;
	export const EuiModalHeaderTitle: EuiModalHeaderTitleProps;

}
declare module '@elastic/eui/src/components/modal/modal_body.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiModalBodyStyles: (euiThemeContext: UseEuiTheme) => {
	    euiModalBody: import("@emotion/react").SerializedStyles;
	    euiModalBody__overflow: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/modal/modal_body' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiModalBodyProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps>;
	export const EuiModalBody: EuiModalBodyProps;

}
declare module '@elastic/eui/src/components/modal/confirm_modal' {
	import React, { FunctionComponent, ComponentProps, ReactNode } from 'react';
	import { EuiModalProps } from '@elastic/eui/src/components/modal/modal';
	import { EuiModalHeaderTitleProps } from '@elastic/eui/src/components/modal/modal_header_title';
	import { EuiButtonColor } from '@elastic/eui/src/components/button';
	export interface EuiConfirmModalProps extends Omit<EuiModalProps, 'children' | 'onClose' | 'title'> {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children?: ReactNode;
	    title?: ReactNode;
	    titleProps?: ComponentProps<EuiModalHeaderTitleProps>;
	    cancelButtonText?: ReactNode;
	    confirmButtonText?: ReactNode;
	    onCancel: (event?: React.KeyboardEvent<HTMLDivElement> | React.MouseEvent<HTMLButtonElement> | MouseEvent | TouchEvent) => void;
	    onConfirm?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
	    confirmButtonDisabled?: boolean;
	    className?: string;
	    /**
	     * Allows focusing either the confirm or cancel button on modal initialization.
	     * Will take precedence over `initialFocus`, if `initialFocus` is passed.
	     */
	    defaultFocusedButton?: typeof CONFIRM_BUTTON | typeof CANCEL_BUTTON;
	    buttonColor?: EuiButtonColor;
	    /**
	     * Sets the max-width of the modal.
	     * Set to `true` to use the default (`euiBreakpoints 'm'`),
	     * set to `false` to not restrict the width,
	     * set to a number for a custom width in px,
	     * set to a string for a custom width in custom measurement.
	     */
	    maxWidth?: boolean | number | string;
	    /**
	     * Passes `isLoading` prop to the confirm button
	     */
	    isLoading?: boolean;
	}
	export const CONFIRM_BUTTON = "confirm";
	export const CANCEL_BUTTON = "cancel";
	export const EuiConfirmModal: FunctionComponent<EuiConfirmModalProps>;

}
declare module '@elastic/eui/src/components/modal' {
	export type { EuiConfirmModalProps } from '@elastic/eui/src/components/modal/confirm_modal';
	export { EuiConfirmModal, CONFIRM_BUTTON as EUI_MODAL_CONFIRM_BUTTON, CANCEL_BUTTON as EUI_MODAL_CANCEL_BUTTON, } from '@elastic/eui/src/components/modal/confirm_modal';
	export type { EuiModalProps } from '@elastic/eui/src/components/modal/modal';
	export { EuiModal } from '@elastic/eui/src/components/modal/modal';
	export type { EuiModalFooterProps } from '@elastic/eui/src/components/modal/modal_footer';
	export { EuiModalFooter } from '@elastic/eui/src/components/modal/modal_footer';
	export type { EuiModalHeaderProps } from '@elastic/eui/src/components/modal/modal_header';
	export { EuiModalHeader } from '@elastic/eui/src/components/modal/modal_header';
	export type { EuiModalBodyProps } from '@elastic/eui/src/components/modal/modal_body';
	export { EuiModalBody } from '@elastic/eui/src/components/modal/modal_body';
	export type { EuiModalHeaderTitleProps } from '@elastic/eui/src/components/modal/modal_header_title';
	export { EuiModalHeaderTitle } from '@elastic/eui/src/components/modal/modal_header_title';

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_types' {
	import { ComponentType, ReactNode } from 'react';
	import { VFile } from 'vfile';
	import { Node as UnistNode, Position as UnistPosition } from 'unist';
	import { Parser } from 'remark-parse-no-trim';
	import { VFileMessage } from 'vfile-message';
	import { IconType } from '@elastic/eui/src/components/icon';
	export interface RemarkParser {
	    Parser: typeof Parser;
	    tokenizeInline: Function;
	    file: VFile;
	}
	export interface RemarkTokenizer {
	    (this: RemarkParser, eat: Function & {
	        now: Function;
	    }, value: string, silent: boolean): boolean | void;
	    locator?: (value: string, fromIndex: number) => number;
	    notInLink?: boolean;
	}
	interface RehypeNode {
	}
	interface RemarkRehypeHandlerCallback {
	    (node: UnistPosition, tagName: string, props: Object, children: RehypeNode[]): RehypeNode;
	}
	export interface RemarkRehypeHandler {
	    (h: RemarkRehypeHandlerCallback, node: UnistNode): RehypeNode;
	}
	export interface EuiMarkdownEditorUiPluginEditorProps<NodeShape> {
	    node: NodeShape | null;
	    onCancel: () => void;
	    onSave: (markdown: string, config: EuiMarkdownStringTagConfig) => void;
	}
	export const isPluginWithImmediateFormatting: (x: PluginWithImmediateFormatting | PluginWithDelayedFormatting<any>) => x is PluginWithImmediateFormatting;
	export interface PluginWithImmediateFormatting {
	    formatting: EuiMarkdownFormatting;
	    editor?: never;
	}
	export interface PluginWithDelayedFormatting<NodeShape> {
	    formatting?: never;
	    editor: ComponentType<EuiMarkdownEditorUiPluginEditorProps<NodeShape>>;
	}
	export type EuiMarkdownEditorUiPlugin<NodeShape = any> = {
	    name: string;
	    button?: {
	        label: string;
	        iconType: IconType;
	        isDisabled?: boolean;
	    };
	    helpText?: ReactNode;
	} & (PluginWithImmediateFormatting | PluginWithDelayedFormatting<NodeShape>);
	export interface EuiMarkdownFormatting {
	    prefix?: string;
	    suffix?: string;
	    blockPrefix?: string;
	    blockSuffix?: string;
	    multiline?: boolean;
	    replaceNext?: string;
	    prefixSpace?: boolean;
	    scanFor?: string;
	    surroundWithNewlines?: boolean;
	    orderedList?: boolean;
	    trimFirst?: boolean;
	}
	export interface EuiMarkdownAstNode {
	    type: string;
	    children?: EuiMarkdownAstNode[];
	    position?: EuiMarkdownAstNodePosition;
	}
	export interface EuiMarkdownAstNodePosition {
	    start: {
	        line: number;
	        column: number;
	        offset: number;
	    };
	    end: {
	        line: number;
	        column: number;
	        offset: number;
	    };
	}
	export type EuiMarkdownParseError = string | VFileMessage | Error;
	export interface EuiMarkdownDropHandler {
	    supportedFiles: string[];
	    accepts: (itemType: string) => boolean;
	    getFormattingForItem: (file: File) => EuiMarkdownDragAndDropResult | Promise<EuiMarkdownDragAndDropResult>;
	}
	export interface EuiMarkdownStringTagConfig {
	    block: boolean;
	}
	export interface EuiMarkdownDragAndDropResult {
	    text: string;
	    config: EuiMarkdownStringTagConfig;
	}
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_actions' {
	import { EuiMarkdownEditorUiPlugin, EuiMarkdownFormatting } from '@elastic/eui/src/components/markdown_editor/markdown_types'; class MarkdownActions {
	    editorID: string;
	    styles: Record<string, EuiMarkdownEditorUiPlugin>;
	    constructor(editorID: string, uiPlugins: EuiMarkdownEditorUiPlugin[]);
	    /**
	     * .do() accepts a string and retrieves the correlating style object (defined in the
	     * constructor). It passes this to applyStyle() that does the text manipulation.
	     *
	     * @param {string} pluginName
	     * @memberof MarkdownActions
	     */
	    do(pluginName: string): true | EuiMarkdownEditorUiPlugin;
	    /**
	     * Sets the default styling object and then superimposes the changes to make on top of
	     * it. Calls the `styleSelectedText` helper function that does the heavy lifting.
	     * Adapted from https://github.com/github/markdown-toolbar-element/blob/main/src/index.ts
	     *
	     * @param {object} incomingStyle
	     * @memberof MarkdownActions
	     */
	    applyStyle(incomingStyle: EuiMarkdownFormatting): void;
	}
	interface SelectionRange {
	    text: string;
	    selectionStart?: number;
	    selectionEnd?: number;
	}
	export function insertText(textarea: HTMLTextAreaElement, { text, selectionStart, selectionEnd }: SelectionRange): void;
	export default MarkdownActions;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_modes' {
	export const MODE_EDITING: "editing";
	export const MODE_VIEWING: "viewing";
	export type MARKDOWN_MODE = typeof MODE_EDITING | typeof MODE_VIEWING;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_context' {
	import { EuiMarkdownEditorUiPlugin } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	interface MarkdownPosition {
	    start: {
	        line: number;
	        column: number;
	        offset: number;
	    };
	    end: {
	        line: number;
	        column: number;
	        offset: number;
	    };
	}
	export interface ContextShape {
	    openPluginEditor: (plugin: EuiMarkdownEditorUiPlugin) => void;
	    replaceNode(position: MarkdownPosition, next: string): void;
	    readOnly?: boolean;
	}
	export const EuiMarkdownContext: import("react").Context<ContextShape>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkdownEditorVariables: ({ euiTheme }: UseEuiTheme) => {
	    minHeight: string;
	    borderRadius: import("csstype").Property.BorderRadius<string | number> | undefined;
	    barsBackgroundColor: string;
	};
	export const euiMarkdownEditorStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownEditor: import("@emotion/react").SerializedStyles;
	    fullHeight: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorPreview: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_toolbar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkdownEditorToolbarStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownEditorToolbar: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorToolbar__buttons: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorToolbar__divider: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_toolbar' {
	import React, { HTMLAttributes, MouseEventHandler } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { MARKDOWN_MODE } from '@elastic/eui/src/components/markdown_editor/markdown_modes';
	import { EuiMarkdownEditorUiPlugin } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	import MarkdownActions from '@elastic/eui/src/components/markdown_editor/markdown_actions';
	export type EuiMarkdownEditorToolbarProps = HTMLAttributes<HTMLDivElement> & CommonProps & {
	    selectedNode?: null | any;
	    markdownActions: MarkdownActions;
	    viewMode: MARKDOWN_MODE;
	    onClickPreview: MouseEventHandler<HTMLButtonElement>;
	    uiPlugins: EuiMarkdownEditorUiPlugin[];
	    right?: React.ReactNode;
	};
	export const EuiMarkdownEditorToolbar: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & CommonProps & {
	    selectedNode?: null | any;
	    markdownActions: MarkdownActions;
	    viewMode: MARKDOWN_MODE;
	    onClickPreview: MouseEventHandler<HTMLButtonElement>;
	    uiPlugins: EuiMarkdownEditorUiPlugin[];
	    right?: React.ReactNode;
	} & React.RefAttributes<HTMLDivElement>>;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_text_area.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkdownEditorTextAreaStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownEditorTextArea: import("@emotion/react").SerializedStyles;
	    readOnly: import("@emotion/react").SerializedStyles;
	    editable: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_text_area' {
	import React, { TextareaHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiMarkdownEditorTextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & CommonProps & {
	    isInvalid?: boolean;
	    fullWidth?: boolean;
	    compressed?: boolean;
	    height: string;
	    maxHeight: string;
	};
	export const EuiMarkdownEditorTextArea: React.ForwardRefExoticComponent<React.TextareaHTMLAttributes<HTMLTextAreaElement> & CommonProps & {
	    isInvalid?: boolean;
	    fullWidth?: boolean;
	    compressed?: boolean;
	    height: string;
	    maxHeight: string;
	} & React.RefAttributes<HTMLTextAreaElement>>;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_format.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	/**
	 * Styles
	 */
	export const euiMarkdownFormatStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownFormat: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    relative: import("@emotion/react").SerializedStyles;
	    colors: {
	        default: import("@emotion/react").SerializedStyles;
	        subdued: import("@emotion/react").SerializedStyles;
	        success: import("@emotion/react").SerializedStyles;
	        accent: import("@emotion/react").SerializedStyles;
	        accentSecondary: import("@emotion/react").SerializedStyles;
	        warning: import("@emotion/react").SerializedStyles;
	        danger: import("@emotion/react").SerializedStyles;
	        ghost: import("@emotion/react").SerializedStyles;
	        inherit: import("@emotion/react").SerializedStyles;
	        custom: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/types' {
	export interface TooltipNodeDetails {
	    type: 'tooltipPlugin';
	    content: string;
	}

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/parser' {
	import { Plugin } from 'unified';
	export const TooltipParser: Plugin;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/plugin' {
	import React from 'react';
	export const tooltipPlugin: {
	    name: string;
	    button: {
	        label: string;
	        iconType: string;
	    };
	    formatting: {
	        prefix: string;
	        suffix: string;
	        trimFirst: boolean;
	    };
	    helpText: React.JSX.Element;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/renderer' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	import { EuiMarkdownAstNodePosition } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	import { TooltipNodeDetails } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/types';
	type TooltipMarkdownRendererProps = PropsWithChildren & TooltipNodeDetails & {
	    position: EuiMarkdownAstNodePosition;
	};
	export const tooltipMarkdownRenderer: FunctionComponent<TooltipMarkdownRendererProps>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip' {
	export { TooltipParser as parser } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/parser';
	export { tooltipPlugin as plugin } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/plugin';
	export { tooltipMarkdownRenderer as renderer } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/renderer';
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_tooltip/types';

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/remark/remark_prismjs' {
	import { Plugin } from 'unified';
	export const FENCED_CLASS = "remark-prismjs--fenced"; const attacher: Plugin;
	export default attacher;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/remark/remark_intraword_underscore' {
	import { Plugin } from 'unified'; const attacher: Plugin;
	export default attacher;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/types' {
	export interface CheckboxNodeDetails {
	    type: 'checkboxPlugin';
	    lead: string;
	    label: string;
	    isChecked: boolean;
	}

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/parser' {
	import { Plugin } from 'unified';
	export const CheckboxParser: Plugin;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/renderer' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	import { EuiMarkdownAstNodePosition } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	import { CheckboxNodeDetails } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/types';
	type CheckboxMarkdownRendererProps = PropsWithChildren & CheckboxNodeDetails & {
	    position: EuiMarkdownAstNodePosition;
	};
	export const CheckboxMarkdownRenderer: FunctionComponent<CheckboxMarkdownRendererProps>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox' {
	export { CheckboxParser as parser } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/parser';
	export { CheckboxMarkdownRenderer as renderer } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/renderer';
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_checkbox/types';

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_link_validator' {
	interface LinkOrTextNode {
	    type: string;
	    url?: string;
	    title?: string | null;
	    value?: string;
	    children?: Array<{
	        value: string;
	    }>;
	}
	export type EuiMarkdownLinkValidatorOptions = {
	    /**
	     * Allow or disallow relative links (links that begin with a `/`)
	     * @default true
	     */
	    allowRelative?: boolean;
	    /**
	     * Only used if `allowRelative` is true.
	     * Allow or disallow document relative links (e.g. `discover` instead of `/app/discover`).
	     * When enabled, document relative URLs are resolved against `baseUrl`
	     * (defaults to `window.location.href`) using the browser's native URL
	     * resolution, the same way an `<a href="discover">` would behave in
	     * plain HTML. (Unlike native URL resolution, trailing slashes
	     * e.g. `discover/` are ignored)
	     * @default false
	     */
	    allowDocumentRelative?: boolean;
	    /**
	     * The base URL to resolve document relative links against.
	     * Only used when `allowDocumentRelative` is true.
	     * Useful for EUI's testing environment which cannot mock window.location, unlikely to be changed from default in actual end use.
	     * @default window.location.href
	     */
	    baseUrl?: string;
	    /**
	     * Allow or disallow specific [URL protocols or schemes](https://developer.mozilla.org/en-US/docs/Web/URI/Schemes)
	     * @default ['https:', 'http:', 'mailto:']
	     */
	    allowProtocols?: string[];
	};
	export const DEFAULT_OPTIONS: {
	    allowRelative: boolean;
	    allowDocumentRelative: boolean;
	    allowProtocols: string[];
	};
	export function euiMarkdownLinkValidator({ allowRelative, allowDocumentRelative, allowProtocols, baseUrl, }: EuiMarkdownLinkValidatorOptions): (ast: any) => void;
	export function mutateLinkToText(node: LinkOrTextNode): LinkOrTextNode;
	export function validateUrl(url: string, { allowRelative, allowProtocols, }: EuiMarkdownLinkValidatorOptions): boolean;
	/**
	 * Tests whether a URL is a document relative URL (e.g. "discover", "dashboards#/view/123")
	 * that has no scheme, no leading slash, and is not an anchor or query-only link.
	 */
	export function isDocumentRelativeUrl(url: string): boolean;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/parsing_plugins' {
	import { PluggableList } from 'unified';
	import { EuiMarkdownLinkValidatorOptions } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_link_validator';
	import type { DefaultPluginsConfig } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/plugins';
	export type DefaultEuiMarkdownParsingPlugins = PluggableList;
	export type DefaultParsingPluginsConfig = {
	    /**
	     * Allows enabling emoji rendering for emoticons such as :) and :(
	     * @default { emoticon: false }
	     */
	    emoji?: {
	        emoticon?: boolean;
	    };
	    /**
	     * Allows configuring the `allowRelative`, `allowProtocols`, and `allowDocumentRelative` of
	     * {@link EuiMarkdownLinkValidatorOptions}
	     */
	    linkValidator?: EuiMarkdownLinkValidatorOptions;
	};
	export const getDefaultEuiMarkdownParsingPlugins: ({ exclude, ...parsingConfig }?: DefaultPluginsConfig & DefaultParsingPluginsConfig) => DefaultEuiMarkdownParsingPlugins;
	export const defaultParsingPlugins: DefaultEuiMarkdownParsingPlugins;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/processing_plugins' {
	import React from 'react';
	import { Plugin, PluggableList, Pluggable, Settings } from 'unified';
	import { Options as Remark2RehypeOptions } from 'mdast-util-to-hast';
	import rehype2react from 'rehype-react';
	import { EuiLinkProps } from '@elastic/eui/src/components/link';
	import type { DefaultPluginsConfig } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/plugins';
	export interface Rehype2ReactOptions {
	    components: {
	        [key: string]: React.ComponentType<any>;
	    };
	    [key: string]: any;
	}
	export type DefaultEuiMarkdownProcessingPlugins = [
	    [
	        Plugin,
	        Remark2RehypeOptions
	    ],
	    [
	        typeof rehype2react,
	        Rehype2ReactOptions
	    ],
	    ...PluggableList
	];
	export type DefaultProcessingPluginsConfig = {
	    /**
	     * Allows customizing all formatted links.
	     * Accepts any prop that [EuiLink](/#/navigation/link) or any anchor link tag accepts.
	     * Useful for, e.g. setting `target="_blank"` on all links
	     */
	    linkProps?: Partial<EuiLinkProps>;
	};
	export const getDefaultEuiMarkdownProcessingPlugins: ({ exclude, linkProps, }?: DefaultPluginsConfig & DefaultProcessingPluginsConfig) => DefaultEuiMarkdownProcessingPlugins;
	export const defaultProcessingPlugins: [[Plugin, Remark2RehypeOptions], [typeof rehype2react, Rehype2ReactOptions], ...Pluggable<any[], Settings>[]];

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/plugins' {
	import { DefaultEuiMarkdownUiPlugins } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/ui_plugins';
	import { DefaultEuiMarkdownParsingPlugins, type DefaultParsingPluginsConfig } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/parsing_plugins';
	import { DefaultEuiMarkdownProcessingPlugins, type DefaultProcessingPluginsConfig } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/processing_plugins';
	export type ExcludableDefaultPlugins = 'emoji' | 'lineBreaks' | 'linkValidator' | 'checkbox' | 'tooltip';
	export type DefaultPluginsConfig = undefined | {
	    exclude?: ExcludableDefaultPlugins[];
	};
	export const getDefaultEuiMarkdownPlugins: (config?: DefaultPluginsConfig & {
	    processingConfig?: DefaultProcessingPluginsConfig;
	    parsingConfig?: DefaultParsingPluginsConfig;
	    uiConfig?: {};
	}) => {
	    parsingPlugins: DefaultEuiMarkdownParsingPlugins;
	    processingPlugins: DefaultEuiMarkdownProcessingPlugins;
	    uiPlugins: DefaultEuiMarkdownUiPlugins;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/ui_plugins' {
	import { EuiMarkdownEditorUiPlugin } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	import type { DefaultPluginsConfig } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/plugins';
	export type DefaultEuiMarkdownUiPlugins = EuiMarkdownEditorUiPlugin[];
	export const getDefaultEuiMarkdownUiPlugins: ({ exclude, }?: DefaultPluginsConfig) => DefaultEuiMarkdownUiPlugins;
	export const defaultUiPlugins: DefaultEuiMarkdownUiPlugins;

}
declare module '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins' {
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/ui_plugins';
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/parsing_plugins';
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/processing_plugins';
	export * from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins/plugins';

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_format' {
	import { FunctionComponent } from 'react';
	import { PluggableList } from 'unified';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTextProps } from '@elastic/eui/src/components/text/text';
	export type EuiMarkdownFormatProps = CommonProps & Omit<EuiTextProps, 'size'> & {
	    children: string;
	    /** array of unified plugins to parse content into an AST */
	    parsingPluginList?: PluggableList;
	    /** array of unified plugins to convert the AST into a ReactNode */
	    processingPluginList?: PluggableList;
	    /**
	     * Determines the text size. Choose `relative` to control the `font-size` based on the value of a parent container.
	     */
	    textSize?: EuiTextProps['size'];
	};
	export const EuiMarkdownFormat: FunctionComponent<EuiMarkdownFormatProps>;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkdownEditorFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownEditorFooter: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorFooter__actions: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorFooter__uploadError: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorFooter__popover: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/icons/markdown_logo' {
	import React from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	} const MarkdownLogo: ({ title, titleId, ...props }: React.SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export default MarkdownLogo;

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_help_button.styles' {
	export const euiMarkdownEditorHelpButtonStyles: () => {
	    euiMarkdownEditorFooter__helpButton: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_help_button' {
	import React from 'react';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	import { EuiMarkdownEditorUiPlugin } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	interface EuiMarkdownEditorHelpButtonProps {
	    uiPlugins: EuiMarkdownEditorUiPlugin[];
	    tooltipProps?: Omit<EuiToolTipProps, 'children' | 'content'>;
	}
	export const EuiMarkdownEditorHelpButton: {
	    ({ uiPlugins, tooltipProps, }: EuiMarkdownEditorHelpButtonProps): React.JSX.Element;
	    displayName: string;
	};
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_footer' {
	import React from 'react';
	import { EuiMarkdownDropHandler, EuiMarkdownEditorUiPlugin, EuiMarkdownParseError } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	interface EuiMarkdownEditorFooterProps {
	    uiPlugins: EuiMarkdownEditorUiPlugin[];
	    isUploadingFiles: boolean;
	    openFiles: () => void;
	    errors: EuiMarkdownParseError[];
	    hasUnacceptedItems: boolean;
	    dropHandlers: EuiMarkdownDropHandler[];
	}
	export const EuiMarkdownEditorFooter: React.ForwardRefExoticComponent<EuiMarkdownEditorFooterProps & React.RefAttributes<HTMLDivElement>>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_drop_zone.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiMarkdownEditorDropZoneStyles: (euiThemeContext: UseEuiTheme) => {
	    euiMarkdownEditorDropZone: import("@emotion/react").SerializedStyles;
	    isDragging: import("@emotion/react").SerializedStyles;
	    isDraggingError: import("@emotion/react").SerializedStyles;
	    hasError: import("@emotion/react").SerializedStyles;
	    euiMarkdownEditorDropZone__input: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor_drop_zone' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	import { EuiMarkdownEditorUiPlugin, EuiMarkdownParseError, EuiMarkdownDropHandler, EuiMarkdownStringTagConfig } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	interface EuiMarkdownEditorDropZoneProps extends PropsWithChildren {
	    uiPlugins: EuiMarkdownEditorUiPlugin[];
	    errors: EuiMarkdownParseError[];
	    dropHandlers: EuiMarkdownDropHandler[];
	    insertText: (text: string, config: EuiMarkdownStringTagConfig) => void;
	    hasUnacceptedItems: boolean;
	    setHasUnacceptedItems: (hasUnacceptedItems: boolean) => void;
	    setEditorFooterHeight: (height: number) => void;
	    isEditing: boolean;
	    showFooter?: boolean;
	}
	export const EuiMarkdownEditorDropZone: FunctionComponent<EuiMarkdownEditorDropZoneProps>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor/markdown_editor' {
	import React, { HTMLAttributes } from 'react';
	import { PluggableList } from 'unified';
	import { VFileMessage } from 'vfile-message';
	import { CommonProps, OneOf } from '@elastic/eui/src/components/common';
	import { EuiMarkdownEditorToolbarProps } from '@elastic/eui/src/components/markdown_editor/markdown_editor_toolbar';
	import { EuiMarkdownEditorTextAreaProps } from '@elastic/eui/src/components/markdown_editor/markdown_editor_text_area';
	import { EuiMarkdownFormatProps } from '@elastic/eui/src/components/markdown_editor/markdown_format';
	import { MARKDOWN_MODE } from '@elastic/eui/src/components/markdown_editor/markdown_modes';
	import { EuiMarkdownAstNode, EuiMarkdownDropHandler, EuiMarkdownEditorUiPlugin, EuiMarkdownParseError } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	import { ContextShape } from '@elastic/eui/src/components/markdown_editor/markdown_context';
	type CommonMarkdownEditorProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'placeholder'> & CommonProps & {
	    /** aria-label OR aria-labelledby must be set */
	    'aria-label'?: string;
	    /** aria-label OR aria-labelledby must be set */
	    'aria-labelledby'?: string;
	    /** ID of an element describing the text editor, useful for associating error messages */
	    'aria-describedby'?: string;
	    /** a unique ID to attach to the textarea. If one isn't provided, a random one
	     * will be generated */
	    editorId?: string;
	    /** A markdown content */
	    value: string;
	    /** callback function when markdown content is modified */
	    onChange: (value: string) => void;
	    /**
	     * Sets the current display mode to a read-only state. All editing gets resctricted.
	     */
	    readOnly?: ContextShape['readOnly'];
	    /**
	     * Sets the `height` in pixels of the editor/preview area or pass `full` to allow
	     * the EuiMarkdownEditor to fill the height of its container.
	     * When in `full` mode the vertical resize is not allowed.
	     */
	    height?: number | 'full';
	    /**
	     * Sets the `max-height` in pixels of the editor/preview area.
	     * It has no effect when the `height` is set to `full`.
	     */
	    maxHeight?: number;
	    /**
	     * Automatically adjusts the preview height to fit all the content and avoid a scrollbar.
	     */
	    autoExpandPreview?: boolean;
	    /** plugins to identify new syntax and parse it into an AST node */
	    parsingPluginList?: PluggableList;
	    /** plugins to process the markdown AST nodes into a React nodes */
	    processingPluginList?: PluggableList;
	    /** defines UI for plugins' buttons in the toolbar as well as any modals or extra UI that provides content to the editor */
	    uiPlugins?: EuiMarkdownEditorUiPlugin[];
	    /** errors to bubble up */
	    errors?: EuiMarkdownParseError[];
	    /** callback triggered when parsing results are available */
	    onParse?: (error: EuiMarkdownParseError | null, data: {
	        messages: VFileMessage[];
	        ast: EuiMarkdownAstNode;
	    }) => void;
	    /** initial display mode for the editor */
	    initialViewMode?: MARKDOWN_MODE;
	    /** array defining any drag&drop handlers */
	    dropHandlers?: EuiMarkdownDropHandler[];
	    /**
	     * Sets the placeholder of the textarea
	     */
	    placeholder?: EuiMarkdownEditorTextAreaProps['placeholder'];
	    /**
	     * Further extend the props applied to EuiMarkdownFormat
	     */
	    markdownFormatProps?: Omit<EuiMarkdownFormatProps, 'parsingPluginList' | 'processingPluginList' | 'children'>;
	    /**
	     * Props to customize the toolbar. `right` replaces the default preview/editor toggle with custom content.
	     */
	    toolbarProps?: {
	        className?: EuiMarkdownEditorToolbarProps['className'];
	        right?: EuiMarkdownEditorToolbarProps['right'];
	    };
	    /** Controls whether the footer is shown */
	    showFooter?: boolean;
	};
	export type EuiMarkdownEditorProps = OneOf<CommonMarkdownEditorProps, 'aria-label' | 'aria-labelledby'>;
	export interface EuiMarkdownEditorRef {
	    textarea: HTMLTextAreaElement | null;
	    replaceNode: ContextShape['replaceNode'];
	}
	export const EuiMarkdownEditor: React.ForwardRefExoticComponent<EuiMarkdownEditorProps & React.RefAttributes<EuiMarkdownEditorRef>>;
	export {};

}
declare module '@elastic/eui/src/components/markdown_editor' {
	export type { EuiMarkdownEditorProps, EuiMarkdownEditorRef, } from '@elastic/eui/src/components/markdown_editor/markdown_editor';
	export { EuiMarkdownEditor } from '@elastic/eui/src/components/markdown_editor/markdown_editor';
	export { EuiMarkdownEditorHelpButton } from '@elastic/eui/src/components/markdown_editor/markdown_editor_help_button';
	export { getDefaultEuiMarkdownParsingPlugins, getDefaultEuiMarkdownProcessingPlugins, getDefaultEuiMarkdownUiPlugins, getDefaultEuiMarkdownPlugins, } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_default_plugins';
	export { EuiMarkdownContext } from '@elastic/eui/src/components/markdown_editor/markdown_context';
	export type { EuiMarkdownFormatProps } from '@elastic/eui/src/components/markdown_editor/markdown_format';
	export { EuiMarkdownFormat } from '@elastic/eui/src/components/markdown_editor/markdown_format';
	export type { EuiMarkdownParseError, EuiMarkdownAstNode, EuiMarkdownAstNodePosition, EuiMarkdownFormatting, EuiMarkdownEditorUiPlugin, RemarkRehypeHandler, RemarkTokenizer, } from '@elastic/eui/src/components/markdown_editor/markdown_types';
	export { euiMarkdownLinkValidator } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_link_validator';
	export type { EuiMarkdownLinkValidatorOptions } from '@elastic/eui/src/components/markdown_editor/plugins/markdown_link_validator';

}
declare module '@elastic/eui/src/components/page/_restrict_width' {
	/**
	 * The `restrictedWidth` property is the same for all EuiPage components.
	 * This is file contains the type specific to that prop and a helper
	 * function for creating the corresponding classNames and style tags
	 * based on the consumer's configuration
	 */
	import { CSSProperties } from 'react';
	export const PAGE_MAX_WIDTH: CSSProperties['maxWidth'];
	export type _EuiPageRestrictWidth = {
	    /**
	     * Sets the max-width of the page,
	     * set to `true` to use the default size of `1200px`,
	     * set to `false` to not restrict the width,
	     * set to a number for a custom width in px,
	     * set to a string for a custom width in custom measurement.
	     */
	    restrictWidth?: boolean | number | string;
	};
	/**
	 * **DEPRECATED**
	 * This function calculates the correct class name and combined styles
	 * based on the `restrictWidth` value passed in
	 *
	 * @param restrictWidth `boolean | number | string` The prop value
	 * @param style `CSSProperties` An object of style attributes if provided
	 * @returns An object with keys for the `widthClassName` to append to the component's class and the updated `newStyle` props
	 */
	export function setPropsForRestrictedPageWidth(restrictWidth: _EuiPageRestrictWidth['restrictWidth'], style?: CSSProperties): {
	    widthClassName?: string;
	    newStyle: CSSProperties;
	};
	/**
	 * This function calculates the correct just the combined styles
	 * based on the `restrictWidth` value passed in
	 *
	 * @param restrictWidth `boolean | number | string` The prop value
	 * @param style `CSSProperties` An object of style attributes if provided
	 * @returns An object of the updated `style` props
	 */
	export function setStyleForRestrictedPageWidth(restrictWidth: _EuiPageRestrictWidth['restrictWidth'], style?: CSSProperties): CSSProperties;

}
declare module '@elastic/eui/src/components/page/page.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPageStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPage: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	    restrictWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	export interface EuiPageProps extends CommonProps, HTMLAttributes<HTMLDivElement>, _EuiPageRestrictWidth {
	    /**
	     * Adjust the padding.
	     * When using this setting it's best to be consistent throughout all similar usages
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Adds `flex-grow: 1` to the whole page for stretching to fit vertically.
	     * Must be wrapped inside a flexbox, preferrably with `min-height: 100vh`
	     */
	    grow?: boolean;
	    /**
	     * Changes the `flex-direction` property.
	     * Flip to `column` when not including a sidebar.
	     */
	    direction?: 'row' | 'column';
	    /**
	     * Defines the page background color.
	     * @default 'transparent'
	     */
	    color?: 'plain' | 'transparent';
	}
	export const EuiPage: FunctionComponent<EuiPageProps>;

}
declare module '@elastic/eui/src/components/page/page_body/page_body.styles' {
	export const euiPageBodyStyles: () => {
	    euiPageBody: import("@emotion/react").SerializedStyles;
	    restrictWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page_body/page_body' {
	import { PropsWithChildren, ComponentType, ComponentProps, JSX } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	import { EuiPanelProps } from '@elastic/eui/src/components/panel';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	type ComponentTypes = keyof JSX.IntrinsicElements | ComponentType<any>;
	export type EuiPageBodyProps<T extends ComponentTypes = 'main'> = PropsWithChildren & CommonProps & ComponentProps<T> & _EuiPageRestrictWidth & {
	    /**
	     * Sets the HTML element for `EuiPageBody`.
	     */
	    component?: T;
	    /**
	     * Uses an EuiPanel as the main component instead of a plain div
	     */
	    panelled?: boolean;
	    /**
	     * Extends any extra EuiPanel props if `panelled=true`
	     */
	    panelProps?: Omit<EuiPanelProps, 'paddingSize'>;
	    /**
	     * Adjusts the padding
	     */
	    paddingSize?: EuiPaddingSize;
	};
	export const EuiPageBody: <T extends ComponentTypes>({ children, restrictWidth, className, css, component: Component, panelled, panelProps, paddingSize, borderRadius, ...rest }: EuiPageBodyProps<T>) => JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/page/page_body' {
	export type { EuiPageBodyProps } from '@elastic/eui/src/components/page/page_body/page_body';
	export { EuiPageBody } from '@elastic/eui/src/components/page/page_body/page_body';

}
declare module '@elastic/eui/src/components/page/page_header/page_header.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPageHeaderStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiPageHeader: import("@emotion/react").SerializedStyles;
	    border: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page_header/page_header_content.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPageHeaderContentStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiPageHeaderContent: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    bottom: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	    stretch: import("@emotion/react").SerializedStyles;
	    childrenOnly: {
	        flex: import("@emotion/react").SerializedStyles;
	        responsive: import("@emotion/react").SerializedStyles;
	        responsiveReverse: import("@emotion/react").SerializedStyles;
	    };
	    euiPageHeaderContent__top: import("@emotion/react").SerializedStyles;
	    euiPageHeaderContent__leftSideItems: import("@emotion/react").SerializedStyles;
	    euiPageHeaderContent__rightSideItems: import("@emotion/react").SerializedStyles;
	    euiPageHeaderContent__rightSideItem: import("@emotion/react").SerializedStyles;
	    euiPageHeaderContent__titleIcon: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page_header/page_header_content' {
	import { FunctionComponent, ReactNode, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiIconProps, IconType } from '@elastic/eui/src/components/icon';
	import { EuiTabsProps } from '@elastic/eui/src/components/tabs';
	import { Props as EuiTabProps } from '@elastic/eui/src/components/tabs/tab';
	import { EuiFlexGroupProps } from '@elastic/eui/src/components/flex';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	import { EuiBreadcrumbsProps } from '@elastic/eui/src/components/breadcrumbs';
	import { PADDING_SIZES } from '@elastic/eui/src/global_styling';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	export const ALIGN_ITEMS: readonly ["top", "bottom", "center", "stretch"];
	type Tab = EuiTabProps & {
	    /**
	     * Visible text of the tab
	     */
	    label: ReactNode;
	};
	export interface EuiPageHeaderContentTitle {
	    /**
	     * Wrapped in an `H1` so choose appropriately.
	     * A simple string is best
	     */
	    pageTitle?: ReactNode;
	    /**
	     * Additional props to pass to the EuiTitle
	     */
	    pageTitleProps?: Omit<EuiTitleProps, 'children' | 'size'>;
	    /**
	     * Optional icon to place to the left of the title
	     */
	    iconType?: IconType;
	    /**
	     * Additional EuiIcon props to apply to the optional icon
	     */
	    iconProps?: Partial<Omit<EuiIconProps, 'type'>>;
	    /**
	     * Optional array breadcrumbs that render before the `pageTitle`
	     */
	    breadcrumbs?: EuiBreadcrumbsProps['breadcrumbs'];
	    /**
	     * Adjust the props of [EuiBreadcrumbs](#/navigation/breadcrumbs)
	     */
	    breadcrumbProps?: Partial<Omit<EuiBreadcrumbsProps, 'breadcrumbs'>>;
	}
	export interface EuiPageHeaderContentTabs {
	    /**
	     * In-app navigation presented as large borderless tabs.
	     * Accepts an array of `EuiTab` objects;
	     */
	    tabs?: Tab[];
	    /**
	     * Any extras to apply to the outer tabs container.
	     * Extends `EuiTabs`
	     */
	    tabsProps?: Omit<EuiTabsProps, 'size' | 'expand'>;
	}
	/**
	 * The left side can either be a title with optional description and/or icon;
	 * Or a list of tabs,
	 * Or a custom node
	 */
	interface EuiPageHeaderContentLeft extends EuiPageHeaderContentTitle, EuiPageHeaderContentTabs {
	    /**
	     * Position is dependent on existing with a `pageTitle` or `tabs`
	     * Automatically get wrapped in a single paragraph tag inside an EuiText block
	     */
	    description?: string | ReactNode;
	}
	export interface _EuiPageHeaderContentProps extends EuiPageHeaderContentLeft, _EuiPageRestrictWidth {
	    /**
	     * If not set, defaults to true if `tabs` are passed and render at the bottom of the page.
	     * Otherwise, defaults to false.
	     */
	    bottomBorder?: boolean;
	    /**
	     * Adjust the padding.
	     * When using this setting it's best to be consistent throughout all similar usages
	     */
	    paddingSize?: (typeof PADDING_SIZES)[number];
	    /**
	     * Set to false if you don't want the children to stack at small screen sizes.
	     * Set to `reverse` to display the right side content first for the sake of hierarchy (like global time)
	     */
	    responsive?: boolean | 'reverse';
	    /**
	     * Vertical alignment of the left and right side content;
	     * Default is `center` for custom content, but `top` for when `pageTitle` or `tabs` are included
	     */
	    alignItems?: (typeof ALIGN_ITEMS)[number];
	    /**
	     * Pass custom an array of content to this side usually up to 3 buttons.
	     * The first button should be primary, usually with `fill`. At larger breakpoints, items will
	     * render from right to left, but will collapse vertically and render left to right on smaller mobile screens.
	     */
	    rightSideItems?: ReactNode[];
	    /**
	     * Additional EuiFlexGroup props to pass to the container of the `rightSideItems`
	     */
	    rightSideGroupProps?: Partial<EuiFlexGroupProps>;
	    /**
	     * Custom children will be rendered before the `tabs` unless no `pageTitle` is present, then it will be the last item
	     */
	    children?: ReactNode;
	}
	export interface EuiPageHeaderContentProps extends CommonProps, HTMLAttributes<HTMLDivElement>, _EuiPageHeaderContentProps {
	}
	export const EuiPageHeaderContent: FunctionComponent<EuiPageHeaderContentProps>;
	export {};

}
declare module '@elastic/eui/src/components/page/_bottom_border' {
	export type _EuiPageBottomBorder = {
	    /**
	     * Adds a bottom border to separate it from the content after;
	     * Passing `extended` will ensure the border touches the sides of the parent container.
	     */
	    bottomBorder?: boolean | 'extended';
	};

}
declare module '@elastic/eui/src/components/page/page_header/page_header' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiPaddingSize } from '@elastic/eui/src/global_styling';
	import { _EuiPageHeaderContentProps } from '@elastic/eui/src/components/page/page_header/page_header_content';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	import { _EuiPageBottomBorder } from '@elastic/eui/src/components/page/_bottom_border';
	export interface EuiPageHeaderProps extends CommonProps, HTMLAttributes<HTMLElement>, Omit<_EuiPageHeaderContentProps, 'bottomBorder'>, _EuiPageRestrictWidth, _EuiPageBottomBorder {
	    /**
	     * Adjust the overall padding.
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Define the header background color
	     * @default 'transparent'
	     */
	    color?: 'plain' | 'transparent';
	}
	export const EuiPageHeader: FunctionComponent<EuiPageHeaderProps>;

}
declare module '@elastic/eui/src/components/page/page_header/page_header_section' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiPageHeaderSectionProps extends CommonProps, HTMLAttributes<HTMLDivElement> {
	}
	export const EuiPageHeaderSection: FunctionComponent<EuiPageHeaderSectionProps>;

}
declare module '@elastic/eui/src/components/page/page_header' {
	export type { EuiPageHeaderProps } from '@elastic/eui/src/components/page/page_header/page_header';
	export { EuiPageHeader } from '@elastic/eui/src/components/page/page_header/page_header';
	export type { EuiPageHeaderContentProps } from '@elastic/eui/src/components/page/page_header/page_header_content';
	export { EuiPageHeaderContent } from '@elastic/eui/src/components/page/page_header/page_header_content';
	export type { EuiPageHeaderSectionProps } from '@elastic/eui/src/components/page/page_header/page_header_section';
	export { EuiPageHeaderSection } from '@elastic/eui/src/components/page/page_header/page_header_section';

}
declare module '@elastic/eui/src/components/page/page_section/page_section.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const ALIGNMENTS: readonly ["top", "center", "horizontalCenter"];
	export const euiPageSectionStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiPageSection: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    border: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	    horizontalCenter: import("@emotion/react").SerializedStyles;
	};
	export const euiPageSectionContentStyles: () => {
	    euiPageSection__content: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	    restrictWidth: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page_section/page_section' {
	import { FunctionComponent, ComponentType, HTMLAttributes, JSX } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	import { _EuiPageBottomBorder } from '@elastic/eui/src/components/page/_bottom_border';
	import { ALIGNMENTS } from '@elastic/eui/src/components/page/page_section/page_section.styles';
	import { EuiPaddingSize, _EuiBackgroundColor } from '@elastic/eui/src/global_styling';
	export type EuiPageSectionProps = CommonProps & _EuiPageRestrictWidth & _EuiPageBottomBorder & {
	    /**
	     * Background color of the section;
	     * Usually a lightened form of the brand colors
	     */
	    color?: _EuiBackgroundColor;
	    /**
	     * Padding for all four sides
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Horizontal and/or vertical alignment of the section contents
	     */
	    alignment?: (typeof ALIGNMENTS)[number];
	    /**
	     * When true the panel will grow in height to fill container if parent is a flex group
	     */
	    grow?: boolean;
	    /**
	     * Passed down to the div wrapper of the section contents
	     */
	    contentProps?: CommonProps & HTMLAttributes<HTMLDivElement>;
	    /**
	     * Sets which HTML element to render.
	     */
	    component?: keyof JSX.IntrinsicElements | ComponentType;
	} & Omit<HTMLAttributes<Element>, 'color'>;
	export const EuiPageSection: FunctionComponent<EuiPageSectionProps>;

}
declare module '@elastic/eui/src/components/page/page_section' {
	export type { EuiPageSectionProps } from '@elastic/eui/src/components/page/page_section/page_section';
	export { EuiPageSection } from '@elastic/eui/src/components/page/page_section/page_section';

}
declare module '@elastic/eui/src/components/page/page_sidebar/page_sidebar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPageSidebarStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPageSidebar: import("@emotion/react").SerializedStyles;
	    sticky: import("@emotion/react").SerializedStyles;
	    embellish: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page/page_sidebar/page_sidebar' {
	import { CSSProperties, FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiPaddingSize, _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling';
	export interface EuiPageSidebarProps extends CommonProps, HTMLAttributes<HTMLDivElement> {
	    /**
	     * Adjust the padding.
	     * When using this setting it's best to be consistent throughout all similar usages.
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Renders a fancy little visual in the top left corner of the side bar
	     */
	    hasEmbellish?: boolean;
	    /**
	     * Adds `position: sticky` and affords for any fixed position headers.
	     */
	    sticky?: boolean | {
	        /**
	         * To account for any fixed elements like headers,
	         * pass in the value of the total height of those fixed elements.
	         */
	        offset?: number;
	    };
	    /**
	     * A minimum width is necessary to maintain size.
	     * Be sure to take `paddingSize` into account.
	     */
	    minWidth?: CSSProperties['width'];
	    /**
	     * Sets the `minWidth` to 100% when within these breakpoints.
	     */
	    responsive?: _EuiThemeBreakpoint[];
	}
	export const EuiPageSidebar: FunctionComponent<EuiPageSidebarProps>;

}
declare module '@elastic/eui/src/components/page/page_sidebar' {
	export type { EuiPageSidebarProps } from '@elastic/eui/src/components/page/page_sidebar/page_sidebar';
	export { EuiPageSidebar } from '@elastic/eui/src/components/page/page_sidebar/page_sidebar';

}
declare module '@elastic/eui/src/components/page' {
	export type { EuiPageProps } from '@elastic/eui/src/components/page/page';
	export { EuiPage } from '@elastic/eui/src/components/page/page';
	export type { EuiPageBodyProps } from '@elastic/eui/src/components/page/page_body';
	export { EuiPageBody } from '@elastic/eui/src/components/page/page_body';
	export type { EuiPageHeaderContentProps, EuiPageHeaderProps, EuiPageHeaderSectionProps, } from '@elastic/eui/src/components/page/page_header';
	export { EuiPageHeader, EuiPageHeaderContent, EuiPageHeaderSection, } from '@elastic/eui/src/components/page/page_header';
	export type { EuiPageSectionProps } from '@elastic/eui/src/components/page/page_section';
	export { EuiPageSection } from '@elastic/eui/src/components/page/page_section';
	export type { EuiPageSidebarProps } from '@elastic/eui/src/components/page/page_sidebar';
	export { EuiPageSidebar } from '@elastic/eui/src/components/page/page_sidebar';

}
declare module '@elastic/eui/src/components/page_template/outer/page_outer.styles' {
	export const euiPageOuterStyles: {
	    euiPageOuter: import("@emotion/react").SerializedStyles;
	    grow: import("@emotion/react").SerializedStyles;
	    column: import("@emotion/react").SerializedStyles;
	    row: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/page_template/outer/page_outer' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling';
	export const PAGE_DIRECTIONS: readonly ["row", "column"];
	type PageDirections = (typeof PAGE_DIRECTIONS)[number];
	export interface _EuiPageOuterProps extends CommonProps, HTMLAttributes<HTMLDivElement> {
	    /**
	     * Adds `flex-grow: 1` to the whole page for stretching to fit vertically.
	     * Must be wrapped inside a flexbox, preferrably with `min-height: 100vh`
	     */
	    grow?: boolean;
	    /**
	     * Changes the `flex-direction` property.
	     * Flip to `column` when not including a sidebar.
	     */
	    direction?: PageDirections;
	    /**
	     * When direction is `row`, it will flip to `column` when within these breakpoints.
	     */
	    responsive?: _EuiThemeBreakpoint[];
	}
	export const _EuiPageOuter: FunctionComponent<_EuiPageOuterProps>;
	export {};

}
declare module '@elastic/eui/src/components/page_template/outer' {
	export type { _EuiPageOuterProps } from '@elastic/eui/src/components/page_template/outer/page_outer';
	export { _EuiPageOuter } from '@elastic/eui/src/components/page_template/outer/page_outer';

}
declare module '@elastic/eui/src/components/page_template/inner/page_inner.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiPageInnerStyles: (euiThemeContext: UseEuiTheme) => {
	    euiPageInner: import("@emotion/react").SerializedStyles;
	    panelled: import("@emotion/react").SerializedStyles;
	    border: {
	        top: import("@emotion/react").SerializedStyles;
	        left: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/page_template/inner/page_inner' {
	import { PropsWithChildren, ComponentType, ComponentProps, JSX } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiPaddingSize, _EuiThemeBreakpoint } from '@elastic/eui/src/global_styling';
	export type ComponentTypes = keyof JSX.IntrinsicElements | ComponentType;
	export type _EuiPageInnerProps<T extends ComponentTypes = 'main'> = PropsWithChildren & CommonProps & ComponentProps<T> & {
	    /**
	     * Sets which HTML element to render.
	     */
	    component?: T;
	    /**
	     * Adds a background and shadow to define the area.
	     */
	    panelled?: boolean;
	    /**
	     * Adds a single side border, based on the `responsive` state.
	     * Typically added when a side bar exists.
	     */
	    border?: boolean;
	    /**
	     * Adjust the overall padding.
	     */
	    paddingSize?: EuiPaddingSize;
	    /**
	     * Decides at which point the main content wrapper will be 100vw.
	     */
	    responsive?: _EuiThemeBreakpoint[];
	};
	export const _EuiPageInner: <T extends ComponentTypes>({ children, component: Component, panelled, border, paddingSize, responsive, ...rest }: _EuiPageInnerProps<T>) => JSX.Element;

}
declare module '@elastic/eui/src/components/page_template/inner' {
	export type { _EuiPageInnerProps } from '@elastic/eui/src/components/page_template/inner/page_inner';
	export { _EuiPageInner } from '@elastic/eui/src/components/page_template/inner/page_inner';

}
declare module '@elastic/eui/src/components/page_template/bottom_bar/page_bottom_bar' {
	import { FunctionComponent } from 'react';
	import { EuiBottomBarProps } from '@elastic/eui/src/components/bottom_bar';
	import { EuiPageSectionProps } from '@elastic/eui/src/components/page/page_section';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	export interface _EuiPageBottomBarProps extends Pick<EuiPageSectionProps, 'paddingSize'>, _EuiPageRestrictWidth, Omit<EuiBottomBarProps, 'paddingSize'> {
	    /**
	     * The reference id of the element to insert into
	     */
	    parent?: string;
	}
	export const _EuiPageBottomBar: FunctionComponent<_EuiPageBottomBarProps>;

}
declare module '@elastic/eui/src/components/page_template/empty_prompt/page_empty_prompt' {
	import { FunctionComponent } from 'react';
	import { EuiEmptyPromptProps } from '@elastic/eui/src/components/empty_prompt';
	import { EuiPageSectionProps } from '@elastic/eui/src/components/page/page_section';
	export type _EuiPageEmptyPromptProps = Omit<EuiPageSectionProps, 'title' | 'bottomBorder'> & Omit<EuiEmptyPromptProps, 'paddingSize'> & {
	    panelled?: boolean;
	};
	export const _EuiPageEmptyPrompt: FunctionComponent<_EuiPageEmptyPromptProps>;

}
declare module '@elastic/eui/src/components/page_template/page_template' {
	import React, { CSSProperties, FunctionComponent, HTMLAttributes } from 'react';
	import { _EuiPageOuterProps } from '@elastic/eui/src/components/page_template/outer';
	import { _EuiPageInnerProps } from '@elastic/eui/src/components/page_template/inner';
	import { ComponentTypes } from '@elastic/eui/src/components/page_template/inner/page_inner';
	import { _EuiPageBottomBarProps } from '@elastic/eui/src/components/page_template/bottom_bar/page_bottom_bar';
	import { _EuiPageEmptyPromptProps } from '@elastic/eui/src/components/page_template/empty_prompt/page_empty_prompt';
	import { EuiPageHeaderProps, EuiPageSectionProps, EuiPageSidebarProps } from '@elastic/eui/src/components/page';
	import { _EuiPageRestrictWidth } from '@elastic/eui/src/components/page/_restrict_width';
	import { _EuiPageBottomBorder } from '@elastic/eui/src/components/page/_bottom_border';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export const TemplateContext: React.Context<{
	    sidebar: {};
	    section: {};
	    header: {};
	    emptyPrompt: {};
	    bottomBar: {};
	}>;
	export type EuiPageTemplateProps = _EuiPageOuterProps & Omit<_EuiPageInnerProps, 'border' | 'component'> & _EuiPageRestrictWidth & _EuiPageBottomBorder & {
	    /**
	     * Applies a top or left border to the inner contents
	     * to add separation between content and sidebar when a sidebar exists.
	     */
	    contentBorder?: _EuiPageInnerProps['border'];
	    /**
	     * Minimum height in which to enforce scrolling
	     */
	    minHeight?: CSSProperties['minHeight'];
	    /**
	     * To account for any fixed elements like headers,
	     * pass in the value of the total height of those fixed elements.
	     * Otherwise they will be calculated based on the data attributes on the body element.
	     */
	    offset?: number;
	    /**
	     * Passes through some common HTML attributes to the `main` content wrapper
	     */
	    mainProps?: CommonProps & HTMLAttributes<HTMLElement>;
	    /**
	     * Sets which HTML element to render for the `main` content wrapper
	     * @default main
	     */
	    component?: ComponentTypes;
	};
	/**
	 * Consumed via `EuiPageTemplate`,
	 * it controls and propogates most of the shared props per direct child
	 */
	export const _EuiPageTemplate: FunctionComponent<EuiPageTemplateProps>;
	export const EuiPageTemplate: React.FunctionComponent<EuiPageTemplateProps> & {
	    Sidebar: React.FunctionComponent<EuiPageSidebarProps>;
	    Header: React.FunctionComponent<EuiPageHeaderProps>;
	    Section: React.FunctionComponent<EuiPageSectionProps>;
	    BottomBar: React.FunctionComponent<_EuiPageBottomBarProps>;
	    EmptyPrompt: React.FunctionComponent<_EuiPageEmptyPromptProps>;
	};

}
declare module '@elastic/eui/src/components/page_template' {
	export type { EuiPageTemplateProps } from '@elastic/eui/src/components/page_template/page_template';
	export { EuiPageTemplate } from '@elastic/eui/src/components/page_template/page_template';

}
declare module '@elastic/eui/src/global_styling/utility/utility' {
	import React from 'react';
	import { UseEuiTheme } from '@elastic/eui/src/services/theme/hooks';
	export const globalStyles: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;
	export const EuiUtilityClasses: () => React.JSX.Element;

}
declare module '@elastic/eui/src/components/provider/cache/cache_provider' {
	import React, { PropsWithChildren } from 'react';
	import { EmotionCache } from '@emotion/css';
	export interface EuiCacheProviderProps extends PropsWithChildren {
	    cache?: false | EmotionCache;
	}
	export const EuiCacheProvider: ({ cache, children, }: EuiCacheProviderProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/provider/cache' {
	export * from '@elastic/eui/src/components/provider/cache/cache_provider';

}
declare module '@elastic/eui/src/components/provider/system_defaults/match_media_hook' {
	export const useWindowMediaMatcher: (mediaQuery: string) => boolean;

}
declare module '@elastic/eui/src/components/provider/system_defaults/system_defaults_provider' {
	import { FunctionComponent, PropsWithChildren } from 'react';
	export const EuiSystemDefaultsProvider: FunctionComponent<PropsWithChildren>;

}
declare module '@elastic/eui/src/components/provider/system_defaults' {
	export { EuiSystemDefaultsProvider } from '@elastic/eui/src/components/provider/system_defaults/system_defaults_provider';
	export { useWindowMediaMatcher } from '@elastic/eui/src/components/provider/system_defaults/match_media_hook';

}
declare module '@elastic/eui/src/components/provider/nested/nested_context' {
	import React, { PropsWithChildren } from 'react';
	/**
	 * This util creates a context for EuiProviders to use and determine if they're
	 * the only (top-most) EuiProvider in the app. If they aren't (i.e., they're
	 * nested within another EuiProvider) we should throw a warning and not
	 * render instantiate the nested EuiProvider.
	 */
	export const EuiNestedProviderContext: React.Context<boolean>;
	export const EuiProviderNestedCheck: ({ children }: PropsWithChildren<{}>) => React.JSX.Element;
	export const useIsNestedEuiProvider: () => boolean;

}
declare module '@elastic/eui/src/components/provider/nested' {
	export * from '@elastic/eui/src/components/provider/nested/nested_context';

}
declare module '@elastic/eui/src/components/provider/provider' {
	import { PropsWithChildren, JSX } from 'react';
	import type { EmotionCache } from '@emotion/css';
	import { EuiThemeProviderProps, EuiThemeSystem, EuiThemeColorMode, EuiThemeHighContrastModeProp } from '@elastic/eui/src/services';
	import { EuiGlobalStylesProps } from '@elastic/eui/src/global_styling/reset/global_styles';
	import { EuiComponentDefaults } from '@elastic/eui/src/components/provider/component_defaults';
	export interface EuiProviderProps<T> extends PropsWithChildren, EuiGlobalStylesProps, Pick<EuiThemeProviderProps<T>, 'modify'> {
	    /**
	     * Provide a specific EuiTheme; Defaults to EuiThemeBorealis;
	     * Pass `null` to remove all theming including global reset
	     */
	    theme?: EuiThemeSystem | null;
	    /**
	     * Allows setting `light` or `dark` mode.
	     * Defaults to the user's OS/system setting if undefined.
	     */
	    colorMode?: EuiThemeColorMode;
	    /**
	     * Allows enabling a high contrast mode preference for better accessibility.
	     * Defaults to the user's OS/system setting if undefined.
	     *
	     * - @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-contrast
	     * - @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/forced-colors (system only, supercedes this prop)
	     */
	    highContrastMode?: EuiThemeHighContrastModeProp;
	    /**
	     * Provide global styles via `@emotion/react` `Global` for your custom theme.
	     * Pass `false` to remove the default EUI global styles.
	     */
	    globalStyles?: false | ((params: any) => JSX.Element | null);
	    /**
	     * Provide utility classes.
	     * Pass `false` to remove the default EUI utility classes.
	     */
	    utilityClasses?: false | ((params: any) => JSX.Element | null);
	    /**
	     * Provide a cache configuration(s) from `@emotion/cache`.
	     *
	     * - `default` will encompass all Emotion styles, including consumer defined appliction styles, not handled by nested cache instances.
	     * - `global` will scope all EUI global and reset styles.
	     * - `utility` will scope all EUI utility class styles.
	     *
	     * A cache instance provided as the sole value will function the same as the `default` cache.
	     */
	    cache?: EmotionCache | {
	        default?: EmotionCache;
	        global?: EmotionCache;
	        utility?: EmotionCache;
	    };
	    /**
	     * Allows configuring specified component defaults across all usages, overriding
	     * baseline EUI component defaults.
	     *
	     * Not all components will be supported, and configurable component defaults
	     * will be considered on a case-by-case basis.
	     *
	     * Individual component prop usages will always override these defaults.
	     */
	    componentDefaults?: EuiComponentDefaults;
	}
	export const EuiProvider: <T extends {} = {}>({ cache, theme, globalStyles: Globals, utilityClasses: Utilities, colorMode, highContrastMode, modify, componentDefaults, children, }: PropsWithChildren<EuiProviderProps<T>>) => any;

}
declare module '@elastic/eui/src/components/provider' {
	export type { EuiProviderProps } from '@elastic/eui/src/components/provider/provider';
	export { EuiProvider } from '@elastic/eui/src/components/provider/provider';
	export type { EuiComponentDefaultsProviderProps } from '@elastic/eui/src/components/provider/component_defaults';
	export { EuiComponentDefaultsProvider, EuiComponentDefaultsContext, } from '@elastic/eui/src/components/provider/component_defaults';

}
declare module '@elastic/eui/src/components/tree_view/tree_view_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTreeViewItemStyles: (euiThemeContext: UseEuiTheme) => {
	    li: {
	        euiTreeView__node: import("@emotion/react").SerializedStyles;
	        default: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	        expanded: import("@emotion/react").SerializedStyles;
	    };
	    button: {
	        euiTreeView__nodeInner: import("@emotion/react").SerializedStyles;
	        default: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	    icon: {
	        euiTreeView__iconWrapper: import("@emotion/react").SerializedStyles;
	        default: import("@emotion/react").SerializedStyles;
	        compressed: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/tree_view/tree_view_item' {
	import { FunctionComponent, HTMLAttributes, ReactNode, Ref } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTreeViewProps } from '@elastic/eui/src/components/tree_view/tree_view';
	export type EuiTreeViewItemProps = Omit<HTMLAttributes<HTMLButtonElement>, 'id' | 'children'> & CommonProps & {
	    /**
	     * Required for `aria-controls` accessibility
	     */
	    id: string;
	    /**
	     * The main button content
	     */
	    label: ReactNode;
	    /**
	     * Used to render nested `EuiTreeView`s
	     */
	    children?: ReactNode;
	    /**
	     * Optional icon to render. Pass, e.g., `<EuiIcon />` or `<EuiToken />`
	     */
	    icon?: ReactNode;
	    /**
	     * Renders an arrow if `children` exists. Otherwise renders a blank icon
	     */
	    hasArrow?: boolean;
	    /**
	     * Adds a targetable modifier class
	     */
	    isActive?: boolean;
	    /**
	     * Sets the `aria-expanded` attribute
	     */
	    isExpanded?: boolean;
	    /**
	     * Determines default or compressed display
	     */
	    display?: EuiTreeViewProps['display'];
	    buttonRef?: Ref<HTMLButtonElement>;
	    /**
	     * Optional extra props to pass to the wrapping `<li>`
	     */
	    wrapperProps?: HTMLAttributes<HTMLLIElement>;
	};
	export const EuiTreeViewItem: FunctionComponent<EuiTreeViewItemProps>;

}
declare module '@elastic/eui/src/components/tree_view/tree_view.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTreeViewStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTreeView: import("@emotion/react").SerializedStyles;
	    default: import("@emotion/react").SerializedStyles;
	    compressed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tree_view/tree_view' {
	import React, { Component, HTMLAttributes, ContextType } from 'react';
	import { WithEuiThemeProps } from '@elastic/eui/src/services';
	import { CommonProps } from '@elastic/eui/src/components/common'; const EuiTreeViewContext: React.Context<string>;
	export interface Node {
	    /** An array of EuiTreeViewNodes to render as children
	     */
	    children?: Node[];
	    /** The readable label for the item
	     */
	    label: React.ReactNode;
	    /** A unique ID
	     */
	    id: string;
	    /** An icon to use on the left of the label
	     */
	    icon?: React.ReactElement;
	    /** Display a different icon when the item is expanded.
	    For instance, an open folder or a down arrow
	    */
	    iconWhenExpanded?: React.ReactElement;
	    /** Use an empty icon to keep items without an icon
	    lined up with their siblings
	    */
	    useEmptyIcon?: boolean;
	    /** Whether or not the item is expanded.
	     */
	    isExpanded?: boolean;
	    /** Optional class to throw on the node
	     */
	    className?: string;
	    /** Optional styles
	     */
	    css?: CommonProps['css'];
	    /** Function to call when the item is clicked.
	     The open state of the item will always be toggled.
	     */
	    callback?(): string;
	}
	export type EuiTreeViewDisplayOptions = 'default' | 'compressed';
	interface EuiTreeViewState {
	    openItems: string[];
	    activeItem: string;
	    treeID: string;
	    expandChildNodes: boolean;
	}
	export type CommonTreeProps = CommonProps & HTMLAttributes<HTMLUListElement> & {
	    /**
	     * Never accepts children directly, only through the `items` prop
	     */
	    children?: never;
	    /**
	     * An array of EuiTreeViewNodes
	     */
	    items: Node[];
	    /**
	     * Optionally use a variation with smaller text and icon sizes
	     * @default default
	     */
	    display?: EuiTreeViewDisplayOptions;
	    /**
	     * Set all items to open on initial load
	     */
	    expandByDefault?: boolean;
	    /**
	     * Display expansion arrows next to all items
	     * that contain children
	     */
	    showExpansionArrows?: boolean;
	};
	export type EuiTreeViewProps = Omit<CommonTreeProps, 'aria-label' | 'aria-labelledby'> & ({
	    'aria-label': string;
	} | {
	    'aria-labelledby': string;
	});
	export class EuiTreeViewClass extends Component<EuiTreeViewProps & WithEuiThemeProps, EuiTreeViewState> {
	    treeIdGenerator: (idSuffix?: string) => string;
	    static contextType: React.Context<string>;
	    context: ContextType<typeof EuiTreeViewContext>;
	    isNested: boolean;
	    constructor(props: EuiTreeViewProps & WithEuiThemeProps, context?: ContextType<typeof EuiTreeViewContext>);
	    componentDidUpdate(prevProps: EuiTreeViewProps): void;
	    buttonRef: Array<HTMLButtonElement | undefined>;
	    setButtonRef: (ref: HTMLButtonElement | HTMLAnchorElement | null, index: number) => void;
	    handleNodeClick: (node: Node, ignoreCallback?: boolean) => void;
	    isNodeOpen: (node: Node) => boolean;
	    onKeyDown: (event: React.KeyboardEvent, node: Node) => void;
	    onChildrenKeydown: (event: React.KeyboardEvent, index: number) => void;
	    render(): React.JSX.Element;
	}
	export const EuiTreeView: React.ForwardRefExoticComponent<Omit<EuiTreeViewProps, "theme"> & React.RefAttributes<Omit<EuiTreeViewProps, "theme">>> & {
	    Item: React.FunctionComponent<import ("@elastic/eui/src/components/tree_view/tree_view_item").EuiTreeViewItemProps>;
	};
	export {};

}
declare module '@elastic/eui/src/components/tree_view' {
	export type { EuiTreeViewProps } from '@elastic/eui/src/components/tree_view/tree_view';
	export { EuiTreeView } from '@elastic/eui/src/components/tree_view/tree_view';

}
declare module '@elastic/eui/src/components/search_bar/search_box' {
	import { FunctionComponent } from 'react';
	import { EuiFieldSearchProps } from '@elastic/eui/src/components/form';
	import { EuiSearchBarProps } from '@elastic/eui/src/components/search_bar/search_bar';
	export interface EuiSearchBoxProps extends EuiFieldSearchProps {
	    query: string;
	    onSearch: (queryText: string) => void;
	    /**
	     * @default Search...
	     */
	    placeholder?: string;
	    hint?: {
	        id: string;
	        isVisible: boolean;
	        setIsVisible: (isVisible: boolean) => void;
	    } & EuiSearchBarProps['hint'];
	}
	export const EuiSearchBox: FunctionComponent<EuiSearchBoxProps>;

}
declare module '@elastic/eui/src/components/search_bar/query/date_format' {
	import { Moment, MomentInput } from 'moment';
	export interface EuiMoment extends Moment {
	    __eui_granularity?: GranularityType;
	    __eui_format?: string;
	}
	export interface GranularityType {
	    es: 'd' | 'w' | 'M' | 'y';
	    js: 'day' | 'week' | 'month' | 'year';
	    isSame: (d1: Moment, d2: Moment) => boolean;
	    start: (date: Moment) => Moment;
	    startOfNext: (date: Moment) => Moment;
	    iso8601: (date: Moment) => string;
	}
	interface GranularitiesType {
	    DAY: GranularityType;
	    WEEK: GranularityType;
	    MONTH: GranularityType;
	    YEAR: GranularityType;
	}
	export const Granularity: Readonly<GranularitiesType>;
	export const printIso8601: (value: MomentInput) => string;
	export const dateGranularity: (parsedDate: EuiMoment) => GranularityType;
	export const dateFormat: Readonly<{
	    parse(value: string): EuiMoment;
	    print(date: EuiMoment | MomentInput, defaultGranularity?: undefined): string;
	}>;
	export {};

}
declare module '@elastic/eui/src/components/search_bar/query/date_value' {
	import { GranularityType } from '@elastic/eui/src/components/search_bar/query/date_format';
	import moment, { MomentInput } from 'moment';
	export const DATE_TYPE = "date";
	export interface DateValue {
	    type: 'date';
	    raw: MomentInput;
	    granularity: GranularityType | undefined;
	    text: string;
	    resolve: () => moment.Moment;
	}
	export const dateValuesEqual: (v1: DateValue, v2: DateValue) => boolean;
	export const isDateValue: (value: any) => value is DateValue;
	export const dateValue: (raw: MomentInput, granularity?: GranularityType, dateFormat?: any) => DateValue | undefined;
	export const dateValueParser: (format?: Readonly<{
	    parse(value: string): import ("@elastic/eui/src/components/search_bar/query/date_format").EuiMoment;
	    print(date: import ("@elastic/eui/src/components/search_bar/query/date_format").EuiMoment | MomentInput, defaultGranularity?: undefined): string;
	}>) => (text: string) => DateValue | undefined;

}
declare module '@elastic/eui/src/components/search_bar/query/ast' {
	import { DateValue } from '@elastic/eui/src/components/search_bar/query/date_value';
	export type MatchType = 'must' | 'must_not';
	export type Value = string | number | boolean | DateValue;
	export interface IsClause {
	    type: 'is';
	    match?: MatchType;
	    flag: string;
	}
	export interface FieldClause {
	    type: 'field';
	    match?: MatchType;
	    operator: OperatorType;
	    field: string;
	    value: Value | Value[];
	}
	export interface TermClause {
	    type: 'term';
	    match?: MatchType;
	    value: Value;
	}
	export interface GroupClause {
	    type: 'group';
	    match: MatchType;
	    value: Clause[];
	}
	export type Clause = IsClause | FieldClause | TermClause | GroupClause;
	export const Match: Readonly<{
	    MUST: "must";
	    MUST_NOT: "must_not";
	    isMust(match: MatchType | undefined): match is "must";
	    isMustClause(clause: Clause): boolean;
	}>;
	export type OperatorType = 'eq' | 'exact' | 'gt' | 'gte' | 'lt' | 'lte';
	export const Operator: Readonly<{
	    EQ: "eq";
	    EXACT: "exact";
	    GT: "gt";
	    GTE: "gte";
	    LT: "lt";
	    LTE: "lte";
	    isEQ(match: OperatorType | undefined): match is "eq";
	    isEQClause(clause: Clause): boolean;
	    isEXACT(match: OperatorType | undefined): match is "exact";
	    isEXACTClause(clause: Clause): boolean;
	    isRange(match: OperatorType | undefined): match is "gt" | "gte" | "lt" | "lte";
	    isRangeClause(clause: Clause): boolean;
	    isGT(match: OperatorType | undefined): match is "gt";
	    isGTClause(clause: Clause): boolean;
	    isGTE(match: OperatorType | undefined): match is "gte";
	    isGTEClause(clause: Clause): boolean;
	    isLT(match: OperatorType | undefined): match is "lt";
	    isLTClause(clause: Clause): boolean;
	    isLTE(match: OperatorType | undefined): match is "lte";
	    isLTEClause(clause: Clause): boolean;
	}>;
	/**
	 * The AST structure is an array of clauses. There are 3 types of clauses that are supported:
	 *
	 * :term:
	 * Holds a VALUE and an OCCUR. The OCCUR indicates whether the value must match or must not match. Default
	 * clauses are not associated with any specific field - when executing the search, one can specify what are
	 * the default fields that the default clauses will be matched against.
	 *
	 * :field:
	 * Like the `term` clause, holds a VALUE and an MATCH, but this clause also specifies the field that the
	 * value will be matched against.
	 *
	 * :is:
	 * Holds a FLAG and indicates whether this flag must be applied or must not be applied. Typically this clause
	 * matches against boolean values of a record (e.g. "is:online", "is:internal", "is:on", etc..)
	 *
	 * This AST is immutable - every "mutating" operation returns a newly mutated AST.
	 */
	export class _AST {
	    private readonly _clauses;
	    private readonly _indexedClauses;
	    static create(clauses: Clause[]): _AST;
	    constructor(clauses?: Clause[]);
	    get clauses(): Clause[];
	    getTermClauses(): TermClause[];
	    getTermClause(value: Value): TermClause | undefined;
	    getFieldNames(): string[];
	    getFieldClauses(field?: string): FieldClause[];
	    getFieldClause(field: string, predicate: (c: FieldClause) => boolean): FieldClause | undefined;
	    hasOrFieldClause(field: string, value?: Value): boolean;
	    getOrFieldClause(field: string, value?: Value, must?: boolean, operator?: OperatorType): FieldClause | undefined;
	    addOrFieldValue(field: string, value: Value, must?: boolean, operator?: OperatorType): _AST;
	    removeOrFieldValue(field: string, value: Value): _AST;
	    removeOrFieldClauses(field: string): _AST;
	    hasSimpleFieldClause(field: string, value?: Value): boolean;
	    getSimpleFieldClause(field: string, value?: Value): FieldClause | undefined;
	    addSimpleFieldValue(field: string, value: Value, must?: boolean, operator?: OperatorType): _AST;
	    removeSimpleFieldValue(field: string, value: Value): _AST;
	    removeSimpleFieldClauses(field: string): _AST;
	    getIsClauses(): IsClause[];
	    getIsClause(flag: string): IsClause;
	    removeIsClause(flag: string): _AST;
	    removeIsClauses(): _AST;
	    removeAllClauses(): _AST;
	    getGroupClauses(): GroupClause[];
	    /**
	     * Creates and returns a new AST with the given clause added to the current clauses. If
	     * the current clauses already include a similar clause, it will be (in-place) replaced by
	     * the given clause. Whether a clause is similar to the given one depends on the type of the clause.
	     * Two clauses are similar if:
	     *
	     * - they are both of the same type
	     * - if they are `default` clauses, they must have the same value
	     * - if they are `term` clauses, they must have the same fields and values
	     * - if they are `is` clauses, they must have the same flags
	     *
	     * The reasoning behind not including the `match` attributes of the clauses in the rules above, stems
	     * in the fact that the AST clauses are ANDed, and having two similar clauses with two different
	     * match attributes creates a logically contradicted AST (e.g. what does it mean to
	     * "(must have x) AND (must not have x)"?)
	     *
	     * note:  in-place replacement means the given clause will be placed in the same position as the one it
	     *        replaced
	     */
	    addClause(newClause: Clause): _AST;
	}
	export const AST: Readonly<{
	    Match: Readonly<{
	        MUST: "must";
	        MUST_NOT: "must_not";
	        isMust(match: MatchType | undefined): match is "must";
	        isMustClause(clause: Clause): boolean;
	    }>;
	    Operator: Readonly<{
	        EQ: "eq";
	        EXACT: "exact";
	        GT: "gt";
	        GTE: "gte";
	        LT: "lt";
	        LTE: "lte";
	        isEQ(match: OperatorType | undefined): match is "eq";
	        isEQClause(clause: Clause): boolean;
	        isEXACT(match: OperatorType | undefined): match is "exact";
	        isEXACTClause(clause: Clause): boolean;
	        isRange(match: OperatorType | undefined): match is "gt" | "gte" | "lt" | "lte";
	        isRangeClause(clause: Clause): boolean;
	        isGT(match: OperatorType | undefined): match is "gt";
	        isGTClause(clause: Clause): boolean;
	        isGTE(match: OperatorType | undefined): match is "gte";
	        isGTEClause(clause: Clause): boolean;
	        isLT(match: OperatorType | undefined): match is "lt";
	        isLTClause(clause: Clause): boolean;
	        isLTE(match: OperatorType | undefined): match is "lte";
	        isLTEClause(clause: Clause): boolean;
	    }>;
	    Term: Readonly<{
	        TYPE: "term";
	        isInstance: (clause: Clause) => clause is TermClause;
	        must: (value: Value) => {
	            type: "term";
	            value: Value;
	            match: "must";
	        };
	        mustNot: (value: Value) => {
	            type: "term";
	            value: Value;
	            match: "must_not";
	        };
	    }>;
	    Group: Readonly<{
	        TYPE: "group";
	        isInstance: (clause: Clause) => clause is GroupClause;
	        must: (value: Clause[]) => {
	            type: "group";
	            value: Clause[];
	            match: "must";
	        };
	        mustNot: (value: Clause[]) => {
	            type: "group";
	            value: Clause[];
	            match: "must_not";
	        };
	    }>;
	    Field: Readonly<{
	        TYPE: "field";
	        isInstance: (clause: Clause) => clause is FieldClause;
	        must: {
	            eq: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "eq";
	            };
	            exact: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "exact";
	            };
	            gt: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "gt";
	            };
	            gte: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "gte";
	            };
	            lt: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "lt";
	            };
	            lte: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must";
	                operator: "lte";
	            };
	        };
	        mustNot: {
	            eq: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "eq";
	            };
	            exact: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "exact";
	            };
	            gt: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "gt";
	            };
	            gte: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "gte";
	            };
	            lt: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "lt";
	            };
	            lte: (field: string, value: Value | Value[]) => {
	                type: "field";
	                field: string;
	                value: Value | Value[];
	                match: "must_not";
	                operator: "lte";
	            };
	        };
	    }>;
	    Is: Readonly<{
	        TYPE: "is";
	        isInstance: (clause: Clause) => clause is IsClause;
	        must: (flag: string) => {
	            type: "is";
	            flag: string;
	            match: "must";
	        };
	        mustNot: (flag: string) => {
	            type: "is";
	            flag: string;
	            match: "must_not";
	        };
	    }>;
	    create: (clauses: Clause[]) => _AST;
	}>;

}
declare module '@elastic/eui/src/components/search_bar/query/default_syntax' {
	import { _AST, Clause } from '@elastic/eui/src/components/search_bar/query/ast';
	export interface ParseOptions {
	    dateFormat?: any;
	    schema?: {
	        strict?: boolean;
	        fields?: string[] | Record<string, any>;
	        recognizedFields?: string[];
	    };
	    escapeValue?: (value: any) => string;
	}
	export type Syntax = Readonly<{
	    printClause: (clause: Clause, text: string, options: any) => string;
	    print: (ast: _AST, options?: {}) => string;
	    parse: (query: string, options?: ParseOptions) => _AST;
	}>;
	export const defaultSyntax: Syntax;

}
declare module '@elastic/eui/src/components/search_bar/query/operators' {
	import moment from 'moment';
	import { Value } from '@elastic/eui/src/components/search_bar/query/ast';
	export type FieldValue = string | number | boolean | any[] | Date | moment.Moment | null | undefined;
	export type ClauseValue = Value | Date | moment.Moment | null | undefined;
	type Options = Partial<{
	    exactMatch: boolean;
	    ignoreCase: boolean;
	}>;
	export const eq: (fieldValue: FieldValue, clauseValue: ClauseValue, options?: Options) => boolean;
	export const exact: (fieldValue: FieldValue, clauseValue: ClauseValue, options?: {}) => boolean;
	export const gt: (fieldValue: FieldValue, clauseValue: ClauseValue) => boolean;
	export const gte: (fieldValue: FieldValue, clauseValue: ClauseValue) => boolean;
	export const lt: (fieldValue: FieldValue, clauseValue: ClauseValue) => boolean;
	export const lte: (fieldValue: FieldValue, clauseValue: ClauseValue) => boolean;
	export {};

}
declare module '@elastic/eui/src/components/search_bar/query/execute_ast' {
	import { _AST, Clause, IsClause, MatchType, Value } from '@elastic/eui/src/components/search_bar/query/ast';
	interface Explain {
	    hit: boolean;
	    type: Clause['type'];
	    field?: string;
	    value?: Value | Value[];
	    flag?: string;
	    match?: MatchType;
	    operator?: any;
	} const defaultIsClauseMatcher: <T extends object>(item: T, clause: IsClause, explain?: Explain[]) => boolean;
	export const createFilter: <T extends {}>(ast: _AST, defaultFields: string[] | undefined, isClauseMatcher?: <T_1 extends object>(item: T_1, clause: IsClause, explain?: Explain[]) => boolean, explain?: boolean) => (item: T) => boolean;
	interface Options {
	    isClauseMatcher?: typeof defaultIsClauseMatcher;
	    defaultFields?: string[];
	    explain?: boolean;
	}
	export function executeAst<T extends object>(ast: _AST, items: T[], options?: Options): T[];
	export {};

}
declare module '@elastic/eui/src/components/search_bar/query/ast_to_es_query_dsl' {
	import { OperatorType, Value, _AST } from '@elastic/eui/src/components/search_bar/query/ast';
	export interface QueryContainer {
	    bool?: BoolQuery;
	    match_all?: {};
	    match?: object;
	    match_phrase?: object;
	    range?: object;
	    term?: object;
	    simple_query_string?: object;
	}
	interface BoolQuery {
	    must?: QueryContainer[];
	    must_not?: QueryContainer[];
	    should?: QueryContainer[];
	}
	type Options = Partial<{
	    defaultFields: string[];
	    extraMustQueries: QueryContainer[];
	    extraMustNotQueries: QueryContainer[];
	    termValuesToQuery: (terms: Value[], options: {}) => QueryContainer;
	    fieldValuesToQuery: (terms: string, options: {}) => QueryContainer;
	    isFlagToQuery: (flag: string, on: boolean) => QueryContainer;
	}>;
	export const _termValuesToQuery: (values: Value[], options: Options) => {
	    simple_query_string: {
	        query: string;
	        fields?: string[];
	    };
	} | undefined;
	export const _fieldValuesToQuery: (field: string, operations: { [x in OperatorType]: Value[]; }, andOr: "and" | "or") => QueryContainer;
	export const _isFlagToQuery: (flag: string, on: boolean) => {
	    term: {
	        [x: string]: boolean;
	    };
	};
	export const astToEsQueryDsl: (ast: _AST, options?: {}) => QueryContainer;
	export {};

}
declare module '@elastic/eui/src/components/search_bar/query/ast_to_es_query_string' {
	import { _AST } from '@elastic/eui/src/components/search_bar/query/ast';
	export const astToEsQueryString: (ast: _AST) => string;

}
declare module '@elastic/eui/src/components/search_bar/query/query' {
	import { ParseOptions, Syntax } from '@elastic/eui/src/components/search_bar/query/default_syntax';
	import { _AST, Clause, OperatorType, Value } from '@elastic/eui/src/components/search_bar/query/ast';
	/**
	 * This is the consumer interface for the query - it's effectively a wrapper construct around
	 * the AST and some of its related utility functions (e.g. parsing, text representation, executing, etc...)
	 * It is immutable - all mutating operations return a new (mutated) query instance.
	 */
	export class Query {
	    static parse(text: string, options?: ParseOptions, syntax?: Syntax): Query;
	    static isMust(clause: Clause): boolean;
	    static MATCH_ALL: Query;
	    static isTerm(clause: Clause): clause is import ("@elastic/eui/src/components/search_bar/query/ast").TermClause;
	    static isIs(clause: Clause): clause is import ("@elastic/eui/src/components/search_bar/query/ast").IsClause;
	    static isField(clause: Clause): clause is import ("@elastic/eui/src/components/search_bar/query/ast").FieldClause;
	    ast: _AST;
	    text: string;
	    private syntax;
	    constructor(ast: _AST, syntax?: Syntax, text?: string);
	    hasClauses(): boolean;
	    hasSimpleFieldClause(field: string, value?: string): boolean;
	    getSimpleFieldClause(field: string, value?: Value): import ("@elastic/eui/src/components/search_bar/query/ast").FieldClause | undefined;
	    removeSimpleFieldClauses(field: string): Query;
	    addSimpleFieldValue(field: string, value: Value, must?: boolean, operator?: OperatorType): Query;
	    removeSimpleFieldValue(field: string, value: Value): Query;
	    hasOrFieldClause(field: string, value?: Value): boolean;
	    getOrFieldClause(field: string, value?: Value): import ("@elastic/eui/src/components/search_bar/query/ast").FieldClause | undefined;
	    addOrFieldValue(field: string, value: Value, must?: boolean, operator?: OperatorType): Query;
	    removeOrFieldValue(field: string, value: Value): Query;
	    removeOrFieldClauses(field: string): Query;
	    removeAllClauses(): Query;
	    hasIsClause(flag: string): boolean;
	    getIsClause(flag: string): import ("@elastic/eui/src/components/search_bar/query/ast").IsClause;
	    addMustIsClause(flag: string): Query;
	    addMustNotIsClause(flag: string): Query;
	    removeIsClause(flag: string): Query;
	    removeIsClauses(): Query;
	    /**
	     * Executes this query over the given iterable item and returns
	     * an new array of all items that matched this query. Options:
	     *
	     * defaultFields: string[]
	     *
	     *    An array of field names to match the default clauses against. When not specified, the query
	     *    will pick up all the string fields of each record and try to match against those.
	     *
	     * isClauseMatcher?: (record: any, flag: string, applied: boolean, explain?: []) => boolean
	     *
	     *    By default the 'is' clauses will try to match against boolean fields - where the flag of the clause
	     *    indicates the field name. You can change this behaviour by providing this matcher function for the
	     *    is clause. For example, if the object has a `tags` field, one can create a matcher that checks if
	     *    an object has a specific tag (e.g. "is:marketing", "is:kitchen", etc..)
	     *
	     * explain?: boolean
	     *
	     *    When set to `true`, each item in the returns array will have an `__explain` field that will hold
	     *    information about why the objects matched the query (default to `false`, mainly/only useful for
	     *    debugging)
	     */
	    static execute<T extends object>(query: string | Query, items: T[], options?: {}): T[];
	    /**
	     * Builds and returns an Elasticsearch query out this query. Options:
	     *
	     * defaultFields?: string[]
	     *
	     *    An array of field names to match the default clauses against. When not specified, the query
	     *    will pick up all the string fields of each record and try to match against those.
	     *
	     * isToQuery?: (flag: string, on: boolean) => Object (elasticsearch query object)
	     *
	     *    By default, "is" clauses will be translated to a term query where the flag is the field
	     *    and the "on" value will be the value of the field. This function lets you change this default
	     *    translation and provide your own custom one.
	     *
	     * termValuesToQuery?: (values: string[]) => Object (elasticsearch query object)
	     *
	     *    By default, "term" clauses will be translated to a "simple_query_string" query where all
	     *    the values serve as terms in the query string. This function lets you change this default
	     *    translation and provide your own custom one.
	     *
	     * fieldValuesToAndQuery?: (field: string, values: string[]) => Object (elasticsearch query object)
	     *
	     *    By default, "field" clauses will be translated to a match query where all the values serve as
	     *    terms in the query(the operator is AND). This function lets you change this default translation
	     *    and provide your own custom one.
	     */
	    static toESQuery(query: string | Query, options?: {}): import ("@elastic/eui/src/components/search_bar/query/ast_to_es_query_dsl").QueryContainer;
	    static toESQueryString(query: string | Query): string;
	}

}
declare module '@elastic/eui/src/components/search_bar/query' {
	export { Query } from '@elastic/eui/src/components/search_bar/query/query';
	export { AST } from '@elastic/eui/src/components/search_bar/query/ast';

}
declare module '@elastic/eui/src/components/search_bar/filters/is_filter' {
	import { FC } from 'react';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	export interface IsFilterConfigType {
	    type: 'is';
	    field: string;
	    name: string;
	    negatedName?: string;
	    available?: () => boolean;
	}
	export interface IsFilterProps {
	    index: number;
	    config: IsFilterConfigType;
	    query: Query;
	    onChange: (value: Query) => void;
	}
	export const IsFilter: FC<IsFilterProps>;

}
declare module '@elastic/eui/src/components/selectable/selectable_option' {
	import React, { HTMLAttributes } from 'react';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import type { EuiTextTruncateProps } from '@elastic/eui/src/components/text_truncate';
	import { EuiToolTipProps } from '@elastic/eui/src/components/tool_tip';
	export const OPTION_CHECKED_STATES: readonly ["on", "off", "mixed", undefined];
	export type EuiSelectableOptionCheckedType = (typeof OPTION_CHECKED_STATES)[number];
	export type EuiSelectableOptionBase = CommonProps & {
	    /**
	     * Visible label of option.
	     * Must be unique across items if `key` is not supplied
	     */
	    label: string;
	    /**
	     * Optionally change the searchable term by passing a different string other than the `label`.
	     * Best used when creating a custom `optionRender` to separate the label from metadata but allowing to search on both
	     */
	    searchableLabel?: string;
	    /**
	     * Must be unique across items.
	     * Will be used to match options instead of `label`
	     */
	    key?: string;
	    /**
	     * Leave `undefined` to indicate not selected. Pass a string of
	     * 'on' to indicate inclusion, 'off' to indicate exclusion,
	     * or 'mixed' to indicate inclusion for some.
	     */
	    checked?: EuiSelectableOptionCheckedType;
	    disabled?: boolean;
	    /**
	     * Optional `boolean`.
	     * Set to `true` to indicate object is just a grouping label, not a selectable item
	     */
	    isGroupLabel?: false;
	    /**
	     * Node to add between the selection icon and the label
	     */
	    prepend?: React.ReactNode;
	    /**
	     * Node to add to the far right of the item
	     */
	    append?: React.ReactNode;
	    ref?: (optionIndex: number) => void;
	    /**
	     * Disallow `id` from being set.
	     * Option item `id`s are coordinated at a higher level for a11y reasons.
	     */
	    id?: never;
	    /**
	     * Option data to pass through to the `renderOptions` element.
	     * Bypass `EuiSelectableItem` and avoid DOM attribute warnings.
	     */
	    data?: {
	        [key: string]: any;
	    };
	    /**
	     * How to handle long text within the item.
	     * Wrapping only works if `isVirtualization` is false.
	     * @default 'truncate'
	     */
	    textWrap?: 'truncate' | 'wrap';
	    /**
	     * If textWrap is set to `truncate`, you can pass a custom truncation configuration
	     * that accepts any [EuiTextTruncate](/#/utilities/text-truncation) prop except for
	     * `text` and `children`.
	     *
	     * Note: when searching, custom truncation props are ignored. The highlighted search
	     * text will always take precedence.
	     */
	    truncationProps?: Partial<Omit<EuiTextTruncateProps, 'text' | 'children'>>;
	    /**
	     * Optional custom tooltip content for the button
	     */
	    toolTipContent?: EuiToolTipProps['content'];
	    /**
	     * Optional props to pass to the underlying **[EuiToolTip](/#/display/tooltip)**
	     */
	    toolTipProps?: Partial<Omit<EuiToolTipProps, 'content' | 'children'>>;
	};
	type _EuiSelectableGroupLabelOption = Omit<EuiSelectableOptionBase, 'isGroupLabel'> & Exclude<HTMLAttributes<HTMLDivElement>, 'id'> & {
	    isGroupLabel: true;
	};
	export type EuiSelectableGroupLabelOption<T> = _EuiSelectableGroupLabelOption & T;
	type _EuiSelectableLIOption = EuiSelectableOptionBase & Exclude<HTMLAttributes<HTMLLIElement>, 'id'>;
	export type EuiSelectableLIOption<T> = _EuiSelectableLIOption & T;
	export type EuiSelectableOption<T = {}> = ExclusiveUnion<EuiSelectableGroupLabelOption<T>, EuiSelectableLIOption<T>>;
	export {};

}
declare module '@elastic/eui/src/components/selectable/matching_options' {
	import { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	import { EuiSelectableOptionMatcher } from '@elastic/eui/src/components/selectable/selectable';
	type SelectableOptions<T> = Array<EuiSelectableOption<T>>;
	interface GetMatchingOptionsArgs<TOption> {
	    /**
	     * All available options to match against
	     */
	    options: SelectableOptions<TOption>;
	    /**
	     * String to match option.label || option.searchableLabel against
	     */
	    searchValue: string;
	    /**
	     * Async?
	     */
	    isPreFiltered: boolean;
	    /**
	     * To exclude selected options from the search list,
	     * pass the array of selected options
	     */
	    selectedOptions?: SelectableOptions<TOption>;
	    /**
	     * Option matcher function passed to EuiSelectable or the default matcher
	     */
	    optionMatcher: EuiSelectableOptionMatcher<TOption>;
	}
	export const getMatchingOptions: <TOption>({ searchValue, options, isPreFiltered, selectedOptions, optionMatcher, }: GetMatchingOptionsArgs<TOption>) => SelectableOptions<TOption>;
	/**
	 * Partial string equality option matcher for EuiSelectable
	 * It matches all options with labels including the searched string.
	 */
	export const createPartialStringEqualityOptionMatcher: <TOption>() => EuiSelectableOptionMatcher<TOption>;
	export {};

}
declare module '@elastic/eui/src/components/selectable/selectable_search/selectable_search' {
	import React from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFieldSearchProps } from '@elastic/eui/src/components/form';
	import { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	import type { EuiSelectableOptionMatcher } from '@elastic/eui/src/components/selectable/selectable';
	export type EuiSelectableSearchProps<T> = CommonProps & Omit<EuiFieldSearchProps, 'onChange' | 'onSearch' | 'incremental'> & {
	    /**
	     * Passes back (searchValue, matchingOptions)
	     */
	    onChange: (searchValue: string, matchingOptions: Array<EuiSelectableOption<T>>) => void;
	};
	export type _EuiSelectableSearchProps<T> = EuiSelectableSearchProps<T> & {
	    options: Array<EuiSelectableOption<T>>;
	    /**
	     * Search value state managed by parent EuiSelectable
	     */
	    value: string;
	    /**
	     * The id of the visible list to create the appropriate aria controls
	     */
	    listId?: string;
	    isPreFiltered: boolean;
	    /**
	     * Option matcher function
	     */
	    optionMatcher: EuiSelectableOptionMatcher<T>;
	};
	export const EuiSelectableSearch: <T>({ onChange: onChangeCallback, options, value, placeholder, isPreFiltered, listId, className, optionMatcher, compressed, ...rest }: _EuiSelectableSearchProps<T>) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/selectable/selectable_search' {
	export type { EuiSelectableSearchProps } from '@elastic/eui/src/components/selectable/selectable_search/selectable_search';
	export { EuiSelectableSearch } from '@elastic/eui/src/components/selectable/selectable_search/selectable_search';

}
declare module '@elastic/eui/src/components/selectable/selectable_message/selectable_message.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSelectableMessageStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSelectableMessage: import("@emotion/react").SerializedStyles;
	    bordered: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/selectable/selectable_message/selectable_message' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiSelectableMessageProps = Omit<HTMLAttributes<HTMLDivElement>, 'color'> & CommonProps & {
	    /**
	     * Match this to the `listProps.bordered` property of your `EuiSelectable` instance
	     */
	    bordered?: boolean;
	};
	export const EuiSelectableMessage: FunctionComponent<EuiSelectableMessageProps>;

}
declare module '@elastic/eui/src/components/selectable/selectable_message' {
	export type { EuiSelectableMessageProps } from '@elastic/eui/src/components/selectable/selectable_message/selectable_message';
	export { EuiSelectableMessage } from '@elastic/eui/src/components/selectable/selectable_message/selectable_message';

}
declare module '@elastic/eui/src/components/selectable/selectable_list/selectable_list_item' {
	import React, { FunctionComponent, LiHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiBadgeProps } from '@elastic/eui/src/components/badge';
	import type { EuiSelectableOption, EuiSelectableOptionCheckedType } from '@elastic/eui/src/components/selectable/selectable_option';
	export type EuiSelectableListItemProps = LiHTMLAttributes<HTMLLIElement> & CommonProps & {
	    children?: React.ReactNode;
	    /**
	     * Applies an icon and visual styling to activated items
	     */
	    checked?: EuiSelectableOptionCheckedType;
	    /**
	     * Shows icons based on `checked` type
	     */
	    showIcons?: boolean;
	    /**
	     * Highlights the item for pseudo focus
	     */
	    isFocused?: boolean;
	    disabled?: boolean;
	    prepend?: React.ReactNode;
	    append?: React.ReactNode;
	    allowExclusions?: boolean;
	    singleSelection?: boolean;
	    /**
	     * When enabled by setting to either `true` or passing custom a custom badge,
	     * shows a hollow badge as an append (far right) when the item is focused.
	     * The default content when `true` is `↩ to select/deselect/include/exclude`
	     */
	    onFocusBadge?: boolean | EuiBadgeProps;
	    /**
	     * Whether the `EuiSelectable` instance is searchable.
	     * When true, the Space key will not toggle selection, as it will type into the search box instead. Screen reader instructions will be added instructing users to use the Enter key to select items.
	     * When false, the Space key will toggle item selection. No extra screen reader instructions will be added, as Space to toggle is a generally standard for most select/checked elements.
	     */
	    searchable?: boolean;
	    /**
	     * Attribute applied the option `<li>`.
	     * If set to a role that allows [aria-checked](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-checked),
	     * `aria-checked` will be automatically configured.
	     */
	    role?: LiHTMLAttributes<HTMLLIElement>['role'];
	    /**
	     * How to handle long text within the item.
	     * Wrapping only works if virtualization is off.
	     */
	    textWrap?: EuiSelectableOption['textWrap'];
	    /**
	     * Optional custom tooltip content for the button
	     */
	    toolTipContent?: EuiSelectableOption['toolTipContent'];
	    /**
	     * Optional props to pass to the underlying **[EuiToolTip](/#/display/tooltip)**
	     */
	    toolTipProps?: EuiSelectableOption['toolTipProps'];
	};
	export const EuiSelectableListItem: FunctionComponent<EuiSelectableListItemProps>;

}
declare module '@elastic/eui/src/components/selectable/selectable_list/selectable_list' {
	import React, { Component, HTMLAttributes, ReactNode, CSSProperties } from 'react';
	import { VariableSizeList, ListProps, ListChildComponentProps as ReactWindowListChildComponentProps } from 'react-window';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiAutoSizeHorizontal } from '@elastic/eui/src/components/auto_sizer';
	import type { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	import type { EuiSelectableOnChangeEvent, EuiSelectableProps } from '@elastic/eui/src/components/selectable/selectable';
	import { EuiSelectableListItemProps } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list_item';
	interface ListChildComponentProps<T> extends Omit<ReactWindowListChildComponentProps, 'style'> {
	    data: Array<EuiSelectableOption<T>>;
	    style?: CSSProperties;
	}
	export type EuiSelectableOptionsListVirtualizedProps = ExclusiveUnion<{
	    /**
	     * Use virtualized rendering for list items with `react-window`.
	     * Sets each row's height to the value of `rowHeight`.
	     */
	    isVirtualized?: true;
	    /**
	     *  The height of each option in pixels. Defaults to `32`.
	     *  Has no effect if `isVirtualized=false`.
	     */
	    rowHeight: number;
	}, {
	    isVirtualized: false;
	}>;
	export type EuiSelectableOptionsListProps = CommonProps & HTMLAttributes<HTMLDivElement> & {
	    /**
	     * The index of the option to be highlighted as pseudo-focused;
	     * Good for use when only one selection is allowed and needing to open
	     * directly to that option
	     */
	    activeOptionIndex?: number;
	    /**
	     * Show the check/cross selection indicators
	     */
	    showIcons?: boolean;
	    singleSelection?: 'always' | boolean;
	    /**
	     * Any props to send specifically to the react-window `FixedSizeList`
	     */
	    windowProps?: Partial<ListProps>;
	    /**
	     * Adds a border around the list to indicate the bounds;
	     * Useful when the list scrolls, otherwise use your own container
	     */
	    bordered?: boolean;
	    /**
	     * When enabled by setting to either `true` or passing custom text,
	     * shows a hollow badge as an append (far right) when the item is focused.
	     * The default content when `true` is `↩ to select/deselect/include/exclude`
	     */
	    onFocusBadge?: EuiSelectableListItemProps['onFocusBadge'];
	    /**
	     * Optional list container padding.
	     * @default 'none'
	     */
	    paddingSize?: 'none' | 's';
	    /**
	     * How to handle long text within the item.
	     * Wrapping only works if virtualization is off.
	     */
	    textWrap?: EuiSelectableListItemProps['textWrap'];
	    /**
	     * If textWrap is set to `truncate`, you can pass a custom truncation configuration
	     * that accepts any [EuiTextTruncate](/#/utilities/text-truncation) prop except for
	     * `text` and `children`.
	     *
	     * Note: when searching, custom truncation props are ignored. The highlighted search
	     * text will always take precedence.
	     */
	    truncationProps?: EuiSelectableOption['truncationProps'];
	} & EuiSelectableOptionsListVirtualizedProps;
	export type EuiSelectableListProps<T> = EuiSelectableOptionsListProps & {
	    /**
	     * All possible options
	     */
	    options: Array<EuiSelectableOption<T>>;
	    /**
	     * Filtered options list (if applicable)
	     */
	    visibleOptions?: Array<EuiSelectableOption<T>>;
	    /**
	     * Search value to highlight on the option render
	     */
	    searchValue: string;
	    /**
	     * Returns the array of options with altered checked state, the click/keyboard event,
	     * and the option that triggered the click/keyboard event
	     */
	    onOptionClick: (options: Array<EuiSelectableOption<T>>, event: EuiSelectableOnChangeEvent, clickedOption: EuiSelectableOption<T>) => void;
	    /**
	     * Custom render for the label portion of the option;
	     * Takes (option, searchValue), returns ReactNode
	     */
	    renderOption?: (option: EuiSelectableOption<T>, searchValue: string) => ReactNode;
	    /**
	     * Sets the max height in pixels or pass `full` to allow
	     * the whole group to fill the height of its container and
	     * allows the list grow as well
	     */
	    height?: number | 'full';
	    /**
	     * Allow cycling through the on, off and undefined state of option.checked
	     * and not just on and undefined
	     */
	    allowExclusions?: boolean;
	    searchable?: boolean;
	    isPreFiltered?: EuiSelectableProps['isPreFiltered'];
	    makeOptionId: (index: number | undefined) => string;
	    listId: string;
	    setActiveOptionIndex: (index: number, cb?: () => void) => void;
	};
	type State<T> = {
	    defaultOptionWidth: number;
	    optionArray: Array<EuiSelectableOption<T>>;
	    itemData: Record<number, EuiSelectableOption<T>>;
	    ariaPosInSetMap: Record<number, number>;
	    ariaSetSize: number;
	};
	export class EuiSelectableList<T> extends Component<EuiSelectableListProps<T>, State<T>> {
	    static defaultProps: {
	        rowHeight: number;
	        paddingSize: "none";
	        searchValue: string;
	        isVirtualized: true;
	    };
	    private animationFrameId;
	    private listRowRerender;
	    constructor(props: EuiSelectableListProps<T>);
	    listRef: VariableSizeList | null;
	    listBoxRef: HTMLUListElement | null;
	    componentWillUnmount(): void;
	    setListRef: (ref: VariableSizeList | null) => void;
	    removeScrollableTabStop: (ref: HTMLDivElement | null) => void;
	    setListBoxRef: (ref: HTMLUListElement | null) => void;
	    shouldComponentUpdate(nextProps: Readonly<EuiSelectableListProps<T>>): boolean;
	    componentDidUpdate(prevProps: EuiSelectableListProps<T>): void;
	    calculateAriaSetAttrs: (optionArray: State<T>["optionArray"]) => {
	        ariaPosInSetMap: Record<number, number>;
	        ariaSetSize: number;
	    };
	    getItemSize: (index: number) => number;
	    ListRow: React.MemoExoticComponent<({ data, index, style }: ListChildComponentProps<T>) => React.JSX.Element>;
	    renderVirtualizedList: (listClasses: string) => React.JSX.Element | null;
	    forceVirtualizedListRowRerender: () => void;
	    focusBadgeOffset: number;
	    calculateDefaultOptionWidth: ({ width: containerWidth, }: EuiAutoSizeHorizontal) => void;
	    getTruncationProps: (option: EuiSelectableOption, highlightSearch: boolean, isFocused: boolean) => {
	        prefix?: string | undefined;
	        slot?: string | undefined;
	        style?: CSSProperties | undefined;
	        title?: string | undefined;
	        width: number;
	        color?: string | undefined;
	        content?: string | undefined;
	        hidden?: boolean | undefined;
	        css?: import("@emotion/serialize").Interpolation<import("@emotion/react").Theme>;
	        onClick?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseDown?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseUp?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseEnter?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseLeave?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOut?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseMove?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOver?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onPointerDown?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerUp?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerEnter?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerLeave?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerMove?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOver?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onTouchStart?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchEnd?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchMove?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onKeyDown?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyUp?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyPress?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onSubmit?: React.FormEventHandler<HTMLDivElement> | undefined;
	        "aria-disabled"?: (boolean | "false" | "true") | undefined;
	        translate?: "yes" | "no" | undefined;
	        property?: string | undefined;
	        className?: string | undefined;
	        defaultChecked?: boolean | undefined;
	        defaultValue?: string | number | readonly string[] | undefined;
	        suppressContentEditableWarning?: boolean | undefined;
	        suppressHydrationWarning?: boolean | undefined;
	        accessKey?: string | undefined;
	        autoFocus?: boolean | undefined;
	        contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
	        contextMenu?: string | undefined;
	        dir?: string | undefined;
	        draggable?: (boolean | "false" | "true") | undefined;
	        id?: string | undefined;
	        lang?: string | undefined;
	        nonce?: string | undefined;
	        spellCheck?: (boolean | "false" | "true") | undefined;
	        tabIndex?: number | undefined;
	        radioGroup?: string | undefined;
	        role?: React.AriaRole | undefined;
	        about?: string | undefined;
	        datatype?: string | undefined;
	        inlist?: any;
	        rel?: string | undefined;
	        resource?: string | undefined;
	        rev?: string | undefined;
	        typeof?: string | undefined;
	        vocab?: string | undefined;
	        autoCapitalize?: string | undefined;
	        autoCorrect?: string | undefined;
	        autoSave?: string | undefined;
	        itemProp?: string | undefined;
	        itemScope?: boolean | undefined;
	        itemType?: string | undefined;
	        itemID?: string | undefined;
	        itemRef?: string | undefined;
	        results?: number | undefined;
	        security?: string | undefined;
	        unselectable?: "on" | "off" | undefined;
	        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
	        is?: string | undefined;
	        "aria-activedescendant"?: string | undefined;
	        "aria-atomic"?: (boolean | "false" | "true") | undefined;
	        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
	        "aria-braillelabel"?: string | undefined;
	        "aria-brailleroledescription"?: string | undefined;
	        "aria-busy"?: (boolean | "false" | "true") | undefined;
	        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
	        "aria-colcount"?: number | undefined;
	        "aria-colindex"?: number | undefined;
	        "aria-colindextext"?: string | undefined;
	        "aria-colspan"?: number | undefined;
	        "aria-controls"?: string | undefined;
	        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
	        "aria-describedby"?: string | undefined;
	        "aria-description"?: string | undefined;
	        "aria-details"?: string | undefined;
	        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
	        "aria-errormessage"?: string | undefined;
	        "aria-expanded"?: (boolean | "false" | "true") | undefined;
	        "aria-flowto"?: string | undefined;
	        "aria-grabbed"?: (boolean | "false" | "true") | undefined;
	        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
	        "aria-hidden"?: (boolean | "false" | "true") | undefined;
	        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
	        "aria-keyshortcuts"?: string | undefined;
	        "aria-label"?: string | undefined;
	        "aria-labelledby"?: string | undefined;
	        "aria-level"?: number | undefined;
	        "aria-live"?: "off" | "assertive" | "polite" | undefined;
	        "aria-modal"?: (boolean | "false" | "true") | undefined;
	        "aria-multiline"?: (boolean | "false" | "true") | undefined;
	        "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
	        "aria-orientation"?: "horizontal" | "vertical" | undefined;
	        "aria-owns"?: string | undefined;
	        "aria-placeholder"?: string | undefined;
	        "aria-posinset"?: number | undefined;
	        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
	        "aria-readonly"?: (boolean | "false" | "true") | undefined;
	        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
	        "aria-required"?: (boolean | "false" | "true") | undefined;
	        "aria-roledescription"?: string | undefined;
	        "aria-rowcount"?: number | undefined;
	        "aria-rowindex"?: number | undefined;
	        "aria-rowindextext"?: string | undefined;
	        "aria-rowspan"?: number | undefined;
	        "aria-selected"?: (boolean | "false" | "true") | undefined;
	        "aria-setsize"?: number | undefined;
	        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
	        "aria-valuemax"?: number | undefined;
	        "aria-valuemin"?: number | undefined;
	        "aria-valuenow"?: number | undefined;
	        "aria-valuetext"?: string | undefined;
	        dangerouslySetInnerHTML?: {
	            __html: string | TrustedHTML;
	        } | undefined;
	        onCopy?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCopyCapture?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCut?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCutCapture?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onPaste?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onPasteCapture?: React.ClipboardEventHandler<HTMLDivElement> | undefined;
	        onCompositionEnd?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionEndCapture?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionStart?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionStartCapture?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionUpdate?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLDivElement> | undefined;
	        onFocus?: React.FocusEventHandler<HTMLDivElement> | undefined;
	        onFocusCapture?: React.FocusEventHandler<HTMLDivElement> | undefined;
	        onBlur?: React.FocusEventHandler<HTMLDivElement> | undefined;
	        onBlurCapture?: React.FocusEventHandler<HTMLDivElement> | undefined;
	        onChange?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onChangeCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onBeforeInput?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onBeforeInputCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onInput?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onInputCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onReset?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onResetCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onSubmitCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onInvalid?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onInvalidCapture?: React.FormEventHandler<HTMLDivElement> | undefined;
	        onLoad?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onError?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onErrorCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onKeyDownCapture?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyPressCapture?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onKeyUpCapture?: React.KeyboardEventHandler<HTMLDivElement> | undefined;
	        onAbort?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onAbortCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlay?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayThrough?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onCanPlayThroughCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onDurationChange?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onDurationChangeCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEmptied?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEmptiedCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEncrypted?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEncryptedCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEnded?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onEndedCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedData?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedDataCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedMetadata?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadedMetadataCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadStart?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onLoadStartCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPause?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPauseCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPlay?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPlayCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPlaying?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onPlayingCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onProgress?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onProgressCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onRateChange?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onRateChangeCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onResize?: (width: number) => void;
	        onResizeCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSeeked?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSeekedCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSeeking?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSeekingCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onStalled?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onStalledCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSuspend?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSuspendCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onTimeUpdate?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onTimeUpdateCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onVolumeChange?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onVolumeChangeCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onWaiting?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onWaitingCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onAuxClick?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onAuxClickCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onClickCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onContextMenu?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onContextMenuCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onDoubleClick?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onDoubleClickCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onDrag?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnd?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragEndCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnter?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragEnterCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragExit?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragExitCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragLeave?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragLeaveCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragOver?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragOverCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragStart?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDragStartCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDrop?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onDropCapture?: React.DragEventHandler<HTMLDivElement> | undefined;
	        onMouseDownCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseMoveCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOutCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseOverCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onMouseUpCapture?: React.MouseEventHandler<HTMLDivElement> | undefined;
	        onSelect?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onSelectCapture?: React.ReactEventHandler<HTMLDivElement> | undefined;
	        onTouchCancel?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchCancelCapture?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchEndCapture?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchMoveCapture?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onTouchStartCapture?: React.TouchEventHandler<HTMLDivElement> | undefined;
	        onPointerDownCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerMoveCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerUpCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerCancel?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerCancelCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOverCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOut?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onPointerOutCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onGotPointerCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onLostPointerCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLDivElement> | undefined;
	        onScroll?: React.UIEventHandler<HTMLDivElement> | undefined;
	        onScrollCapture?: React.UIEventHandler<HTMLDivElement> | undefined;
	        onWheel?: React.WheelEventHandler<HTMLDivElement> | undefined;
	        onWheelCapture?: React.WheelEventHandler<HTMLDivElement> | undefined;
	        onAnimationStart?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationStartCapture?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationEnd?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationEndCapture?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationIteration?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onAnimationIterationCapture?: React.AnimationEventHandler<HTMLDivElement> | undefined;
	        onTransitionEnd?: React.TransitionEventHandler<HTMLDivElement> | undefined;
	        onTransitionEndCapture?: React.TransitionEventHandler<HTMLDivElement> | undefined;
	        'data-test-subj'?: string;
	        ellipsis?: string;
	        truncation?: import ("@elastic/eui/src/components/text_truncate").EuiTextTruncationTypes;
	        truncationOffset?: number;
	        truncationPosition?: number;
	        calculationDelayMs?: number;
	    } | undefined;
	    renderSearchedText: (text: string, truncationProps?: EuiSelectableOptionsListProps["truncationProps"]) => React.JSX.Element;
	    renderTruncatedText: (text: string, truncationProps?: EuiSelectableOptionsListProps["truncationProps"]) => React.JSX.Element;
	    render(): React.JSX.Element;
	    onAddOrRemoveOption: (option: EuiSelectableOption<T>, event: EuiSelectableOnChangeEvent) => void;
	    private onAddOption;
	    private onRemoveOption;
	    private onExcludeOption;
	}
	export {};

}
declare module '@elastic/eui/src/components/selectable/selectable_list' {
	export type { EuiSelectableListProps, EuiSelectableOptionsListProps, EuiSelectableOptionsListVirtualizedProps, } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list';
	export { EuiSelectableList } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list';
	export type { EuiSelectableListItemProps } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list_item';
	export { EuiSelectableListItem } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list_item';

}
declare module '@elastic/eui/src/components/selectable/selectable.styles' {
	export const euiSelectableStyles: {
	    euiSelectable: import("@emotion/react").SerializedStyles;
	    fullHeight: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/selectable/selectable' {
	import React, { Component, HTMLAttributes, ReactNode, ReactElement, KeyboardEvent, MouseEvent, FocusEvent } from 'react';
	import { Align } from 'react-window';
	import { CommonProps, ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiSelectableSearch } from '@elastic/eui/src/components/selectable/selectable_search';
	import { EuiSelectableSearchProps } from '@elastic/eui/src/components/selectable/selectable_search/selectable_search';
	import { EuiSelectableMessage } from '@elastic/eui/src/components/selectable/selectable_message';
	import { EuiSelectableList } from '@elastic/eui/src/components/selectable/selectable_list';
	import { EuiSelectableOptionsListProps } from '@elastic/eui/src/components/selectable/selectable_list/selectable_list';
	import { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	export type EuiSelectableOnChangeEvent = KeyboardEvent | MouseEvent;
	type RequiredEuiSelectableOptionsListProps = Omit<EuiSelectableOptionsListProps, keyof (typeof EuiSelectableList)['defaultProps']>;
	type OptionalEuiSelectableOptionsListProps = Omit<EuiSelectableOptionsListProps, keyof RequiredEuiSelectableOptionsListProps>;
	type EuiSelectableOptionsListPropsWithDefaults = RequiredEuiSelectableOptionsListProps & Partial<OptionalEuiSelectableOptionsListProps>;
	export interface EuiSelectableOptionMatcherArgs<TOption> {
	    option: EuiSelectableOption<TOption>;
	    searchValue: string;
	    normalizedSearchValue: string;
	}
	export type EuiSelectableOptionMatcher<T> = (args: EuiSelectableOptionMatcherArgs<T>) => boolean;
	/**
	 * The `searchable` prop has significant implications for a11y. When present, we effectively change from adhering to the
	 * - ARIA `listbox` spec (@see https://www.w3.org/TR/wai-aria-practices-1.2/#Listbox)
	 * - ARIA `combobox` spec (@see https://www.w3.org/TR/wai-aria-practices-1.2/#combobox)
	 *
	 * and (re)implement all relevant attributes and keyboard interactions.
	 * Take note of logic that relies on `searchable` to ensure that any modifications remain in alignment.
	 *
	 * `searchProps` can only be specified when `searchable` is `true`.
	 */
	export type EuiSelectableSearchableProps<T> = ExclusiveUnion<{
	    searchable: false;
	}, {
	    /**
	     * Hooks up a search box to filter the list (boolean)
	     */
	    searchable: true;
	    /**
	     * Passes props down to the `EuiFieldSearch`.
	     * {@link EuiSelectableSearchProps}
	     */
	    searchProps?: EuiSelectableSearchableSearchProps<T>;
	}>;
	export type EuiSelectableSearchableSearchProps<T> = Partial<EuiSelectableSearchProps<T>>;
	export type EuiSelectableProps<T = {}> = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onChange'> & EuiSelectableSearchableProps<T> & {
	    /**
	     * Function that takes the `list` node and then
	     * the `search` node (if `searchable` is applied)
	     */
	    children?: (list: ReactElement<typeof EuiSelectableMessage | typeof EuiSelectableList>, search: ReactElement<typeof EuiSelectableSearch> | undefined) => ReactNode;
	    /**
	     * Array of EuiSelectableOption objects. See {@link EuiSelectableOption}
	     */
	    options: Array<EuiSelectableOption<T>>;
	    /**
	     * Passes back the altered `options` array with selected options having `checked: 'on'`.
	     * Also passes back the React click/keyboard event as a second argument,
	     * and the option that triggered the onChange event as a third argument.
	     */
	    onChange?: (options: Array<EuiSelectableOption<T>>, event: EuiSelectableOnChangeEvent, changedOption: EuiSelectableOption<T>) => void;
	    /**
	     * Passes back the current active option whenever the user changes the currently
	     * highlighted option via keyboard navigation or searching.
	     */
	    onActiveOptionChange?: (option: EuiSelectableOption | null) => void;
	    /**
	     * Sets the single selection policy of
	     * `false`: allows multiple selection
	     * `true`: only allows one selection
	     * `always`: can and must have only one selection
	     * @default false
	     */
	    singleSelection?: EuiSelectableOptionsListProps['singleSelection'];
	    /**
	     * Allows marking options as `checked='off'` as well as `'on'`
	     */
	    allowExclusions?: boolean;
	    /**
	     * Show an loading indicator while you load and hook up your data
	     */
	    isLoading?: boolean;
	    /**
	     * Sets the max height in pixels or pass `full` to allow
	     * the whole group to fill the height of its container and
	     * allows the list grow as well
	     */
	    height?: number | 'full';
	    /**
	     * See {@link EuiSelectableOptionsListPropsWithDefaults}
	     */
	    listProps?: EuiSelectableOptionsListPropsWithDefaults;
	    /**
	     * Custom render function for each option.
	     * Returns `(option, searchValue)`
	     */
	    renderOption?: (option: EuiSelectableOption<T>, searchValue: string) => ReactNode;
	    /**
	     * Customize the loading message. Pass a string to simply change the text,
	     * or a node to replace the whole content.
	     */
	    loadingMessage?: ReactElement | string;
	    /**
	     * Customize the no matches message. Pass a string to simply change the text,
	     * or a node to replace the whole content.
	     */
	    noMatchesMessage?: ReactElement | string;
	    /**
	     * Customize the empty message. Pass a string to simply change the text,
	     * or a node to replace the whole content.
	     */
	    emptyMessage?: ReactElement | string;
	    /**
	     * Add an error message.
	     * The message will be shown when the value is not `null` or `undefined`.
	     * Pass a string to simply change the text, or a node to replace the whole content.
	     *
	     * `errorMessage={hasErrors ? 'My error message' : null}`
	     */
	    errorMessage?: ReactElement | string | null;
	    /**
	     * Control whether or not options get filtered internally (i.e., whether filtering is
	     * handled by EUI or by you, the consumer).
	     * If set to `true`, all passed `options` will be displayed regardless of the user's
	     * search input.
	     *
	     * Additionally allows passing a configuration object which enables turning off
	     * search highlighting if needed.
	     *
	     * @default false
	     */
	    isPreFiltered?: boolean | {
	        highlightSearch?: boolean;
	    };
	    /**
	     * Optional screen reader instructions to announce upon focus/interaction. This text is read out
	     * after the `EuiSelectable` label and a brief pause, but before the default keyboard instructions for
	     * interacting with a selectable are read out.
	     */
	    selectableScreenReaderText?: string;
	    /**
	     * Optional custom option matcher function
	     *
	     * @example
	     * const exactEqualityMatcher: EuiSelectableOptionMatcher = ({ option, searchValue }) => {
	     *   return option.label === searchValue;
	     * }
	     */
	    optionMatcher?: EuiSelectableOptionMatcher<T>;
	};
	export interface EuiSelectableState<T> {
	    activeOptionIndex?: number;
	    searchValue: string;
	    visibleOptions: Array<EuiSelectableOption<T>>;
	    isFocused: boolean;
	}
	export class EuiSelectable<T = {}> extends Component<EuiSelectableProps<T>, EuiSelectableState<T>> {
	    static defaultProps: {
	        options: never[];
	        singleSelection: boolean;
	        searchable: boolean;
	        isPreFiltered: boolean;
	        optionMatcher: EuiSelectableOptionMatcher<unknown>;
	    };
	    private inputRef;
	    private containerRef;
	    private optionsListRef;
	    private preventOnFocus;
	    rootId: (suffix?: string) => string;
	    messageContentId: string;
	    listId: string;
	    constructor(props: EuiSelectableProps<T>);
	    static getDerivedStateFromProps<T>(nextProps: EuiSelectableProps<T>, prevState: EuiSelectableState<T>): Partial<EuiSelectableState<T>>;
	    componentDidUpdate<T>(prevProps: EuiSelectableProps<T>, prevState: EuiSelectableState<T>): void;
	    isFocusOnSearchOrListBox: (target: EventTarget | null) => boolean | undefined;
	    onMouseDown: () => void;
	    onFocus: (event?: FocusEvent) => void;
	    onKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
	    incrementActiveOptionIndex: (amount: number) => void;
	    onSearchChange: (searchValue: string, visibleOptions: Array<EuiSelectableOption<T>>) => void;
	    onContainerBlur: (e: React.FocusEvent) => void;
	    onOptionClick: (options: Array<EuiSelectableOption<T>>, event: EuiSelectableOnChangeEvent, clickedOption: EuiSelectableOption<T>) => void;
	    scrollToItem: (index: number, align?: Align) => void;
	    makeOptionId: (index?: number) => string;
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSelectableTemplateSitewideStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSelectableTemplateSitewide: import("@emotion/react").SerializedStyles;
	    euiSelectableTemplateSitewide__optionMetasList: import("@emotion/react").SerializedStyles;
	    euiSelectableTemplateSitewide__optionMeta: import("@emotion/react").SerializedStyles;
	    metaTypes: {
	        fontWeight: string;
	        application: import("@emotion/react").SerializedStyles;
	        deployment: import("@emotion/react").SerializedStyles;
	        article: import("@emotion/react").SerializedStyles;
	        case: import("@emotion/react").SerializedStyles;
	        platform: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiSelectableTemplateSitewidePopoverStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSelectableTemplateSitewide__popover: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide_option' {
	import React from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiIconProps } from '@elastic/eui/src/components/icon';
	import { EuiAvatarProps } from '@elastic/eui/src/components/avatar';
	import { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	import { euiSelectableTemplateSitewideStyles } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide.styles';
	export interface EuiSelectableTemplateSitewideMetaData extends CommonProps {
	    /**
	     * Required to display the metadata
	     */
	    text: string;
	    /**
	     * Styles the metadata according to Elastic's schema.
	     * Can be one of 'application', 'deployment', 'article', 'case', 'platform',
	     * or a custom string to associate with your own schema.
	     * Appends the string to the class name as `euiSelectableTemplateSitewide__optionMeta--[type]`
	     */
	    type?: 'application' | 'deployment' | 'article' | 'case' | 'platform' | string;
	    /**
	     * Will wrap the meta tag in EuiHighlight to mark the portions that match the search text
	     */
	    highlightSearchString?: boolean;
	}
	/**
	 * The generic extension allows consumers to keep their data objects
	 * intact without needing to do key lookups when using `renderOption`
	 */
	export type EuiSelectableTemplateSitewideOption<T = {
	    [key: string]: any;
	}> = {
	    /**
	     * Displayed on the left (`prepend`).
	     * Object of `EuiIconProps` for display of the solution/application's logo
	     */
	    icon?: EuiIconProps;
	    /**
	     * Displayed on the right (`append`).
	     * Object of `EuiAvatarProps` for display of the space (default) or user
	     */
	    avatar?: EuiAvatarProps;
	    /**
	     * An array of inline {@link EuiSelectableTemplateSitewideMetaData} displayed beneath the label and separated by bullets.
	     */
	    meta?: EuiSelectableTemplateSitewideMetaData[];
	} & EuiSelectableOption<T>;
	export const euiSelectableTemplateSitewideFormatOptions: (options: EuiSelectableTemplateSitewideOption[], styles: ReturnType<typeof euiSelectableTemplateSitewideStyles>) => EuiSelectableTemplateSitewideOption[];
	export const euiSelectableTemplateSitewideRenderOptions: (option: EuiSelectableTemplateSitewideOption, searchValue: string) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide_popover' {
	import { CSSProperties, FunctionComponent, ReactNode } from 'react';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	import type { EuiSelectableTemplateSitewideProps } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide';
	type EuiSelectableTemplateSitewidePopoverProps = Partial<EuiPopoverProps> & {
	    search: ReactNode;
	    list: ReactNode;
	    trigger?: ReactNode;
	    title?: EuiSelectableTemplateSitewideProps['popoverTitle'];
	    footer?: EuiSelectableTemplateSitewideProps['popoverFooter'];
	    width: CSSProperties['width'];
	    isOpen: boolean;
	};
	export const EuiSelectableTemplateSitewidePopover: FunctionComponent<EuiSelectableTemplateSitewidePopoverProps>;
	export {};

}
declare module '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide' {
	import { FunctionComponent, ReactNode, CSSProperties, ReactElement } from 'react';
	import { EuiThemeColorMode } from '@elastic/eui/src/services';
	import { EuiBreakpointSize } from '@elastic/eui/src/services/breakpoint';
	import { Props as PopoverProps } from '@elastic/eui/src/components/popover/popover';
	import { EuiSelectableProps } from '@elastic/eui/src/components/selectable/selectable';
	import { EuiSelectableTemplateSitewideOption } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide_option';
	export type EuiSelectableTemplateSitewideTheme = 'default' | 'global' | EuiThemeColorMode;
	export type EuiSelectableTemplateSitewideProps = Partial<Omit<EuiSelectableProps<{
	    [key: string]: any;
	}>, 'options'>> & {
	    /**
	     * Extends the typical EuiSelectable {@link EuiSelectableTemplateSitewideOption} with the addition of pre-composed elements
	     * such as `icon`, `avatar` and `meta`
	     */
	    options: EuiSelectableTemplateSitewideOption[];
	    /**
	     * Override some of the EuiPopover props housing the list.
	     * The default width is `600`
	     */
	    popoverProps?: Partial<PopoverProps> & {
	        width?: CSSProperties['width'];
	    };
	    /**
	     * Optionally provide a title for the popover
	     */
	    popoverTitle?: ReactNode;
	    /**
	     * Optionally provide a footer for the popover
	     */
	    popoverFooter?: ReactNode;
	    /**
	     * Optionally provide a separate button for toggling the display of the popover.
	     */
	    popoverButton?: ReactElement;
	    /**
	     * Pass an array of named breakpoints for which to show the `popoverButton`.
	     * If `undefined`, the `popoverButton` will always show (if provided)
	     */
	    popoverButtonBreakpoints?: EuiBreakpointSize[];
	    /**
	     * Manually sets the color mode for the search input and popover. It supports the common `colorMode`
	     * values: `light`, `dark`, `inverse` and additionally `default` and `global`.
	     *
	     * `default` applies the local (nearest) context `colorMode`.
	     * `global` applies the global context `colorMode`
	     */
	    colorModes?: {
	        search: EuiSelectableTemplateSitewideTheme;
	        popover: EuiSelectableTemplateSitewideTheme;
	    };
	};
	export const EuiSelectableTemplateSitewide: FunctionComponent<EuiSelectableTemplateSitewideProps>;

}
declare module '@elastic/eui/src/components/selectable/selectable_templates' {
	export type { EuiSelectableTemplateSitewideProps } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide';
	export { type EuiSelectableTemplateSitewideTheme, EuiSelectableTemplateSitewide, } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide';
	export type { EuiSelectableTemplateSitewideOption, EuiSelectableTemplateSitewideMetaData, } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide_option';
	export { euiSelectableTemplateSitewideFormatOptions, euiSelectableTemplateSitewideRenderOptions, } from '@elastic/eui/src/components/selectable/selectable_templates/selectable_template_sitewide_option';

}
declare module '@elastic/eui/src/components/selectable' {
	export type { EuiSelectableProps, EuiSelectableSearchableProps, EuiSelectableSearchableSearchProps, } from '@elastic/eui/src/components/selectable/selectable';
	export { EuiSelectable } from '@elastic/eui/src/components/selectable/selectable';
	export type { EuiSelectableListProps, EuiSelectableListItemProps, EuiSelectableOptionsListProps, } from '@elastic/eui/src/components/selectable/selectable_list';
	export { EuiSelectableList, EuiSelectableListItem } from '@elastic/eui/src/components/selectable/selectable_list';
	export type { EuiSelectableMessageProps } from '@elastic/eui/src/components/selectable/selectable_message';
	export { EuiSelectableMessage } from '@elastic/eui/src/components/selectable/selectable_message';
	export type { EuiSelectableOption } from '@elastic/eui/src/components/selectable/selectable_option';
	export type { EuiSelectableSearchProps } from '@elastic/eui/src/components/selectable/selectable_search';
	export { EuiSelectableSearch } from '@elastic/eui/src/components/selectable/selectable_search';
	export type { EuiSelectableTemplateSitewideProps, EuiSelectableTemplateSitewideOption, EuiSelectableTemplateSitewideMetaData, } from '@elastic/eui/src/components/selectable/selectable_templates';
	export { EuiSelectableTemplateSitewide, euiSelectableTemplateSitewideRenderOptions, } from '@elastic/eui/src/components/selectable/selectable_templates';

}
declare module '@elastic/eui/src/components/search_bar/filters/field_value_selection_filter' {
	import React, { Component, ReactNode } from 'react';
	import { EuiSelectable } from '@elastic/eui/src/components/selectable';
	import { EuiSelectableOptionCheckedType } from '@elastic/eui/src/components/selectable/selectable_option';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	import { Clause, OperatorType, Value } from '@elastic/eui/src/components/search_bar/query/ast';
	export interface FieldValueOptionType {
	    field?: string;
	    value: Value;
	    name?: string;
	    view?: ReactNode;
	}
	type OptionsLoader = () => Promise<FieldValueOptionType[]>;
	type OptionsFilter = (name: string, query: string, options?: FieldValueOptionType[]) => boolean;
	type MultiSelect = boolean | 'and' | 'or';
	export interface FieldValueSelectionFilterConfigType {
	    type: 'field_value_selection';
	    field?: string;
	    name: string;
	    /**
	     * See {@link FieldValueOptionType}
	     */
	    options: FieldValueOptionType[] | OptionsLoader;
	    filterWith?: 'prefix' | 'includes' | OptionsFilter;
	    cache?: number;
	    multiSelect?: MultiSelect;
	    loadingMessage?: string;
	    noOptionsMessage?: string;
	    searchThreshold?: number;
	    available?: () => boolean;
	    autoClose?: boolean;
	    operator?: OperatorType;
	    autoSortOptions?: boolean;
	}
	export interface FieldValueSelectionFilterProps {
	    index: number;
	    config: FieldValueSelectionFilterConfigType;
	    query: Query;
	    onChange: (query: Query) => void;
	}
	interface State {
	    popoverOpen: boolean;
	    error: string | null;
	    options: {
	        unsorted: FieldValueOptionType[];
	        sorted: FieldValueOptionType[];
	    } | null;
	    cachedOptions?: FieldValueOptionType[] | null;
	    activeItemsCount: number;
	    lastCheckedValue?: Value;
	}
	export class FieldValueSelectionFilter extends Component<FieldValueSelectionFilterProps, State> {
	    selectableClassRef: React.RefObject<EuiSelectable<{}>>;
	    cacheTimeout: ReturnType<typeof setTimeout> | undefined;
	    constructor(props: FieldValueSelectionFilterProps);
	    closePopover(): void;
	    onButtonClick(): void;
	    loadOptions: () => Promise<void>;
	    scrollToAutoSortedOption: () => void;
	    resolveOptionName(option: FieldValueOptionType): string;
	    onOptionClick(field: string, value: Value, checked?: Omit<EuiSelectableOptionCheckedType, 'mixed'>): void;
	    get autoSortOptions(): boolean;
	    get multiSelect(): MultiSelect;
	    componentDidMount(): void;
	    componentDidUpdate(prevProps: FieldValueSelectionFilterProps): void;
	    componentWillUnmount(): void;
	    render(): React.JSX.Element;
	    resolveChecked(clause: Clause | undefined): 'on' | 'off' | undefined;
	    isActiveField(field: string | undefined): boolean;
	}
	export {};

}
declare module '@elastic/eui/src/components/search_bar/filters/field_value_toggle_filter' {
	import { FC } from 'react';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	import { OperatorType, Value } from '@elastic/eui/src/components/search_bar/query/ast';
	export interface FieldValueToggleFilterConfigType {
	    type: 'field_value_toggle';
	    field: string;
	    value: Value;
	    name: string;
	    negatedName?: string;
	    available?: () => boolean;
	    operator?: OperatorType;
	}
	export interface FieldValueToggleFilterProps {
	    index: number;
	    config: FieldValueToggleFilterConfigType;
	    query: Query;
	    onChange: (value: Query) => void;
	}
	export const FieldValueToggleFilter: FC<FieldValueToggleFilterProps>;

}
declare module '@elastic/eui/src/components/search_bar/filters/field_value_toggle_group_filter' {
	import { FC } from 'react';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	import { OperatorType } from '@elastic/eui/src/components/search_bar/query/ast';
	export interface FieldValueToggleGroupFilterItemType {
	    value: string | number | boolean;
	    name: string;
	    negatedName?: string;
	    operator?: OperatorType;
	}
	export interface FieldValueToggleGroupFilterConfigType {
	    type: 'field_value_toggle_group';
	    field: string;
	    /**
	     * See {@link FieldValueToggleGroupFilterItemType}
	     */
	    items: FieldValueToggleGroupFilterItemType[];
	    available?: () => boolean;
	}
	export interface FieldValueToggleGroupFilterProps {
	    index: number;
	    config: FieldValueToggleGroupFilterConfigType;
	    query: Query;
	    onChange: (value: Query) => void;
	}
	export const FieldValueToggleGroupFilter: FC<FieldValueToggleGroupFilterProps>;

}
declare module '@elastic/eui/src/components/search_bar/filters/custom_component_filter' {
	import React, { FC } from 'react';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	/**
	 * The props that are passed down to the custom component
	 */
	export interface CustomComponentProps {
	    query: Query;
	    onChange?: (query: Query) => void;
	}
	export interface CustomComponentFilterConfigType<T extends CustomComponentProps = CustomComponentProps> {
	    type: 'custom_component';
	    component: React.ComponentType<T>;
	    available?: () => boolean;
	}
	export interface CustomComponentFilterProps<T extends CustomComponentProps = CustomComponentProps> {
	    index: number;
	    config: CustomComponentFilterConfigType<T>;
	    query: Query;
	    onChange?: (query: Query) => void;
	}
	export const CustomComponentFilter: FC<CustomComponentFilterProps>;

}
declare module '@elastic/eui/src/components/search_bar/filters/filters' {
	import React from 'react';
	import { IsFilterConfigType } from '@elastic/eui/src/components/search_bar/filters/is_filter';
	import { FieldValueSelectionFilterConfigType } from '@elastic/eui/src/components/search_bar/filters/field_value_selection_filter';
	import { FieldValueToggleFilterConfigType } from '@elastic/eui/src/components/search_bar/filters/field_value_toggle_filter';
	import { FieldValueToggleGroupFilterConfigType } from '@elastic/eui/src/components/search_bar/filters/field_value_toggle_group_filter';
	import { CustomComponentFilterConfigType } from '@elastic/eui/src/components/search_bar/filters/custom_component_filter';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	export const createFilter: (index: number, config: SearchFilterConfig, query: Query, onChange: (query: Query) => void) => React.JSX.Element;
	export type SearchFilterConfig = IsFilterConfigType | FieldValueSelectionFilterConfigType | FieldValueToggleFilterConfigType | FieldValueToggleGroupFilterConfigType | CustomComponentFilterConfigType;

}
declare module '@elastic/eui/src/components/search_bar/filters' {
	export type { SearchFilterConfig } from '@elastic/eui/src/components/search_bar/filters/filters';
	export { createFilter } from '@elastic/eui/src/components/search_bar/filters/filters';
	export type { FieldValueOptionType } from '@elastic/eui/src/components/search_bar/filters/field_value_selection_filter';

}
declare module '@elastic/eui/src/components/search_bar/search_filters' {
	import { FunctionComponent } from 'react';
	import { SearchFilterConfig } from '@elastic/eui/src/components/search_bar/filters';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	export type { SearchFilterConfig } from '@elastic/eui/src/components/search_bar/filters';
	export interface EuiSearchBarFiltersProps {
	    query: Query;
	    onChange: (query: Query) => void;
	    filters: SearchFilterConfig[];
	}
	export const EuiSearchBarFilters: FunctionComponent<EuiSearchBarFiltersProps>;

}
declare module '@elastic/eui/src/components/search_bar/search_bar.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSearchBar__searchHolder: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;
	export const euiSearchBar__filtersHolder: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/search_bar/search_bar' {
	import React, { Component, ReactElement } from 'react';
	import { SearchFilterConfig } from '@elastic/eui/src/components/search_bar/search_filters';
	import { Query } from '@elastic/eui/src/components/search_bar/query';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiFieldSearchProps } from '@elastic/eui/src/components/form/field_search';
	import { EuiInputPopoverProps } from '@elastic/eui/src/components/popover';
	export { Query, AST as Ast } from '@elastic/eui/src/components/search_bar/query';
	export type QueryType = Query | string;
	type Tools = ReactElement | ReactElement[];
	interface ArgsWithQuery {
	    query: Query;
	    queryText: string;
	    error: null;
	}
	/**
	 * When `searchFormat` is 'text', `query` is null and the search is performed
	 * on the `queryText` directly without EQL parsing
	 */
	interface ArgsWithPlainText {
	    query: null;
	    queryText: string;
	    error: null;
	}
	interface ArgsWithError {
	    query: null;
	    queryText: string;
	    error: Error;
	}
	export interface SchemaType {
	    strict?: boolean;
	    fields?: any;
	    flags?: string[];
	    recognizedFields?: string[];
	}
	export type EuiSearchBarOnChangeArgs = ArgsWithQuery | ArgsWithPlainText | ArgsWithError;
	type HintPopOverProps = Partial<Pick<EuiInputPopoverProps, 'isOpen' | 'closePopover' | 'fullWidth' | 'disableFocusTrap' | 'panelClassName' | 'panelPaddingSize' | 'panelStyle' | 'panelProps' | 'popoverScreenReaderText' | 'repositionOnScroll' | 'zIndex' | 'data-test-subj'>>;
	export interface EuiSearchBarProps extends CommonProps {
	    onChange?: (args: EuiSearchBarOnChangeArgs) => void | boolean;
	    /**
	     * The initial query the bar will hold when first mounted
	     */
	    defaultQuery?: QueryType;
	    /**
	     * If you wish to use the search bar as a controlled component, continuously pass the query via this prop.
	     */
	    query?: QueryType;
	    /**
	     * Configures the search box. Set `placeholder` to change the placeholder text in the box and `incremental` to support incremental (as you type) search.
	     */
	    box?: EuiFieldSearchProps & {
	        schema?: SchemaType | boolean;
	    };
	    /**
	     * An array of search filters. See {@link SearchFilterConfig}.
	     */
	    filters?: SearchFilterConfig[];
	    /**
	     * Tools which go to the left of the search bar.
	     */
	    toolsLeft?: Tools;
	    /**
	     * Tools which go to the right of the search bar.
	     */
	    toolsRight?: Tools;
	    /**
	     * Date formatter to use when parsing date values
	     */
	    dateFormat?: object;
	    /**
	     * Hint to render below the search bar
	     */
	    hint?: {
	        content: React.ReactNode;
	        popoverProps?: HintPopOverProps;
	    };
	}
	interface State {
	    query: Query;
	    queryText: string;
	    error: null | Error;
	    isHintVisible: boolean;
	}
	type NotifyControllingParent = Pick<State, 'queryText' | 'error'> & {
	    query: Query | null;
	};
	export class EuiSearchBar extends Component<EuiSearchBarProps, State> {
	    static Query: typeof Query;
	    hintId: string;
	    constructor(props: EuiSearchBarProps);
	    static getDerivedStateFromProps(nextProps: EuiSearchBarProps, prevState: State): State | null;
	    notifyControllingParent(newState: NotifyControllingParent): void;
	    onSearch: (queryText: string) => void;
	    onFiltersChange: (query: Query) => void;
	    renderTools(tools?: Tools): React.JSX.Element | React.JSX.Element[] | undefined;
	    render(): React.JSX.Element;
	}

}
declare module '@elastic/eui/src/components/search_bar' {
	export type { EuiSearchBarProps, EuiSearchBarOnChangeArgs, QueryType, } from '@elastic/eui/src/components/search_bar/search_bar';
	export { EuiSearchBar, Query, Ast } from '@elastic/eui/src/components/search_bar/search_bar';
	export { EuiSearchBarFilters } from '@elastic/eui/src/components/search_bar/search_filters';
	export type { SearchFilterConfig } from '@elastic/eui/src/components/search_bar/search_filters';
	export type { FieldValueOptionType } from '@elastic/eui/src/components/search_bar/filters/field_value_selection_filter';

}
declare module '@elastic/eui/src/components/side_nav/_side_nav_heading' {
	import { FunctionComponent, ReactNode } from 'react';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	export type EuiSideNavHeadingProps = Omit<EuiTitleProps, 'children'> & {
	    children: ReactNode;
	    /**
	     * The actual HTML heading element to wrap the `heading`.
	     * Default is `h2`
	     */
	    element?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'span';
	    /**
	     * For best accessibility, `<nav>` elements should have a nested heading. But you can hide this element if it's redundent from something else (except on mobile).
	     */
	    screenReaderOnly?: boolean;
	};
	export const EuiSideNavHeading: FunctionComponent<EuiSideNavHeadingProps>;

}
declare module '@elastic/eui/src/components/side_nav/side_nav_item.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSideNavItemStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSideNavItem: import("@emotion/react").SerializedStyles;
	    emphasized: import("@emotion/react").SerializedStyles;
	    root: import("@emotion/react").SerializedStyles;
	    trunk: import("@emotion/react").SerializedStyles;
	    branch: import("@emotion/react").SerializedStyles;
	    items: {
	        euiSideNavItem__items: import("@emotion/react").SerializedStyles;
	        rootWithIcon: import("@emotion/react").SerializedStyles;
	        trunk: import("@emotion/react").SerializedStyles;
	        branch: import("@emotion/react").SerializedStyles;
	    };
	};
	export const euiSideNavItemButtonStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSideNavItemButton: import("@emotion/react").SerializedStyles;
	    selected: import("@emotion/react").SerializedStyles;
	    emphasized: import("@emotion/react").SerializedStyles;
	    root: import("@emotion/react").SerializedStyles;
	    trunk: import("@emotion/react").SerializedStyles;
	    branch: import("@emotion/react").SerializedStyles;
	    euiSideNavItemButton__content: import("@emotion/react").SerializedStyles;
	    label: {
	        euiSideNavItemButton__label: import("@emotion/react").SerializedStyles;
	        root: {
	            lineHeight: import("csstype").Property.LineHeight<string | number> | undefined;
	            color: string;
	            fontSize: import("react").CSSProperties["fontSize"];
	            fontWeight: import("react").CSSProperties["fontWeight"];
	        };
	    };
	};

}
declare module '@elastic/eui/src/components/side_nav/side_nav_item' {
	import { HTMLAttributes, ReactNode, ReactElement, MouseEventHandler, JSX } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	/**
	 * The props that are exposed to, or altered for, the consumer
	 * for use in the object of items in `EuiSideNav`
	 * can be found in the `side_nave_types.ts` file.
	 */
	export type _EuiSideNavItemButtonProps = CommonProps & {
	    /**
	     * Is an optional string to be passed as the navigation item's `href` prop,
	     * and by default it will force rendering of the item as an `<a>`
	     */
	    href?: string;
	    target?: string;
	    rel?: string;
	    /**
	     * Callback function to be passed as the navigation item's `onClick` prop,
	     * and by default it will force rendering of the item as a `<button>` instead of a link
	     */
	    onClick?: MouseEventHandler<HTMLButtonElement | HTMLElement>;
	    children: ReactNode;
	    disabled?: boolean;
	};
	export interface _EuiSideNavItemProps {
	    /**
	     * React node which will be rendered as a small icon to the
	     * left of the navigation item text
	     */
	    icon?: ReactElement;
	    /**
	     * If set to true it will render the item in a visible
	     * "selected" state, and will force all ancestor navigation items
	     * to render in an "open" state
	     */
	    isSelected?: boolean;
	    /**
	     * Enhances the whole item's section (including nested items) with
	     * a slight background and bold top item
	     */
	    emphasize?: boolean;
	    /**
	     * Restrict the item's text length to a single line
	     */
	    truncate?: boolean;
	    /**
	     * Passed to the actual `.euiSideNavItemButton` element
	     */
	    buttonClassName?: string;
	    /**
	     * className, css, and style are passed to the parent wrapper, not the button
	     */
	    style?: HTMLAttributes<HTMLDivElement>['style'];
	    items?: ReactNode;
	    isOpen?: boolean;
	    isParent?: boolean;
	    depth?: number;
	    childrenOnly?: boolean;
	}
	type ExcludeEuiSideNavItemProps<T> = Pick<T, Exclude<keyof T, keyof _EuiSideNavItemProps | 'renderItem'>>;
	type OmitEuiSideNavItemProps<T> = {
	    [K in keyof ExcludeEuiSideNavItemProps<T>]: T[K];
	};
	export type RenderItem<T> = (props: OmitEuiSideNavItemProps<T> & _EuiSideNavItemButtonProps) => JSX.Element;
	export type EuiSideNavItemProps<T> = T extends {
	    renderItem: Function;
	} ? T & {
	    renderItem: RenderItem<T>;
	} : T;
	export const EuiSideNavItem: <T extends _EuiSideNavItemButtonProps & _EuiSideNavItemProps & {
	    renderItem?: (props: any) => JSX.Element;
	}>({ isOpen, isSelected, isParent, icon, onClick, href: _href, rel, target, items, children, renderItem: RenderItem, depth, className, css, style, truncate, emphasize, buttonClassName, childrenOnly, ...rest }: EuiSideNavItemProps<T>) => JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/side_nav/side_nav_types' {
	import { ReactNode } from 'react';
	import { RenderItem, _EuiSideNavItemButtonProps, _EuiSideNavItemProps } from '@elastic/eui/src/components/side_nav/side_nav_item';
	export interface EuiSideNavItemType<T> extends Omit<_EuiSideNavItemButtonProps, 'children'>, Omit<_EuiSideNavItemProps, 'isParent' | 'depth' | 'isOpen' | 'childrenOnly' | 'items'> {
	    /**
	     * A value that is passed to React as the `key` for this item
	     */
	    id: string | number;
	    /**
	     * If set to true it will force the item to display in an "open" state at all times.
	     */
	    forceOpen?: boolean;
	    /**
	     * Array containing additional item objects, representing nested children of this navigation item.
	     */
	    items?: Array<EuiSideNavItemType<T>>;
	    /**
	     * React node representing the text to render for this item (usually a string will suffice).
	     */
	    name: ReactNode;
	    /**
	     * Function overriding default rendering for this navigation item — when called, it should return a React node representing a replacement navigation item.
	     */
	    renderItem?: RenderItem<T>;
	}

}
declare module '@elastic/eui/src/components/side_nav/side_nav.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSideNavMobileStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSideNav__mobileToggle: import("@emotion/react").SerializedStyles;
	    euiSideNav__mobileToggleContent: import("@emotion/react").SerializedStyles;
	    content: {
	        euiSideNav__mobileContent: import("@emotion/react").SerializedStyles;
	        hidden: import("@emotion/react").SerializedStyles;
	        open: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/side_nav/side_nav' {
	import React, { Component, ReactNode, MouseEventHandler } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiBreakpointSize, WithEuiThemeProps } from '@elastic/eui/src/services';
	import { EuiSideNavHeadingProps } from '@elastic/eui/src/components/side_nav/_side_nav_heading';
	import { RenderItem } from '@elastic/eui/src/components/side_nav/side_nav_item';
	import { EuiSideNavItemType } from '@elastic/eui/src/components/side_nav/side_nav_types';
	export type EuiSideNavProps<T = {}> = T & CommonProps & {
	    /**
	     * `children` are not rendered. Use `items` to specify navigation items instead.
	     */
	    children?: never;
	    /**
	     * Class names to be merged into the final `className` property.
	     */
	    className?: string;
	    /**
	     * Creates an associated heading element and uses the same node as default for `mobileTitle`
	     */
	    heading?: ReactNode;
	    /**
	     * Adds a couple extra {@link EuiSideNavHeading} props and extends the props of EuiTitle that wraps the `heading`
	     */
	    headingProps?: Partial<EuiSideNavHeadingProps>;
	    /**
	     * When called, toggles visibility of the navigation menu at mobile responsive widths. The callback should set the `isOpenOnMobile` prop to actually toggle navigation visibility.
	     */
	    toggleOpenOnMobile?: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * If `true`, the navigation menu will be open at mobile device widths. Use in conjunction with the `toggleOpenOnMobile` prop.
	     */
	    isOpenOnMobile?: boolean;
	    /**
	     * A React node to render at mobile responsive widths, representing the title of this navigation menu.
	     */
	    mobileTitle?: ReactNode;
	    /**
	     * Array of breakpoint names for when to show the mobile version.
	     * Set to `undefined` to remove responsive behavior
	     */
	    mobileBreakpoints?: EuiBreakpointSize[];
	    /**
	     *  An array of {@link EuiSideNavItem} objects. Lists navigation menu items.
	     */
	    items: Array<EuiSideNavItemType<T>>;
	    /**
	     * Overrides default navigation menu item rendering. When called, it should return a React node representing a replacement navigation item.
	     */
	    renderItem?: RenderItem<T>;
	    /**
	     * Truncates the text of all items to stick to a single line
	     */
	    truncate?: boolean;
	};
	export class EuiSideNavClass<T> extends Component<EuiSideNavProps<T> & WithEuiThemeProps> {
	    generateId: (idSuffix?: string) => string;
	    static defaultProps: {
	        items: never[];
	        mobileBreakpoints: string[];
	    };
	    isItemOpen: (item: EuiSideNavItemType<T>) => boolean;
	    renderTree: (items: Array<EuiSideNavItemType<T>>, depth?: number) => React.JSX.Element[];
	    render(): React.JSX.Element;
	}
	export const EuiSideNav: React.ForwardRefExoticComponent<Omit<EuiSideNavProps<{}>, "theme"> & React.RefAttributes<Omit<EuiSideNavProps<{}>, "theme">>>;

}
declare module '@elastic/eui/src/components/side_nav' {
	export type { EuiSideNavProps } from '@elastic/eui/src/components/side_nav/side_nav';
	export { EuiSideNav } from '@elastic/eui/src/components/side_nav/side_nav';
	export * from '@elastic/eui/src/components/side_nav/side_nav_types';

}
declare module '@elastic/eui/src/components/stat/stat.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiStatStyles: () => {
	    euiStat: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    center: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	};
	export const euiStatTitleStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiStat__title: import("@emotion/react").SerializedStyles;
	    default: import("@emotion/react").SerializedStyles;
	    subdued: import("@emotion/react").SerializedStyles;
	    primary: import("@emotion/react").SerializedStyles;
	    success: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    accent: import("@emotion/react").SerializedStyles;
	    isLoading: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/stat/stat' {
	import { HTMLAttributes, FunctionComponent, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTitleSize } from '@elastic/eui/src/components/title/title';
	export const COLORS: readonly ["default", "subdued", "primary", "success", "warning", "danger", "accent"];
	type TitleColor = (typeof COLORS)[number];
	export const ALIGNMENTS: readonly ["left", "center", "right"];
	export interface EuiStatProps {
	    /**
	     * Set the description (label) text
	     */
	    description: ReactNode;
	    /**
	     * Will hide the title with an animation until false
	     */
	    isLoading?: boolean;
	    /**
	     * Flips the order of the description and title
	     */
	    reverse?: boolean;
	    textAlign?: (typeof ALIGNMENTS)[number];
	    /**
	     * The (value) text
	     */
	    title: ReactNode;
	    /**
	     * The color of the title text
	     */
	    titleColor?: TitleColor | string;
	    /**
	     * Size of the title. See EuiTitle for options ('s', 'm', 'l'... etc)
	     */
	    titleSize?: EuiTitleSize;
	    /**
	     * HTML Element to be used for title
	     */
	    titleElement?: string;
	    /**
	     * HTML Element to be used for description
	     */
	    descriptionElement?: string;
	}
	export const EuiStat: FunctionComponent<CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & EuiStatProps>;
	export {};

}
declare module '@elastic/eui/src/components/stat' {
	export type { EuiStatProps } from '@elastic/eui/src/components/stat/stat';
	export { EuiStat } from '@elastic/eui/src/components/stat/stat';

}
declare module '@elastic/eui/src/components/steps/step_strings' {
	type Props = {
	    number?: number;
	    title?: string;
	};
	export const useI18nStep: ({ number, title }: Props) => string;
	export const useI18nCompleteStep: ({ number, title }: Props) => string;
	export const useI18nWarningStep: ({ number, title }: Props) => string;
	export const useI18nErrorsStep: ({ number, title }: Props) => string;
	export const useI18nIncompleteStep: ({ number, title }: Props) => string;
	export const useI18nDisabledStep: ({ number, title }: Props) => string;
	export const useI18nLoadingStep: ({ number, title }: Props) => string;
	export const useI18nCurrentStep: ({ number, title }: Props) => string;
	export {};

}
declare module '@elastic/eui/src/components/steps/step.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiStepVariables: (euiTheme: UseEuiTheme["euiTheme"]) => {
	    numberSize: string;
	    numberXSSize: string;
	    numberXXSSize: string;
	    numberMargin: string;
	};
	export const euiStepStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStep: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    xxs: import("@emotion/react").SerializedStyles;
	};
	export const euiStepContentStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStep__content: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    readonly s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    xxs: import("@emotion/react").SerializedStyles;
	};
	export const euiStepTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStep__titleWrapper: import("@emotion/react").SerializedStyles;
	    euiStep__title: import("@emotion/react").SerializedStyles;
	    isDisabled: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    xxs: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/steps/step_number.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiStepNumberStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStepNumber: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    none: import("@emotion/react").SerializedStyles;
	    incomplete: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	    loading: import("@emotion/react").SerializedStyles;
	    warning: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    complete: import("@emotion/react").SerializedStyles;
	    current: import("@emotion/react").SerializedStyles;
	};
	export const euiStepNumberContentStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiStepNumber__icon: import("@emotion/react").SerializedStyles;
	    complete: import("@emotion/react").SerializedStyles;
	    danger: import("@emotion/react").SerializedStyles;
	    warning: {
	        m: string;
	        s: string;
	        xs: string;
	        none: string;
	    };
	    none: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/steps/step_number' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	export const STATUS: readonly ["incomplete", "disabled", "loading", "warning", "danger", "complete", "current"];
	export type EuiStepStatus = (typeof STATUS)[number];
	export interface EuiStepNumberProps extends CommonProps, HTMLAttributes<HTMLDivElement> {
	    /**
	     * May replace the number provided in props.number with alternate styling
	     */
	    status?: EuiStepStatus;
	    number?: number;
	    /**
	     * Title sizing equivalent to EuiTitle, but only `m`, `s`, `xs`.
	     * `none` indicates no step number should be rendered.
	     * @default s
	     */
	    titleSize?: Extract<EuiTitleProps['size'], 'xs' | 's' | 'm'> | 'none';
	}
	export const EuiStepNumber: FunctionComponent<EuiStepNumberProps>;

}
declare module '@elastic/eui/src/components/steps/step' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTitleProps } from '@elastic/eui/src/components/title';
	import { EuiStepStatus } from '@elastic/eui/src/components/steps/step_number';
	export interface EuiStepInterface {
	    /**
	     * ReactNode to render as this component's content
	     */
	    children: ReactNode;
	    /**
	     * The HTML tag used for the title
	     */
	    headingElement?: string;
	    /**
	     * The number of the step in the list of steps
	     */
	    step?: number;
	    title: string;
	    /**
	     * May replace the number provided in props.step with alternate styling.
	     */
	    status?: EuiStepStatus;
	    /**
	     * Title sizing equivalent to **EuiTitle**, but only `m`, `s`, `xs` font sizes.
	     * The `xxs` size reduces the size of the accompanying step indicator, but not the title itself.
	     * @default s
	     */
	    titleSize?: Extract<EuiTitleProps['size'], 'xxs' | 'xs' | 's' | 'm'>;
	}
	export type EuiStepProps = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & EuiStepInterface;
	export const EuiStep: FunctionComponent<EuiStepProps>;

}
declare module '@elastic/eui/src/components/steps/steps' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiStepProps } from '@elastic/eui/src/components/steps/step';
	export type EuiContainedStepProps = Omit<EuiStepProps, 'step'>;
	export interface EuiStepsProps extends CommonProps, HTMLAttributes<HTMLDivElement> {
	    /**
	     * An array of `EuiStep` objects excluding the `step` prop
	     */
	    steps: EuiContainedStepProps[];
	    /**
	     * The number the steps should begin from
	     */
	    firstStepNumber?: number;
	    /**
	     * The HTML tag used for the title
	     */
	    headingElement?: string;
	    /**
	     * Title sizing equivalent to **EuiTitle**, but only `m`, `s`, `xs` font sizes.
	     * The `xxs` size reduces the size of the accompanying step indicator, but not the title itself.
	     * @default s
	     */
	    titleSize?: EuiStepProps['titleSize'];
	}
	export const EuiSteps: FunctionComponent<EuiStepsProps>;

}
declare module '@elastic/eui/src/components/steps/sub_steps.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiSubStepsStyles: (euiThemeContext: UseEuiTheme) => {
	    euiSubSteps: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/steps/sub_steps' {
	import { HTMLAttributes, FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiSubStepsProps = FunctionComponent<HTMLAttributes<HTMLDivElement> & CommonProps>;
	export const EuiSubSteps: EuiSubStepsProps;

}
declare module '@elastic/eui/src/components/steps/steps_horizontal.styles' {
	export const euiStepsHorizontalStyles: () => {
	    euiStepsHorizontal: import("@emotion/react").SerializedStyles;
	    euiStepsHorizontal__item: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/steps/steps_horizontal' {
	import { FunctionComponent, OlHTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiStepHorizontalProps } from '@elastic/eui/src/components/steps/step_horizontal';
	export const SIZES: readonly ["xs", "s", "m"];
	export type EuiStepsHorizontalSizes = (typeof SIZES)[number];
	export interface EuiStepsHorizontalProps extends OlHTMLAttributes<HTMLOListElement>, CommonProps {
	    /**
	     * An array of `EuiStepHorizontal` objects excluding the `step` prop
	     */
	    steps: Array<Omit<EuiStepHorizontalProps, 'step'>>;
	    size?: EuiStepsHorizontalSizes;
	}
	export const EuiStepsHorizontal: FunctionComponent<EuiStepsHorizontalProps>;

}
declare module '@elastic/eui/src/components/steps/step_horizontal.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiStepHorizontalStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStepHorizontal: import("@emotion/react").SerializedStyles;
	    m: import("@emotion/react").SerializedStyles;
	    s: import("@emotion/react").SerializedStyles;
	    xs: import("@emotion/react").SerializedStyles;
	    enabled: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};
	export const euiStepHorizontalNumberStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStepHorizontal__number: import("@emotion/react").SerializedStyles;
	};
	export const euiStepHorizontalTitleStyles: (euiThemeContext: UseEuiTheme) => {
	    euiStepHorizontal__title: import("@emotion/react").SerializedStyles;
	    disabled: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/steps/step_horizontal' {
	import { ButtonHTMLAttributes, FunctionComponent, MouseEventHandler } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiStepStatus } from '@elastic/eui/src/components/steps/step_number';
	import { EuiStepsHorizontalSizes } from '@elastic/eui/src/components/steps/steps_horizontal';
	export interface EuiStepHorizontalProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'>, CommonProps {
	    onClick: MouseEventHandler<HTMLButtonElement>;
	    /**
	     * Makes the whole step button disabled.
	     */
	    disabled?: boolean;
	    /**
	     * The number of the step in the list of steps
	     */
	    step?: number;
	    title?: string;
	    /**
	     * Visual representation of the step number indicator.
	     * May replace the number provided in props.step with alternate styling.
	     * The `disabled` prop will override this.
	     */
	    status?: EuiStepStatus;
	    size?: EuiStepsHorizontalSizes;
	}
	export const EuiStepHorizontal: FunctionComponent<EuiStepHorizontalProps>;

}
declare module '@elastic/eui/src/components/steps' {
	export type { EuiStepProps } from '@elastic/eui/src/components/steps/step';
	export { EuiStep } from '@elastic/eui/src/components/steps/step';
	export type { EuiStepsProps } from '@elastic/eui/src/components/steps/steps';
	export { EuiSteps } from '@elastic/eui/src/components/steps/steps';
	export type { EuiSubStepsProps } from '@elastic/eui/src/components/steps/sub_steps';
	export { EuiSubSteps } from '@elastic/eui/src/components/steps/sub_steps';
	export { EuiStepHorizontal } from '@elastic/eui/src/components/steps/step_horizontal';
	export type { EuiStepsHorizontalProps, EuiStepsHorizontalSizes, } from '@elastic/eui/src/components/steps/steps_horizontal';
	export { EuiStepsHorizontal } from '@elastic/eui/src/components/steps/steps_horizontal';
	export type { EuiStepStatus, EuiStepNumberProps } from '@elastic/eui/src/components/steps/step_number';
	export { EuiStepNumber } from '@elastic/eui/src/components/steps/step_number';

}
declare module '@elastic/eui/src/components/tour/_tour_header.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTourHeaderStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiTourHeader: import("@emotion/react").SerializedStyles;
	    euiTourHeader__title: import("@emotion/react").SerializedStyles;
	    euiTourHeader__subtitle: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tour/_tour_header' {
	import { FunctionComponent } from 'react';
	import type { EuiTourStepProps } from '@elastic/eui/src/components/tour/tour_step';
	type EuiTourHeaderProps = {
	    id: string;
	} & Pick<EuiTourStepProps, 'title' | 'subtitle'>;
	export const EuiTourHeader: FunctionComponent<EuiTourHeaderProps>;
	export {};

}
declare module '@elastic/eui/src/components/tour/tour_step_indicator' {
	import { FunctionComponent, HTMLAttributes } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export type EuiTourStepStatus = 'complete' | 'incomplete' | 'active';
	export interface EuiTourStepIndicatorProps extends CommonProps, HTMLAttributes<HTMLLIElement> {
	    number: number;
	    status: EuiTourStepStatus;
	}
	export const EuiTourStepIndicator: FunctionComponent<EuiTourStepIndicatorProps>;

}
declare module '@elastic/eui/src/components/tour/_tour_footer.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const _tourFooterBgColor: ({ euiTheme }: UseEuiTheme) => string;
	export const euiTourFooterStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTourFooter: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tour/_tour_footer' {
	import { FunctionComponent } from 'react';
	import type { EuiTourStepProps } from '@elastic/eui/src/components/tour/tour_step';
	type EuiTourFooterProps = Pick<EuiTourStepProps, 'footerAction' | 'step' | 'stepsTotal' | 'onFinish'>;
	export const EuiTourFooter: FunctionComponent<EuiTourFooterProps>;
	export {};

}
declare module '@elastic/eui/src/components/tour/tour.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTourStyles: (euiThemeContext: UseEuiTheme) => {
	    euiTour: import("@emotion/react").SerializedStyles;
	};
	export const euiTourBeaconStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiTourBeacon: import("@emotion/react").SerializedStyles;
	    isOpen: import("@emotion/react").SerializedStyles;
	    right: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    top: import("@emotion/react").SerializedStyles;
	    bottom: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/tour/tour_step' {
	import { CSSProperties, HTMLAttributes, FunctionComponent, ReactElement, ReactNode } from 'react';
	import { ElementTarget } from '@elastic/eui/src/services';
	import { CommonProps, ExclusiveUnion, NoArgCallback } from '@elastic/eui/src/components/common';
	import { EuiPopoverProps } from '@elastic/eui/src/components/popover';
	type _EuiPopoverProps = EuiPopoverProps & Omit<HTMLAttributes<HTMLDivElement>, 'content' | 'title' | 'step'>;
	type _PopoverOverrides = 'button' | 'closePopover';
	type _PopoverPartials = 'closePopover';
	type ExtendedEuiPopoverProps = Omit<_EuiPopoverProps, _PopoverOverrides> & Partial<Pick<EuiPopoverProps, _PopoverPartials>>;
	export type EuiTourStepAnchorProps = ExclusiveUnion<{
	    /**
	     * Element to which the tour step popover attaches when open
	     */
	    children: ReactElement;
	    /**
	     * Selector or reference to the element to which the tour step popover attaches when open
	     */
	    anchor?: never;
	}, {
	    children?: never;
	    anchor: ElementTarget;
	}>;
	export type EuiTourStepProps = CommonProps & ExtendedEuiPopoverProps & EuiTourStepAnchorProps & {
	    /**
	     * Contents of the tour step popover
	     */
	    content: ReactNode;
	    /**
	     * Step will display if set to `true`
	     */
	    isStepOpen?: boolean;
	    /**
	     * Change the default min width of the popover panel
	     */
	    minWidth?: CSSProperties['minWidth'];
	    /**
	     * Change the default max width of the popover panel
	     */
	    maxWidth?: CSSProperties['maxWidth'];
	    /**
	     * Function to call for 'Skip tour' and 'End tour' actions
	     */
	    onFinish: NoArgCallback<void>;
	    /**
	     * The number of the step within the parent tour. 1-based indexing.
	     */
	    step: number;
	    /**
	     * The total number of steps in the tour
	     */
	    stepsTotal: number;
	    /**
	     * Smaller title text that appears atop each step in the tour. The subtitle gets wrapped in the appropriate heading level.
	     */
	    subtitle?: ReactNode;
	    /**
	     * Larger title text specific to this step. The title gets wrapped in the appropriate heading level.
	     */
	    title: ReactNode;
	    /**
	     * Extra visual indication of step location.
	     * It does not apply when `hasArrow=false`
	     */
	    decoration?: 'none' | 'beacon';
	    /**
	     * Accepts any `ReactNode` to replace the 'Skip tour' link in the footer.
	     * Ideally, pass one button or an array of up to 2 buttons.
	     */
	    footerAction?: ReactNode | ReactNode[];
	};
	export const EuiTourStep: FunctionComponent<EuiTourStepProps>;
	export {};

}
declare module '@elastic/eui/src/components/tour/types' {
	export interface EuiTourState {
	    currentTourStep: number;
	    isTourActive: boolean;
	    tourPopoverWidth: number;
	    tourSubtitle: string;
	}
	interface ActionFinish {
	    type: 'EUI_TOUR_FINISH';
	    payload: {
	        resetTour?: boolean;
	    };
	}
	interface ActionReset {
	    type: 'EUI_TOUR_RESET';
	}
	interface ActionDecrement {
	    type: 'EUI_TOUR_PREVIOUS';
	}
	interface ActionIncrement {
	    type: 'EUI_TOUR_NEXT';
	}
	interface ActionGotoStep {
	    type: 'EUI_TOUR_GOTO';
	    payload: {
	        step: number;
	        isTourActive?: boolean;
	    };
	}
	export type EuiTourAction = ActionFinish | ActionReset | ActionDecrement | ActionIncrement | ActionGotoStep;
	export interface EuiTourActions {
	    finishTour: (resetTour?: boolean) => void;
	    resetTour: () => void;
	    decrementStep: () => void;
	    incrementStep: () => void;
	    goToStep: (step: number, isTourActive?: boolean) => void;
	}
	export {};

}
declare module '@elastic/eui/src/components/tour/useEuiTour' {
	import { EuiTourStepProps } from '@elastic/eui/src/components/tour/tour_step';
	import { EuiTourActions, EuiTourState } from '@elastic/eui/src/components/tour/types';
	export type EuiStatelessTourStep = EuiTourStepProps & Partial<EuiTourState>;
	export type EuiStatelessTourSteps = Array<Exclude<EuiStatelessTourStep, 'onFinish'>>;
	export const useEuiTour: (stepsArray: EuiStatelessTourSteps, initialState: EuiTourState) => [EuiTourStepProps[], EuiTourActions, EuiTourState];

}
declare module '@elastic/eui/src/components/tour/tour' {
	import { FunctionComponent, ReactElement } from 'react';
	import { EuiStatelessTourSteps } from '@elastic/eui/src/components/tour/useEuiTour';
	import { EuiTourStepProps } from '@elastic/eui/src/components/tour/tour_step';
	import { EuiTourActions, EuiTourState } from '@elastic/eui/src/components/tour/types';
	export interface EuiTourProps {
	    children: (steps: EuiTourStepProps[], actions: EuiTourActions, state: EuiTourState) => ReactElement;
	    steps: EuiStatelessTourSteps;
	    initialState: EuiTourState;
	}
	export const EuiTour: FunctionComponent<EuiTourProps>;

}
declare module '@elastic/eui/src/components/tour' {
	export type { EuiTourProps } from '@elastic/eui/src/components/tour/tour';
	export { EuiTour } from '@elastic/eui/src/components/tour/tour';
	export type { EuiTourStepProps } from '@elastic/eui/src/components/tour/tour_step';
	export { EuiTourStep } from '@elastic/eui/src/components/tour/tour_step';
	export type { EuiTourStepIndicatorProps } from '@elastic/eui/src/components/tour/tour_step_indicator';
	export { EuiTourStepIndicator } from '@elastic/eui/src/components/tour/tour_step_indicator';
	export type { EuiStatelessTourStep, EuiStatelessTourSteps } from '@elastic/eui/src/components/tour/useEuiTour';
	export { useEuiTour } from '@elastic/eui/src/components/tour/useEuiTour';
	export * from '@elastic/eui/src/components/tour/types';

}
declare module '@elastic/eui/src/components/basic_table/collapsed_item_actions' {
	import React from 'react';
	import { Action } from '@elastic/eui/src/components/basic_table/action_types';
	import { ItemIdResolved } from '@elastic/eui/src/components/basic_table/table_types';
	export interface CollapsedItemActionsProps<T extends object> {
	    actions: Array<Action<T>>;
	    item: T;
	    itemId: ItemIdResolved;
	    actionsDisabled: boolean;
	    displayedRowIndex: number;
	    className?: string;
	}
	export const CollapsedItemActions: <T extends {}>({ actions, itemId, item, actionsDisabled, displayedRowIndex, className, }: CollapsedItemActionsProps<T>) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/basic_table/default_item_action' {
	import { ReactElement } from 'react';
	import { DefaultItemAction as Action } from '@elastic/eui/src/components/basic_table/action_types';
	export interface DefaultItemActionProps<T extends object> {
	    action: Action<T>;
	    enabled: boolean;
	    item: T;
	    className?: string;
	}
	export const DefaultItemAction: <T extends object>({ action, enabled, item, className, }: DefaultItemActionProps<T>) => ReactElement;

}
declare module '@elastic/eui/src/components/basic_table/custom_item_action' {
	import React from 'react';
	import { CustomItemAction as Action } from '@elastic/eui/src/components/basic_table/action_types';
	export interface CustomItemActionProps<T> {
	    action: Action<T>;
	    enabled: boolean;
	    item: T;
	    className: string;
	    index?: number;
	}
	export const CustomItemAction: <T>({ action, enabled, item, className, }: CustomItemActionProps<T>) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/basic_table/expanded_item_actions' {
	import { ReactElement } from 'react';
	import { Action } from '@elastic/eui/src/components/basic_table/action_types';
	import { ItemIdResolved } from '@elastic/eui/src/components/basic_table/table_types';
	export interface ExpandedItemActionsProps<T extends object> {
	    actions: Array<Action<T>>;
	    itemId: ItemIdResolved;
	    item: T;
	    actionsDisabled: boolean;
	    className?: string;
	}
	export const ExpandedItemActions: <T extends {}>({ actions, itemId, item, actionsDisabled, className, }: ExpandedItemActionsProps<T>) => ReactElement;

}
declare module '@elastic/eui/src/components/basic_table/panel.styles' {
	import type { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiBasicTablePanelStyles: ({ euiTheme }: UseEuiTheme) => import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/basic_table/use_panel_props' {
	/**
	 * @internal
	 */
	export const EUI_BASIC_TABLE_PANEL_CLASS_NAME: "euiBasicTablePanel";
	/**
	 * A utility hook that returns props needed to be passed to element(s) being
	 * a part of the paneled table look and feel (e.g., a toolbar above the table).
	 * @beta
	 */
	export const useEuiBasicTablePanelProps: () => {
	    css: import("@emotion/serialize").SerializedStyles;
	    className: "euiBasicTablePanel";
	};

}
declare module '@elastic/eui/src/components/basic_table/basic_table.styles' {
	import type { UseEuiTheme } from '@elastic/eui/src/services';
	import type { EuiTableProps } from '@elastic/eui/src/components/table';
	export const euiBasicTableBodyLoading: (euiThemeContext: UseEuiTheme) => import("@emotion/react").SerializedStyles;
	/**
	 * @internal
	 */
	export const euiBasicTableWrapperPanelledStyles: (responsiveBreakpoint: EuiTableProps["responsiveBreakpoint"]) => (theme: UseEuiTheme) => import("@emotion/react").SerializedStyles | null;
	export const safariLoadingWorkaround: import("@emotion/react").SerializedStyles;

}
declare module '@elastic/eui/src/components/basic_table/basic_table' {
	import React, { Component, HTMLAttributes, ReactNode, ContextType } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiComponentDefaultsContext } from '@elastic/eui/src/components/provider/component_defaults';
	import { EuiTableProps } from '@elastic/eui/src/components/table';
	import { type Pagination } from '@elastic/eui/src/components/basic_table/pagination_bar';
	import { EuiTableActionsColumnType, EuiTableComputedColumnType, EuiTableDataType, EuiTableFieldDataColumnType, ItemId, EuiTableSelectionType, EuiTableSortingType, ItemIdResolved } from '@elastic/eui/src/components/basic_table/table_types';
	interface ItemIdToExpandedRowMap {
	    [id: string]: ReactNode;
	}
	export function getItemId<T>(item: T, itemId?: ItemId<T>): any;
	export type EuiBasicTableColumn<T extends object> = EuiTableFieldDataColumnType<T> | EuiTableComputedColumnType<T> | EuiTableActionsColumnType<T>;
	export interface Criteria<T> {
	    /**
	     * If the shown items represents a page (slice) into a bigger set, this describes this page
	     */
	    page?: {
	        index: number;
	        size: number;
	    };
	    /**
	     * If the shown items are sorted, this describes the sort criteria
	     */
	    sort?: {
	        field: keyof T;
	        direction: 'asc' | 'desc';
	    };
	}
	export interface CriteriaWithPagination<T> extends Criteria<T> {
	    /**
	     * If the shown items represents a page (slice) into a bigger set, this describes this page
	     */
	    page: {
	        index: number;
	        size: number;
	    };
	}
	type CellPropsCallback<T extends object> = (item: T, column: EuiBasicTableColumn<T>) => object;
	type RowPropsCallback<T> = (item: T) => object;
	interface BasicTableProps<T extends object> extends Omit<EuiTableProps, 'onChange'> {
	    /**
	     * Describes how to extract a unique ID from each item, used for selections & expanded rows
	     */
	    itemId?: ItemId<T>;
	    /**
	     * Row expansion uses the itemId prop to identify each row
	     */
	    itemIdToExpandedRowMap?: ItemIdToExpandedRowMap;
	    /**
	     * A list of objects to appear in the table - an item per row
	     */
	    items: T[];
	    /**
	     * Applied to `EuiTableRowCell`
	     */
	    cellProps?: object | CellPropsCallback<T>;
	    /**
	     * An array of one of the objects: {@link EuiTableFieldDataColumnType}, {@link EuiTableComputedColumnType} or {@link EuiTableActionsColumnType}.
	     */
	    columns: Array<EuiBasicTableColumn<T>>;
	    /**
	     * Error message to display
	     */
	    error?: string;
	    /**
	     * Provides a description of the table’s content. If no description is provided, the table will default to the name Data Table.
	     */
	    tableCaption?: string;
	    /**
	     * Indicates which column should be used as the identifying cell in each row. Should match a "field" prop in FieldDataColumn
	     */
	    rowHeader?: string;
	    /**
	     * Provides an infinite loading indicator
	     */
	    loading?: boolean;
	    /**
	     * Enable the panelled style of the table.
	     *
	     * Panelled style adds contrast between the table navigation controls
	     * and table content itself. It should be used in tables rendered outside
	     * EUI containers like `<EuiPanel>` or `<EuiFlyout>`.
	     * @default false
	     */
	    panelled?: boolean;
	    /**
	     * Message to display if table is empty
	     */
	    noItemsMessage?: ReactNode;
	    /**
	     * Called whenever pagination or sorting changes (this property is required when either pagination or sorting is configured).
	     * See {@link Criteria} or {@link CriteriaWithPagination}
	     */
	    onChange?: (criteria: Criteria<T>) => void;
	    /**
	     * Configures {@link Pagination}
	     */
	    pagination?: undefined;
	    /**
	     * Applied to `EuiTableRow`
	     */
	    rowProps?: object | RowPropsCallback<T>;
	    /**
	     * Configures {@link EuiTableSelectionType}
	     */
	    selection?: EuiTableSelectionType<T>;
	    /**
	     * Configures {@link EuiTableSortingType}
	     */
	    sorting?: EuiTableSortingType<T>;
	    /**
	     * Sets the table-layout CSS property. Note that auto tableLayout prevents truncateText from working properly.
	     */
	    tableLayout?: 'fixed' | 'auto';
	}
	type BasicTableWithPaginationProps<T extends object> = Omit<BasicTableProps<T>, 'pagination' | 'onChange'> & {
	    pagination: Pagination;
	    onChange?: (criteria: CriteriaWithPagination<T>) => void;
	};
	export type EuiBasicTableProps<T extends object> = CommonProps & Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> & (BasicTableProps<T> | BasicTableWithPaginationProps<T>);
	interface State<T> {
	    initialSelectionRendered: boolean;
	    selection: T[];
	}
	export class EuiBasicTable<T extends object = any> extends Component<EuiBasicTableProps<T>, State<T>> {
	    static contextType: React.Context<import ("@elastic/eui/src/components/provider/component_defaults").EuiComponentDefaults>;
	    context: ContextType<typeof EuiComponentDefaultsContext>;
	    static defaultProps: {
	        tableLayout: string;
	        noItemsMessage: React.JSX.Element;
	    };
	    static getDerivedStateFromProps<T extends object>(nextProps: EuiBasicTableProps<T>, prevState: State<T>): {
	        selection: T[];
	    } | null;
	    constructor(props: EuiBasicTableProps<T>);
	    componentDidMount(): void;
	    componentDidUpdate(): void;
	    get pageSize(): number;
	    get isSelectionControlled(): boolean;
	    getInitialSelection(): void;
	    buildCriteria(props: EuiBasicTableProps<T>): Criteria<T>;
	    changeSelection(changedSelection: T[]): void;
	    clearSelection(): void;
	    onPageSizeChange(size: number): void;
	    onPageChange(index: number): void;
	    onColumnSortChange(column: EuiBasicTableColumn<T>): void;
	    tableId: string;
	    render(): React.JSX.Element;
	    renderTable(): React.JSX.Element;
	    renderTableMobileSort(): React.JSX.Element | null;
	    renderTableCaption(): React.JSX.Element;
	    selectAllIdGenerator: (idSuffix?: string) => string;
	    renderSelectAll: (isMobile: boolean) => React.JSX.Element | undefined;
	    renderTableHead(): React.JSX.Element;
	    renderTableFooter(): React.JSX.Element | null;
	    renderTableBody(): React.JSX.Element;
	    renderErrorMessage(error: string): React.JSX.Element;
	    renderEmptyMessage(): React.JSX.Element;
	    renderItemRow(item: T, rowIndex: number, displayedRowIndex: number): React.JSX.Element;
	    renderItemSelectionCell(itemId: ItemId<T>, item: T, selected: boolean, displayedRowIndex: number): (boolean | React.JSX.Element | undefined)[];
	    renderItemActionsCell(itemId: ItemIdResolved, item: T, column: EuiTableActionsColumnType<T>, columnIndex: number, rowIndex: 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>, columnIndex: number, key: string | number, content: ReactNode, setScopeRow: boolean): React.JSX.Element;
	    renderCopyChar: (columnIndex: number) => React.JSX.Element;
	    resolveColumnSortDirection: (column: EuiBasicTableColumn<T>) => "desc" | "asc" | undefined;
	    resolveColumnOnSort: (column: EuiBasicTableColumn<T>) => (() => void) | undefined;
	    getRendererForDataType(dataType?: EuiTableDataType): (value: any) => string;
	    getAlignForDataType(dataType?: EuiTableDataType): "left" | "right";
	    renderPaginationBar(): React.JSX.Element | undefined;
	}
	export {};

}
declare module '@elastic/eui/src/components/basic_table/in_memory_table' {
	import React, { Component, ReactNode } from 'react';
	import { Criteria, EuiBasicTableProps, CriteriaWithPagination } from '@elastic/eui/src/components/basic_table/basic_table';
	import { PropertySort } from '@elastic/eui/src/services';
	import { Direction } from '@elastic/eui/src/services/sort';
	import { EuiSearchBarProps, Query, SchemaType } from '@elastic/eui/src/components/search_bar/search_bar';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiTablePaginationProps } from '@elastic/eui/src/components/table/table_pagination';
	import { EuiComponentDefaults } from '@elastic/eui/src/components/provider/component_defaults';
	interface onChangeArgument {
	    query: Query | null;
	    queryText: string;
	    error: Error | null;
	}
	export type Search = boolean | EuiSearchBarProps;
	interface PaginationOptions extends EuiTablePaginationProps {
	    pageSizeOptions?: number[];
	    initialPageIndex?: number;
	    initialPageSize?: number;
	    pageIndex?: number;
	    pageSize?: number;
	}
	type Pagination = boolean | PaginationOptions;
	interface SortingOptions {
	    sort: PropertySort;
	}
	type Sorting = boolean | SortingOptions;
	type InMemoryTableProps<T extends object> = Omit<EuiBasicTableProps<T>, 'pagination' | 'sorting' | 'noItemsMessage' | 'onChange'> & {
	    /**
	     * Message to display if table is empty
	     */
	    noItemsMessage?: ReactNode;
	    /**
	     * Configures the search bar. Can be `true` for defaults,
	     * or an {@link EuiSearchBarProps} object.
	     *
	     * When `searchFormat="text"`, `query` and `defaultQuery` must be strings
	     * ({@link Query} objects are ignored).
	     */
	    search?: Search;
	    /**
	     * By default, tables use `eql` format for search which allows using advanced filters.
	     *
	     * However, certain special characters (such as quotes, parentheses, and colons)
	     * are reserved for EQL syntax and will error if used.
	     *
	     * If your table does not require filter search and instead requires searching for certain
	     * symbols, use a plain `text` search format instead (note that filters will be ignored
	     * in this format).
	     *
	     * @default "eql"
	     */
	    searchFormat?: 'eql' | 'text';
	    /**
	     * Configures {@link Pagination}
	     */
	    pagination?: undefined;
	    /**
	     * Configures {@link EuiTableSortingType}
	     */
	    sorting?: Sorting;
	    /**
	     * Set `allowNeutralSort` to false to force column sorting. Defaults to true.
	     */
	    allowNeutralSort?: boolean;
	    /**
	     * `onChange` is not required when `pagination` and/or `sorting` are configured,
	     * but if `onChange` is present it is responsible for handling state for each/both.
	     * See {@link Criteria} or {@link CriteriaWithPagination}
	     */
	    onChange?: EuiBasicTableProps<T>['onChange'];
	    /**
	     * Callback for when table pagination or sorting is changed. This is meant to be informational only,
	     * and not used to set any state as the in-memory table already manages this state.
	     * See {@link Criteria} or {@link CriteriaWithPagination}.
	     */
	    onTableChange?: (nextValues: Criteria<T>) => void;
	    executeQueryOptions?: {
	        defaultFields?: string[];
	        isClauseMatcher?: (...args: any) => boolean;
	        explain?: boolean;
	        /**
	         * When the search bar Query is controlled and passed to the `search` prop it is by default executed against the items passed to the table to filter them out.
	         * If the filtering is already done before passing the `items` to the table we can disable the execution by setting `enabled` to `false`.
	         */
	        enabled?: boolean;
	    };
	    /**
	     * Insert content between the search bar and table components.
	     */
	    childrenBetween?: ReactNode;
	};
	type InMemoryTablePropsWithPagination<T extends object> = Omit<InMemoryTableProps<T>, 'pagination' | 'onTableChange'> & {
	    pagination: Pagination;
	    onTableChange?: (nextValues: CriteriaWithPagination<T>) => void;
	};
	export type EuiInMemoryTableProps<T extends object = object> = CommonProps & (InMemoryTableProps<T> | InMemoryTablePropsWithPagination<T>);
	interface State<T extends object> {
	    prevProps: {
	        items: T[];
	        sortName: ReactNode;
	        sortDirection?: Direction;
	        search?: Search;
	    };
	    search?: Search;
	    query: Query | string | null;
	    pageIndex: number;
	    pageSize?: number;
	    pageSizeOptions?: number[];
	    sortName: ReactNode;
	    sortDirection?: Direction;
	    allowNeutralSort: boolean;
	    showPerPageOptions: boolean | undefined;
	}
	export class EuiInMemoryTable<T extends object = object> extends Component<EuiInMemoryTableProps<T>, State<T>> {
	    static contextType: React.Context<EuiComponentDefaults>;
	    static defaultProps: {
	        tableLayout: string;
	        searchFormat: string;
	    };
	    static getDerivedStateFromProps<T extends object>(nextProps: EuiInMemoryTableProps<T>, prevState: State<T>): State<T> | null;
	    constructor(props: EuiInMemoryTableProps<T>, context: EuiComponentDefaults);
	    onTableChange: ({ page, sort }: Criteria<T>) => void;
	    onQueryChange: ({ query, queryText, error }: onChangeArgument) => void;
	    onPlainTextSearch: (searchValue: string) => void;
	    renderSearchBar(): React.JSX.Element | undefined;
	    resolveSearchSchema(): SchemaType;
	    getItemSorter(): (a: T, b: T) => number;
	    getItems(): {
	        items: T[];
	        totalItemCount: number;
	    };
	    render(): React.JSX.Element;
	}
	export {};

}
declare module '@elastic/eui/src/components/basic_table' {
	export type { EuiBasicTableProps, EuiBasicTableColumn, Criteria, CriteriaWithPagination, } from '@elastic/eui/src/components/basic_table/basic_table';
	export { EuiBasicTable } from '@elastic/eui/src/components/basic_table/basic_table';
	export type { EuiInMemoryTableProps, Search } from '@elastic/eui/src/components/basic_table/in_memory_table';
	export { EuiInMemoryTable } from '@elastic/eui/src/components/basic_table/in_memory_table';
	export type { EuiTableDataType, EuiTableFooterProps, EuiTableFieldDataColumnType, EuiTableComputedColumnType, EuiTableActionsColumnType, EuiTableSelectionType, EuiTableSortingType, } from '@elastic/eui/src/components/basic_table/table_types';
	export type { Pagination } from '@elastic/eui/src/components/basic_table/pagination_bar';
	export type { DefaultItemAction, CustomItemAction } from '@elastic/eui/src/components/basic_table/action_types';
	export { useEuiBasicTablePanelProps } from '@elastic/eui/src/components/basic_table/use_panel_props';

}
declare module '@elastic/eui/src/components/text_diff/text_diff.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiTextDiffStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiTextDiff: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/text_diff/text_diff' {
	import { HTMLAttributes, ElementType, JSX } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	interface Props {
	    /**
	     * The starting string
	     */
	    beforeText: string;
	    /**
	     * The string used to compare against `beforeText`
	     */
	    afterText: string;
	    /**
	     * HTML element to wrap insertion differences.
	     * Defaults to `ins`
	     */
	    insertComponent?: ElementType;
	    /**
	     * HTML element to wrap deletion differences.
	     * Defaults to `del`
	     */
	    deleteComponent?: ElementType;
	    /**
	     * HTML element to wrap text with no differences.
	     * Doesn't wrap with anything by default
	     */
	    sameComponent?: ElementType;
	    /**
	     * Time in milliseconds. Passing a timeout of value '0' disables the timeout state
	     */
	    timeout?: number;
	}
	export type EuiTextDiffProps = CommonProps & Props & HTMLAttributes<HTMLElement>;
	export const useEuiTextDiff: ({ className, insertComponent, deleteComponent, sameComponent, beforeText, afterText, timeout, ...rest }: EuiTextDiffProps) => [JSX.Element, [0 | 1 | -1, string][]];
	export {};

}
declare module '@elastic/eui/src/components/text_diff' {
	export type { EuiTextDiffProps } from '@elastic/eui/src/components/text_diff/text_diff';
	export { useEuiTextDiff } from '@elastic/eui/src/components/text_diff/text_diff';

}
declare module '@elastic/eui/src/components/toast/toast.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiToastStyles: (euiThemeContext: UseEuiTheme) => {
	    euiToast: import("@emotion/react").SerializedStyles;
	    decor: import("@emotion/react").SerializedStyles;
	    wrapper: import("@emotion/react").SerializedStyles;
	    body: import("@emotion/react").SerializedStyles;
	    content: import("@emotion/react").SerializedStyles;
	    text: import("@emotion/react").SerializedStyles;
	    icon: import("@emotion/react").SerializedStyles;
	    actions: import("@emotion/react").SerializedStyles;
	    dismissButton: import("@emotion/react").SerializedStyles;
	    hasAnimation: import("@emotion/react").SerializedStyles;
	};
	export const euiToastHeaderStyles: (euiThemeContext: UseEuiTheme) => {
	    euiToastHeader: import("@emotion/react").SerializedStyles;
	    hasDismissButton: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/notification_icon/assets/info_fill' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/notification_icon/assets/warning_static' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/notification_icon/notification_icon.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiNotificationIconStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiNotificationIcon: import("@emotion/react").SerializedStyles;
	    size: {
	        l: import("@emotion/react").SerializedStyles;
	    };
	};

}
declare module '@elastic/eui/src/components/notification_icon/notification_icon' {
	import { FunctionComponent } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon/icon'; const TYPES: readonly ["info", "success", "warning", "error"];
	export type EuiNotificationIconType = (typeof TYPES)[number];
	export const NOTIFICATION_ICONS_MAP: Record<EuiNotificationIconType, {
	    name: string;
	    icon: IconType;
	}>;
	export type EuiNotificationIconProps = CommonProps & {
	    type: EuiNotificationIconType;
	    size?: 'm' | 'l';
	};
	export const EuiNotificationIcon: FunctionComponent<EuiNotificationIconProps>;
	export {};

}
declare module '@elastic/eui/src/components/toast/types' {
	export const COLORS: readonly ["primary", "success", "warning", "danger"];
	export type EuiToastColor = (typeof COLORS)[number];

}
declare module '@elastic/eui/src/components/toast/toast_action' {
	import React from 'react';
	import { ExclusiveUnion } from '@elastic/eui/src/components/common';
	import { EuiButtonEmptyProps } from '@elastic/eui/src/components/button';
	import { Props as EuiButtonProps } from '@elastic/eui/src/components/button/button';
	import { EuiToastColor } from '@elastic/eui/src/components/toast/types';
	export type EuiToastActionPrimaryProps = Omit<EuiButtonProps, 'color' | 'size' | 'fill'>;
	export type EuiToastActionSecondaryProps = Omit<EuiButtonEmptyProps, 'color' | 'size' | 'flush'>;
	type EuiToastActionPrimary = EuiToastActionPrimaryProps & {
	    actionType: 'primary';
	};
	type EuiToastActionSecondary = EuiToastActionSecondaryProps & {
	    actionType: 'secondary';
	};
	type EuiToastActionProps = ExclusiveUnion<EuiToastActionPrimary, EuiToastActionSecondary>;
	export const EuiToastAction: ({ children, actionType, color, ...rest }: EuiToastActionProps & {
	    color?: EuiToastColor;
	}) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/toast/toast' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { IconType } from '@elastic/eui/src/components/icon';
	import { type EuiNotificationIconType } from '@elastic/eui/src/components/notification_icon/notification_icon';
	import { EuiToastActionPrimaryProps, EuiToastActionSecondaryProps } from '@elastic/eui/src/components/toast/toast_action';
	import { EuiToastColor } from '@elastic/eui/src/components/toast/types';
	export const COLOR_TO_NOTIFICATION_ICON_MAP: Record<EuiToastColor, EuiNotificationIconType>;
	export interface EuiToastProps extends CommonProps, Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
	    /**
	     * Title of the toast. Should be used with text only. Do not pass complex content or custom components.
	     * Ensure to always pass a title. It's currently marked as optional for backwards compatibility.
	     * In a future major release, this will be required.
	     */
	    title?: ReactNode;
	    /**
	     * Main component text. Accepts text, text block elements such as `<p>`, and inline elements such as `<span>`, `<strong>`, `<em>` or `<EuiLink>`.
	     * Avoid passing complex layouts or custom components. Use `children` instead.
	     */
	    text?: ReactNode;
	    /**
	     * Can be used for additional, non-inline content. Use sparingly, as toasts are not meant to have complex content.
	     * Where possible, use `text` and `actionProps` instead to display text and actions.
	     */
	    children?: ReactNode;
	    color?: EuiToastColor;
	    /**
	     * Defines a custom icon to be displayed.
	     * When no `iconType` is set, a default icon will be used based on the `color` of the toast.
	     */
	    iconType?: IconType;
	    onClose?: () => void;
	    /**
	     * Duration in milliseconds that drives a countdown animation on the toast's decor bar.
	     * When not set the bar is static at full width.
	     */
	    animationMs?: number;
	    /**
	     * Props for primary and secondary actions within the toast.
	     */
	    actionProps?: {
	        primary?: EuiToastActionPrimaryProps;
	        secondary?: EuiToastActionSecondaryProps;
	    };
	}
	export const EuiToast: FunctionComponent<EuiToastProps>;

}
declare module '@elastic/eui/src/services/time/timer' {
	export class Timer {
	    id: any;
	    callback: undefined | (() => void);
	    finishTime: number | undefined;
	    timeRemaining: number | undefined;
	    constructor(callback: () => void, timeMs: number);
	    pause: () => void;
	    resume: () => void;
	    clear: () => void;
	    finish: () => void;
	}

}
declare module '@elastic/eui/src/services/time' {
	export { Timer } from '@elastic/eui/src/services/time/timer';

}
declare module '@elastic/eui/src/components/toast/global_toast_list.styles' {
	import { UseEuiTheme } from '@elastic/eui/src/services';
	export const euiGlobalToastListStyles: (euiThemeContext: UseEuiTheme) => {
	    /**
	     * 1. Allow list to expand as items are added, but cap it at the screen height.
	     * 2. Allow some padding for shadow
	     */
	    euiGlobalToastList: import("@emotion/react").SerializedStyles;
	    content: import("@emotion/react").SerializedStyles;
	    notificationBadge: {
	        notificationBadge: import("@emotion/react").SerializedStyles;
	        hasFadeOut: import("@emotion/react").SerializedStyles;
	    };
	    right: import("@emotion/react").SerializedStyles;
	    left: import("@emotion/react").SerializedStyles;
	    euiGlobalToastListDismissButton: import("@emotion/react").SerializedStyles;
	};
	export const euiGlobalToastListItemStyles: ({ euiTheme }: UseEuiTheme) => {
	    euiGlobalToastListItem: import("@emotion/react").SerializedStyles;
	    dismissed: import("@emotion/react").SerializedStyles;
	};

}
declare module '@elastic/eui/src/components/toast/global_toast_list_item' {
	import { FunctionComponent, ReactElement } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	export interface EuiGlobalToastListItemProps extends CommonProps {
	    isDismissed?: boolean;
	    /**
	     * ReactElement to render as this component's content
	     */
	    children?: ReactElement;
	}
	export const EuiGlobalToastListItem: FunctionComponent<EuiGlobalToastListItemProps>;

}
declare module '@elastic/eui/src/components/toast/global_toast_list' {
	import { FunctionComponent, HTMLAttributes, ReactNode } from 'react';
	import { CommonProps } from '@elastic/eui/src/components/common';
	import { EuiToastProps } from '@elastic/eui/src/components/toast/toast';
	type ToastSide = 'right' | 'left';
	export const SIDES: ToastSide[];
	export const TOAST_FADE_OUT_MS = 250;
	export const CLEAR_ALL_TOASTS_THRESHOLD_DEFAULT = 3;
	export interface Toast extends EuiToastProps {
	    id: string;
	    text?: ReactNode;
	    toastLifeTimeMs?: number;
	}
	export interface EuiGlobalToastListProps extends CommonProps {
	    toasts?: Toast[];
	    dismissToast: (toast: Toast) => void;
	    toastLifeTimeMs: number;
	    /**
	     * Determines which side of the browser window the toasts should appear
	     */
	    side?: ToastSide;
	    /**
	     * At this threshold, a "Clear all" button will display at the bottom of the toast list
	     * that allows users to dismiss all toasts in a single click.
	     *
	     * Defaults to `3`. Set to `0` to disable the button entirely.
	     */
	    showClearAllButtonAt?: number;
	    /**
	     * Optional callback that fires when a user clicks the "Clear all" button.
	     */
	    onClearAllToasts?: () => void;
	    /**
	     * Defaults to the [log role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/log_role).
	     *
	     * The [alert role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/alert_role)
	     * can be considered only if *all* toasts in this list will require immediate user attention.
	     * Several alerts at once, and unnecessary alerts, will a create bad screen reader user experience.
	     *
	     * @default log
	     */
	    role?: HTMLAttributes<HTMLElement>['role'];
	    /**
	     * Renders a notification badge indicating the amount of toasts in the list.
	     *
	     * @default false
	     */
	    showNotificationBadge?: boolean;
	}
	export const EuiGlobalToastList: FunctionComponent<EuiGlobalToastListProps>;
	export {};

}
declare module '@elastic/eui/src/components/toast' {
	export { EuiToast } from '@elastic/eui/src/components/toast/toast';
	export type { EuiGlobalToastListProps, Toast as EuiGlobalToastListToast, } from '@elastic/eui/src/components/toast/global_toast_list';
	export { EuiGlobalToastList } from '@elastic/eui/src/components/toast/global_toast_list';
	export type { EuiGlobalToastListItemProps } from '@elastic/eui/src/components/toast/global_toast_list_item';
	export { EuiGlobalToastListItem } from '@elastic/eui/src/components/toast/global_toast_list_item';

}
declare module '@elastic/eui/src/components' {
	export * from '@elastic/eui/src/components/accessibility';
	export * from '@elastic/eui/src/components/accordion';
	export * from '@elastic/eui/src/components/aspect_ratio';
	export * from '@elastic/eui/src/components/auto_sizer';
	export * from '@elastic/eui/src/components/avatar';
	export * from '@elastic/eui/src/components/badge';
	export * from '@elastic/eui/src/components/banner';
	export * from '@elastic/eui/src/components/beacon';
	export * from '@elastic/eui/src/components/bottom_bar';
	export * from '@elastic/eui/src/components/breadcrumbs';
	export * from '@elastic/eui/src/components/button';
	export * from '@elastic/eui/src/components/call_out';
	export * from '@elastic/eui/src/components/card';
	export * from '@elastic/eui/src/components/code';
	export * from '@elastic/eui/src/components/collapsible_nav';
	export * from '@elastic/eui/src/components/collapsible_nav_beta';
	export * from '@elastic/eui/src/components/color_picker';
	export * from '@elastic/eui/src/components/combo_box';
	export * from '@elastic/eui/src/components/comment_list';
	export * from '@elastic/eui/src/components/context';
	export * from '@elastic/eui/src/components/context_menu';
	export * from '@elastic/eui/src/components/copy';
	export * from '@elastic/eui/src/components/datagrid';
	export * from '@elastic/eui/src/components/date_picker';
	export * from '@elastic/eui/src/components/delay_hide';
	export * from '@elastic/eui/src/components/delay_render';
	export * from '@elastic/eui/src/components/description_list';
	export * from '@elastic/eui/src/components/drag_and_drop';
	export * from '@elastic/eui/src/components/empty_prompt';
	export * from '@elastic/eui/src/components/error_boundary';
	export * from '@elastic/eui/src/components/expression';
	export * from '@elastic/eui/src/components/filter_group';
	export * from '@elastic/eui/src/components/facet';
	export * from '@elastic/eui/src/components/flex';
	export * from '@elastic/eui/src/components/flyout';
	export * from '@elastic/eui/src/components/focus_trap';
	export * from '@elastic/eui/src/components/form';
	export * from '@elastic/eui/src/components/header';
	export * from '@elastic/eui/src/components/health';
	export * from '@elastic/eui/src/components/highlight';
	export * from '@elastic/eui/src/components/horizontal_rule';
	export * from '@elastic/eui/src/components/icon';
	export * from '@elastic/eui/src/components/image';
	export * from '@elastic/eui/src/components/inner_text';
	export * from '@elastic/eui/src/components/inline_edit';
	export * from '@elastic/eui/src/components/i18n';
	export * from '@elastic/eui/src/components/loading';
	export * from '@elastic/eui/src/components/key_pad_menu';
	export * from '@elastic/eui/src/components/link';
	export * from '@elastic/eui/src/components/list_group';
	export * from '@elastic/eui/src/components/markdown_editor';
	export * from '@elastic/eui/src/components/mark';
	export * from '@elastic/eui/src/components/modal';
	export * from '@elastic/eui/src/components/observer/mutation_observer';
	export * from '@elastic/eui/src/components/outside_click_detector';
	export * from '@elastic/eui/src/components/overlay_mask';
	export * from '@elastic/eui/src/components/page';
	export * from '@elastic/eui/src/components/page_template';
	export * from '@elastic/eui/src/components/pagination';
	export * from '@elastic/eui/src/components/panel';
	export * from '@elastic/eui/src/components/popover';
	export * from '@elastic/eui/src/components/portal';
	export * from '@elastic/eui/src/components/progress';
	export * from '@elastic/eui/src/components/provider';
	export * from '@elastic/eui/src/components/tree_view';
	export * from '@elastic/eui/src/components/observer/resize_observer';
	export * from '@elastic/eui/src/components/search_bar';
	export * from '@elastic/eui/src/components/selectable';
	export * from '@elastic/eui/src/components/side_nav';
	export * from '@elastic/eui/src/components/skeleton';
	export * from '@elastic/eui/src/components/spacer';
	export * from '@elastic/eui/src/components/stat';
	export * from '@elastic/eui/src/components/steps';
	export * from '@elastic/eui/src/components/table';
	export * from '@elastic/eui/src/components/token';
	export * from '@elastic/eui/src/components/tour';
	export * from '@elastic/eui/src/components/basic_table';
	export * from '@elastic/eui/src/components/tabs';
	export * from '@elastic/eui/src/components/text';
	export * from '@elastic/eui/src/components/text_diff';
	export * from '@elastic/eui/src/components/text_truncate';
	export * from '@elastic/eui/src/components/timeline';
	export * from '@elastic/eui/src/components/title';
	export * from '@elastic/eui/src/components/toast';
	export * from '@elastic/eui/src/components/tool_tip';
	export * from '@elastic/eui/src/components/responsive';
	export * from '@elastic/eui/src/components/resizable_container';
	export * from '@elastic/eui/src/components/common';

}
declare module '@elastic/eui' {
	export * from '@elastic/eui/src/components';
	export * from '@elastic/eui/src/services';
	export * from '@elastic/eui/src/utils';
	export * from '@elastic/eui/src/global_styling';

}
declare module '@elastic/eui/src/components/datagrid/data_grid.stories.utils' {
	import React from 'react';
	import type { EuiDataGridCellValueElementProps, EuiDataGridColumnCellActionProps, EuiDataGridProps } from '@elastic/eui/src/components/datagrid/data_grid_types';
	export const raw_data: {
	    name: {
	        formatted: string;
	        raw: string;
	    };
	    email: {
	        formatted: React.JSX.Element;
	        raw: string;
	    };
	    location: React.JSX.Element;
	    date: string;
	    account: string;
	    version: React.JSX.Element;
	}[];
	export const defaultStorybookArgs: {
	    'aria-label': string;
	    css: import("@emotion/react").SerializedStyles;
	    columns: ({
	        id: string;
	        displayAsText: string;
	        defaultSortDirection: "asc";
	        cellActions: (({ rowIndex, Component }: EuiDataGridColumnCellActionProps) => React.JSX.Element)[];
	        initialWidth?: undefined;
	        actions?: undefined;
	        isResizable?: undefined;
	        schema?: undefined;
	    } | {
	        id: string;
	        displayAsText: string;
	        initialWidth: number;
	        cellActions: (({ rowIndex, Component }: EuiDataGridColumnCellActionProps) => React.JSX.Element)[];
	        defaultSortDirection?: undefined;
	        actions?: undefined;
	        isResizable?: undefined;
	        schema?: undefined;
	    } | {
	        id: string;
	        displayAsText: string;
	        actions: {
	            showHide: {
	                label: string;
	            };
	            showMoveLeft: boolean;
	            showMoveRight: boolean;
	            additional: {
	                label: string;
	                onClick: () => void;
	                iconType: string;
	                size: "xs";
	                color: "text";
	            }[];
	        };
	        cellActions: (({ rowIndex, Component, isExpanded, }: EuiDataGridColumnCellActionProps) => React.JSX.Element)[];
	        defaultSortDirection?: undefined;
	        initialWidth?: undefined;
	        isResizable?: undefined;
	        schema?: undefined;
	    } | {
	        id: string;
	        displayAsText: string;
	        defaultSortDirection?: undefined;
	        cellActions?: undefined;
	        initialWidth?: undefined;
	        actions?: undefined;
	        isResizable?: undefined;
	        schema?: undefined;
	    } | {
	        id: string;
	        displayAsText: string;
	        defaultSortDirection: "desc";
	        cellActions?: undefined;
	        initialWidth?: undefined;
	        actions?: undefined;
	        isResizable?: undefined;
	        schema?: undefined;
	    } | {
	        id: string;
	        displayAsText: string;
	        defaultSortDirection: "desc";
	        initialWidth: number;
	        isResizable: boolean;
	        actions: false;
	        schema: string;
	        cellActions?: undefined;
	    })[];
	    rowCount: number;
	    renderCellValue: ({ rowIndex, columnId, }: EuiDataGridCellValueElementProps) => string | React.JSX.Element | null;
	    trailingControlColumns: {
	        id: string;
	        width: number;
	        headerCellRender: () => React.JSX.Element;
	        rowCellRender: () => React.JSX.Element;
	    }[];
	    leadingControlColumns: {
	        id: string;
	        width: number;
	        headerCellRender: () => React.JSX.Element;
	        rowCellRender: ({ rowIndex }: EuiDataGridCellValueElementProps) => React.JSX.Element;
	    }[];
	    columnVisibility: {
	        visibleColumns: string[];
	        setVisibleColumns: () => void;
	        canDragAndDropColumns: boolean;
	    };
	    inMemory: {
	        readonly level: "sorting";
	    };
	    pagination: {
	        pageIndex: number;
	        pageSize: number;
	        pageSizeOptions: number[];
	        onChangeItemsPerPage: () => void;
	        onChangePage: () => void;
	    };
	    gridStyle: {
	        readonly fontSize: "m";
	        readonly cellPadding: "m";
	        readonly border: "all";
	        readonly stripes: false;
	        readonly header: "shade";
	        readonly footer: "overline";
	        readonly stickyFooter: true;
	        readonly rowHover: "highlight";
	        readonly rowClasses: {};
	    };
	    width: string;
	    height: string;
	    toolbarVisibility: {
	        readonly showColumnSelector: true;
	        readonly showDisplaySelector: true;
	        readonly showSortSelector: true;
	        readonly showKeyboardShortcuts: true;
	        readonly showFullScreenSelector: true;
	        readonly additionalControls: null;
	    };
	    headerVisibility: boolean;
	    minSizeForControls: number;
	    rowHeightsOptions: {
	        readonly defaultHeight: undefined;
	        readonly rowHeights: {};
	        readonly lineHeight: undefined;
	        readonly scrollAnchorRow: undefined;
	    };
	};
	export const StatefulDataGrid: (props: EuiDataGridProps) => React.JSX.Element;

}
declare module '@elastic/eui/src/components/icon/assets/anomaly_chart' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/apm_trace' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/arrow_down' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/arrow_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/arrow_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/arrow_up' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/boxes_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/change_point_detection' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cheer' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/color' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/compute' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/console' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/copy_clipboard' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/crosshairs' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/currency' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/cut' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/desktop' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/diff' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_align_center' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_align_left' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_align_right' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_bold' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_checklist' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_heading' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_italic' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_link' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_ordered_list' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_redo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_strike' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_table' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_underline' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_undo' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/editor_unordered_list' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/email' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/eql' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/exit' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/expand' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/eye_closed' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/field_statistics' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/grab' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/grab_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/heatmap' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/import' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_flush' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/index_mapping' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kql_field' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kql_operand' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kql_selector' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/kql_value' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/launch' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/lettering' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/list' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/list_add' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/log_pattern_analysis' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logstash_if' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/logstash_queue' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/map_marker' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/new_chat' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/offline' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/online' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/paint' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/plus_in_circle_filled' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/popout' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/push' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/return_key' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/search' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/star_empty' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/streams_classic' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/streams_wired' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/submodule' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_density_compact' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_density_expanded' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/table_density_normal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/temperature' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/timeslider' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/training' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/unlink' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vector' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_area' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_area_stacked' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_bar_horizontal' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_bar_horizontal_stacked' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_bar_vertical' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_bar_vertical_stacked' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_gauge' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_line' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_map_coordinate' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_map_region' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_pie' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_table' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_tag_cloud' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
declare module '@elastic/eui/src/components/icon/assets/vis_text' {
	import * as React from 'react';
	import type { SVGProps } from 'react';
	interface SVGRProps {
	    title?: string;
	    titleId?: string;
	}
	export const icon: ({ title, titleId, ...props }: SVGProps<SVGSVGElement> & SVGRProps) => React.JSX.Element;
	export {};

}
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0 and the Server Side Public License, v 1; you may not use this file except
 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */
/* eslint-disable import/no-duplicates */

declare module 'remark-emoji' {
  import { Plugin } from 'unified';
  const RemarkEmoji: Plugin;
  export = RemarkEmoji;
}

declare module 'mdast-util-to-hast/lib/all' {
  import { Node } from 'unist';
  import { H } from 'mdast-util-to-hast';

  const all: (h: H, node: Node) => Node[];
  export = all;
}
declare module '@elastic/eui/src/components/table/mobile' {
	export { EuiTableHeaderMobile } from '@elastic/eui/src/components/table/mobile/table_header_mobile';
	export type { EuiTableSortMobileProps } from '@elastic/eui/src/components/table/mobile/table_sort_mobile';
	export { EuiTableSortMobile } from '@elastic/eui/src/components/table/mobile/table_sort_mobile';
	export type { EuiTableSortMobileItemProps } from '@elastic/eui/src/components/table/mobile/table_sort_mobile_item';
	export { EuiTableSortMobileItem } from '@elastic/eui/src/components/table/mobile/table_sort_mobile_item';

}
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0 and the Server Side Public License, v 1; you may not use this file except
 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */

declare module 'text-diff' {
  interface ConstructorProps {
    timeout: number;
  }

  type DiffElement = [-1 | 0 | 1, string];

  class Diff {
    constructor({ timeout }: ConstructorProps);
    main: (initialText: string, currentText: string) => DiffElement[];
  }
  export = Diff;
}
declare module '@elastic/eui/src/services/container_query' {
	export { useEuiContainerQuery } from '@elastic/eui/src/services/container_query/container_query_hook';

}



declare module '@elastic/eui' {
  export type EuiTokensObject = {
    "euiTreeView.listNavigationInstructions": any;
"euiTourStepIndicator.isActive": any;
"euiTourStepIndicator.isComplete": any;
"euiTourStepIndicator.isIncomplete": any;
"euiTourStepIndicator.ariaLabel": any;
"euiTourFooter.endTour": any;
"euiTourFooter.skipTour": any;
"euiTourFooter.closeTour": any;
"euiIconTip.defaultAriaLabel": any;
"euiToast.dismissToast": any;
"euiToast.newNotification": any;
"euiGlobalToastList.clearAllToastsButtonAriaLabel": any;
"euiGlobalToastList.clearAllToastsButtonDisplayText": any;
"euiStat.loadingText": any;
"euiStepStrings.step": any;
"euiStepStrings.simpleStep": any;
"euiStepStrings.complete": any;
"euiStepStrings.simpleComplete": any;
"euiStepStrings.warning": any;
"euiStepStrings.simpleWarning": any;
"euiStepStrings.errors": any;
"euiStepStrings.simpleErrors": any;
"euiStepStrings.incomplete": any;
"euiStepStrings.simpleIncomplete": any;
"euiStepStrings.disabled": any;
"euiStepStrings.simpleDisabled": any;
"euiStepStrings.loading": any;
"euiStepStrings.simpleLoading": any;
"euiStepStrings.current": any;
"euiStepStrings.simpleCurrent": any;
"euiTableHeaderCell.titleTextWithDesc": any;
"euiSkeletonLoading.loadedAriaText": any;
"euiSkeletonLoading.loadingAriaText": any;
"euiSideNav.mobileToggleAriaLabel": any;
"euiSelectable.loadingOptions": any;
"euiSelectable.noMatchingOptions": any;
"euiSelectable.noAvailableOptions": any;
"euiSelectable.screenReaderInstructions": any;
"euiSelectable.placeholderName": any;
"euiSelectable.searchResults": any;
"euiSearchBox.placeholder": any;
"euiSearchBox.incrementalAriaLabel": any;
"euiSearchBox.ariaLabel": any;
"euiResizablePanel.toggleButtonAriaLabel": any;
"euiResizableButton.horizontalResizerAriaLabel": any;
"euiResizableButton.verticalResizerAriaLabel": any;
"euiProgress.valueText": any;
"euiPopover.screenReaderAnnouncement": any;
"euiPaginationButtonArrow.firstPage": any;
"euiPaginationButtonArrow.previousPage": any;
"euiPaginationButtonArrow.nextPage": any;
"euiPaginationButtonArrow.lastPage": any;
"euiPaginationButton.longPageString": any;
"euiPaginationButton.shortPageString": any;
"euiPagination.pageOfTotalCompressed": any;
"euiPagination.firstRangeAriaLabel": any;
"euiPagination.lastRangeAriaLabel": any;
"euiPagination.last": any;
"euiPagination.page": any;
"euiPagination.of": any;
"euiPagination.collection": any;
"euiPagination.fromEndLabel": any;
"euiMark.highlightStart": any;
"euiMark.highlightEnd": any;
"euiMarkdownEditorToolbar.editor": any;
"euiMarkdownEditorToolbar.previewMarkdown": any;
"euiMarkdownEditorHelpButton.mdSyntaxLink": any;
"euiMarkdownEditorHelpButton.syntaxTitle": any;
"euiMarkdownEditorHelpButton.showMarkdownHelp": any;
"euiMarkdownEditorHelpButton.syntaxModalDescriptionPrefix": any;
"euiMarkdownEditorHelpButton.syntaxModalDescriptionSuffix": any;
"euiMarkdownEditorHelpButton.closeButton": any;
"euiMarkdownEditorHelpButton.syntaxPopoverDescription": any;
"euiMarkdownEditorFooter.uploadingFiles": any;
"euiMarkdownEditorFooter.openUploadModal": any;
"euiMarkdownEditorFooter.unsupportedFileType": any;
"euiMarkdownEditorFooter.supportedFileTypes": any;
"euiMarkdownEditorFooter.showSyntaxErrors": any;
"euiMarkdownEditorFooter.errorsTitle": any;
"euiLoadingStrings.ariaLabel": any;
"euiModal.screenReaderModalDialog": any;
"euiModal.closeModal": any;
"euiExternalLinkIcon.newTarget.screenReaderOnlyText": any;
"euiExternalLinkIcon.externalTarget.screenReaderOnlyText": any;
"euiInlineEditForm.saveButtonAriaLabel": any;
"euiInlineEditForm.cancelButtonAriaLabel": any;
"euiInlineEditForm.inputKeyboardInstructions": any;
"euiInlineEditForm.activateEditModeDescription": any;
"euiImageButton.openFullScreen": any;
"euiImageButton.closeFullScreen": any;
"euiForm.addressFormErrors": any;
"euiFlyoutMenu.back": any;
"euiFlyoutMenu.history": any;
"euiFlyoutMenu.pagination.previous": any;
"euiFlyoutMenu.pagination.next": any;
"euiFlyoutMenu.pagination.counter": any;
"euiFlyout.screenReaderModalDialog": any;
"euiFlyout.screenReaderNoOverlayMaskDialog": any;
"euiFlyout.screenReaderFocusTrapShards": any;
"euiFlyoutCloseButton.ariaLabel": any;
"euiFilterButton.filterBadgeActiveAriaLabel": any;
"euiFilterButton.filterBadgeAvailableAriaLabel": any;
"euiErrorBoundary.error": any;
"euiDataGrid.ariaLabel": any;
"euiDataGrid.ariaLabelledBy": any;
"euiDataGrid.screenReaderNotice": any;
"euiContextMenuPanelTitle.ariaLabel": any;
"euiCollapsibleNavBeta.ariaLabel": any;
"euiSaturation.ariaLabel": any;
"euiSaturation.roleDescription": any;
"euiSaturation.screenReaderInstructions": any;
"euiHue.ariaValueText": any;
"euiHue.ariaRoleDescription": any;
"euiHue.label": any;
"euiColorPickerSwatch.ariaLabel": any;
"euiColorPicker.popoverLabel": any;
"euiColorPicker.colorLabel": any;
"euiColorPicker.selectedColorLabel": any;
"euiColorPicker.colorErrorMessage": any;
"euiColorPicker.transparent": any;
"euiColorPicker.alphaLabel": any;
"euiColorPicker.openLabel": any;
"euiColorPicker.closeLabel": any;
"euiColorPicker.ariaLabel": any;
"euiComboBox.listboxAriaLabel": any;
"euiCodeBlockFullScreen.fullscreenCollapse": any;
"euiCodeBlockFullScreen.fullscreenExpand": any;
"euiCodeBlockFullScreen.ariaLabel": any;
"euiCodeBlockCopy.copy": any;
"euiCodeBlockAnnotations.ariaLabel": any;
"euiCodeBlock.label": any;
"euiCallOut.dismissAriaLabel": any;
"euiBottomBar.screenReaderHeading": any;
"euiBottomBar.customScreenReaderAnnouncement": any;
"euiBottomBar.screenReaderAnnouncement": any;
"euiBreadcrumbs.nav.ariaLabel": any;
"euiBreadcrumb.collapsedBadge.ariaLabel": any;
"euiBreadcrumb.popoverAriaLabel": any;
"euiBanner.dismissAriaLabel": any;
"euiCollapsedItemActions.allActionsTooltip": any;
"euiCollapsedItemActions.allActions": any;
"euiCollapsedItemActions.allActionsDisabled": any;
"euiBasicTable.noItemsMessage": any;
"euiBasicTable.caption.itemCountPart.withTotalItemCount": any;
"euiBasicTable.caption.paginationPart.withPageCount": any;
"euiBasicTable.caption.tableName": any;
"euiBasicTable.caption.emptyState": any;
"euiBasicTable.selectAllRows": any;
"euiBasicTable.deselectRows": any;
"euiBasicTable.selectThisRow": any;
"euiBasicTable.tablePagination": any;
"euiTablePagination.allRows": any;
"euiTablePagination.rowsPerPage": any;
"euiTablePagination.rowsPerPageOptionShowAllRows": any;
"euiTablePagination.rowsPerPageOption": any;
"euiTableSortMobile.sorting": any;
"euiSelectableTemplateSitewide.searchPlaceholder": any;
"euiSelectableTemplateSitewide.loadingResults": any;
"euiSelectableTemplateSitewide.noResults": any;
"euiSelectableTemplateSitewide.onFocusBadgeGoTo": any;
"euiSelectableListItem.checkedOption": any;
"euiSelectableListItem.checkOptionInstructions": any;
"euiSelectableListItem.uncheckOptionInstructions": any;
"euiSelectableListItem.excludedOption": any;
"euiSelectableListItem.excludeOptionInstructions": any;
"euiSelectableListItem.mixedOption": any;
"euiSelectableListItem.mixedOptionInstructions": any;
"euiSelectableListItem.mixedOptionUncheckInstructions": any;
"euiSelectableListItem.mixedOptionExcludeInstructions": any;
"euiFieldValueSelectionFilter.buttonLabelHint": any;
"euiPinnableListGroup.pinExtraActionLabel": any;
"euiPinnableListGroup.pinnedExtraActionLabel": any;
"euiSuperSelect.screenReaderAnnouncement": any;
"euiSuperSelect.ariaLabel": any;
"euiRange.sliderScreenReaderInstructions": any;
"euiDualRange.sliderScreenReaderInstructions": any;
"euiFormControlLayoutDelimited.delimiterLabel": any;
"euiFormControlLayoutClearButton.label": any;
"euiFilePicker.promptText": any;
"euiFilePicker.filesSelected": any;
"euiFilePicker.removeSelectedAriaLabel": any;
"euiFilePicker.removeSelected": any;
"euiFieldSearch.clearSearchButtonLabel": any;
"euiFieldPassword.showPassword": any;
"euiFieldPassword.maskPassword": any;
"euiHeaderLinks.appNavigation": any;
"euiHeaderLinks.openNavigationMenu": any;
"euiFlyoutManaged.defaultTitle": any;
"euiTimeWindowButtons.previousDescription": any;
"euiTimeWindowButtons.nextDescription": any;
"euiTimeWindowButtons.invalidShiftLabel": any;
"euiTimeWindowButtons.invalidZoomInLabel": any;
"euiTimeWindowButtons.cannotZoomInLabel": any;
"euiTimeWindowButtons.invalidZoomOutLabel": any;
"euiTimeWindowButtons.previousLabel": any;
"euiTimeWindowButtons.zoomInLabel": any;
"euiTimeWindowButtons.zoomOutLabel": any;
"euiTimeWindowButtons.nextLabel": any;
"euiSuperUpdateButton.updatingButtonLabel": any;
"euiSuperUpdateButton.updateButtonLabel": any;
"euiSuperUpdateButton.refreshButtonLabel": any;
"euiSuperUpdateButton.cannotUpdateTooltip": any;
"euiSuperUpdateButton.clickToApplyTooltip": any;
"euiTimeOptions.last": any;
"euiTimeOptions.next": any;
"euiTimeOptions.seconds": any;
"euiTimeOptions.minutes": any;
"euiTimeOptions.hours": any;
"euiTimeOptions.days": any;
"euiTimeOptions.weeks": any;
"euiTimeOptions.months": any;
"euiTimeOptions.years": any;
"euiTimeOptions.secondsAgo": any;
"euiTimeOptions.minutesAgo": any;
"euiTimeOptions.hoursAgo": any;
"euiTimeOptions.daysAgo": any;
"euiTimeOptions.weeksAgo": any;
"euiTimeOptions.monthsAgo": any;
"euiTimeOptions.yearsAgo": any;
"euiTimeOptions.secondsFromNow": any;
"euiTimeOptions.minutesFromNow": any;
"euiTimeOptions.hoursFromNow": any;
"euiTimeOptions.daysFromNow": any;
"euiTimeOptions.weeksFromNow": any;
"euiTimeOptions.monthsFromNow": any;
"euiTimeOptions.yearsFromNow": any;
"euiTimeOptions.roundToSecond": any;
"euiTimeOptions.roundToMinute": any;
"euiTimeOptions.roundToHour": any;
"euiTimeOptions.roundToDay": any;
"euiTimeOptions.roundToWeek": any;
"euiTimeOptions.roundToMonth": any;
"euiTimeOptions.roundToYear": any;
"euiTimeOptions.today": any;
"euiTimeOptions.thisWeek": any;
"euiTimeOptions.thisMonth": any;
"euiTimeOptions.thisYear": any;
"euiTimeOptions.yesterday": any;
"euiTimeOptions.weekToDate": any;
"euiTimeOptions.monthToDate": any;
"euiTimeOptions.yearToDate": any;
"euiPrettyDuration.lastDurationSeconds": any;
"euiPrettyDuration.nextDurationSeconds": any;
"euiPrettyDuration.lastDurationMinutes": any;
"euiPrettyDuration.nextDurationMinutes": any;
"euiPrettyDuration.lastDurationHours": any;
"euiPrettyDuration.nextDurationHours": any;
"euiPrettyDuration.lastDurationDays": any;
"euiPrettyDuration.nexttDurationDays": any;
"euiPrettyDuration.lastDurationWeeks": any;
"euiPrettyDuration.nextDurationWeeks": any;
"euiPrettyDuration.lastDurationMonths": any;
"euiPrettyDuration.nextDurationMonths": any;
"euiPrettyDuration.lastDurationYears": any;
"euiPrettyDuration.nextDurationYears": any;
"euiPrettyDuration.durationRoundedToSecond": any;
"euiPrettyDuration.durationRoundedToMinute": any;
"euiPrettyDuration.durationRoundedToHour": any;
"euiPrettyDuration.durationRoundedToDay": any;
"euiPrettyDuration.durationRoundedToWeek": any;
"euiPrettyDuration.durationRoundedToMonth": any;
"euiPrettyDuration.durationRoundedToYear": any;
"euiPrettyDuration.now": any;
"euiPrettyDuration.invalid": any;
"euiPrettyDuration.fallbackDuration": any;
"euiPrettyInterval.seconds": any;
"euiPrettyInterval.minutes": any;
"euiPrettyInterval.hours": any;
"euiPrettyInterval.days": any;
"euiPrettyInterval.secondsShorthand": any;
"euiPrettyInterval.minutesShorthand": any;
"euiPrettyInterval.hoursShorthand": any;
"euiPrettyInterval.daysShorthand": any;
"euiPrettyInterval.off": any;
"euiRefreshInterval.fullDescriptionOff": any;
"euiRefreshInterval.fullDescriptionOn": any;
"euiRefreshInterval.toggleLabel": any;
"euiRefreshInterval.toggleAriaLabel": any;
"euiRefreshInterval.valueAriaLabel": any;
"euiRefreshInterval.unitsAriaLabel": any;
"euiAutoRefresh.autoRefreshLabel": any;
"euiAutoRefresh.buttonLabelOff": any;
"euiAutoRefresh.buttonLabelOn": any;
"euiDataGridPagination.detailedPaginationLabel": any;
"euiDataGridPagination.paginationLabel": any;
"euiDataGridSchema.booleanSortTextAsc": any;
"euiDataGridSchema.booleanSortTextDesc": any;
"euiDataGridSchema.currencySortTextAsc": any;
"euiDataGridSchema.currencySortTextDesc": any;
"euiDataGridSchema.dateSortTextAsc": any;
"euiDataGridSchema.dateSortTextDesc": any;
"euiDataGridSchema.numberSortTextAsc": any;
"euiDataGridSchema.numberSortTextDesc": any;
"euiDataGridSchema.jsonSortTextAsc": any;
"euiDataGridSchema.jsonSortTextDesc": any;
"euiKeyboardShortcuts.title": any;
"euiKeyboardShortcuts.upArrowTitle": any;
"euiKeyboardShortcuts.upArrowDescription": any;
"euiKeyboardShortcuts.downArrowTitle": any;
"euiKeyboardShortcuts.downArrowDescription": any;
"euiKeyboardShortcuts.rightArrowTitle": any;
"euiKeyboardShortcuts.rightArrowDescription": any;
"euiKeyboardShortcuts.leftArrowTitle": any;
"euiKeyboardShortcuts.leftArrowDescription": any;
"euiKeyboardShortcuts.homeTitle": any;
"euiKeyboardShortcuts.homeDescription": any;
"euiKeyboardShortcuts.endTitle": any;
"euiKeyboardShortcuts.endDescription": any;
"euiKeyboardShortcuts.ctrl": any;
"euiKeyboardShortcuts.ctrlHomeDescription": any;
"euiKeyboardShortcuts.ctrlEndDescription": any;
"euiKeyboardShortcuts.pageUpTitle": any;
"euiKeyboardShortcuts.pageUpDescription": any;
"euiKeyboardShortcuts.pageDownTitle": any;
"euiKeyboardShortcuts.pageDownDescription": any;
"euiKeyboardShortcuts.enterTitle": any;
"euiKeyboardShortcuts.enterDescription": any;
"euiKeyboardShortcuts.escapeTitle": any;
"euiKeyboardShortcuts.escapeDescription": any;
"euiFullscreenSelector.fullscreenButton": any;
"euiFullscreenSelector.fullscreenButtonActive": any;
"euiDisplaySelector.densityLabel": any;
"euiDisplaySelector.labelCompact": any;
"euiDisplaySelector.labelNormal": any;
"euiDisplaySelector.labelExpanded": any;
"euiDisplaySelector.rowHeightLabel": any;
"euiDisplaySelector.labelAuto": any;
"euiDisplaySelector.labelStatic": any;
"euiDisplaySelector.labelMax": any;
"euiDisplaySelector.buttonText": any;
"euiDisplaySelector.resetButtonText": any;
"euiDataGridToolbarControl.badgeAriaLabel": any;
"euiColumnSortingDraggable.defaultSortAsc": any;
"euiColumnSortingDraggable.defaultSortDesc": any;
"euiColumnSortingDraggable.dragHandleAriaLabel": any;
"euiColumnSortingDraggable.activeSortLabel": any;
"euiColumnSortingDraggable.removeSortLabel": any;
"euiColumnSortingDraggable.toggleLegend": any;
"euiColumnSorting.button": any;
"euiColumnSorting.sortFieldAriaLabel": any;
"euiColumnSorting.emptySorting": any;
"euiColumnSorting.pickFields": any;
"euiColumnSorting.clearAll": any;
"euiColumnSelector.dragHandleAriaLabel": any;
"euiColumnSelector.button": any;
"euiColumnSelector.search": any;
"euiColumnSelector.searchcolumns": any;
"euiColumnSelector.selectAll": any;
"euiColumnSelector.hideAll": any;
"euiCollapsibleNavButton.ariaLabelExpand": any;
"euiCollapsibleNavButton.ariaLabelCollapse": any;
"euiCollapsibleNavButton.ariaLabelOpen": any;
"euiCollapsibleNavButton.ariaLabelClose": any;
"euiCollapsibleNavKibanaSolution.switcherTitle": any;
"euiCollapsibleNavKibanaSolution.switcherAriaLabel": any;
"euiCollapsibleNavKibanaSolution.groupLabel": any;
"euiComboBoxOptionsList.loadingOptions": any;
"euiComboBoxOptionsList.delimiterMessage": any;
"euiComboBoxOptionsList.alreadyAdded": any;
"euiComboBoxOptionsList.createCustomOption": any;
"euiComboBoxOptionsList.noMatchingOptions": any;
"euiComboBoxOptionsList.noAvailableOptions": any;
"euiComboBoxOptionsList.allOptionsSelected": any;
"euiComboBoxPill.removeSelection": any;
"euiCardSelect.selected": any;
"euiCardSelect.unavailable": any;
"euiCardSelect.select": any;
"euiAccordionChildrenLoading.message": any;
"euiRelativeTab.numberInputLabel": any;
"euiRelativeTab.numberInputError": any;
"euiRelativeTab.dateInputError": any;
"euiRelativeTab.unitInputLabel": any;
"euiRelativeTab.fullDescription": any;
"euiDatePopoverContent.startDateLabel": any;
"euiDatePopoverContent.endDateLabel": any;
"euiDatePopoverContent.absoluteTabLabel": any;
"euiDatePopoverContent.relativeTabLabel": any;
"euiDatePopoverContent.nowTabLabel": any;
"euiDatePopoverContent.nowTabContent": any;
"euiDatePopoverContent.nowTabButtonStart": any;
"euiDatePopoverContent.nowTabButtonEnd": any;
"euiDatePopoverButton.invalidTitle": any;
"euiDatePopoverButton.outdatedTitle": any;
"euiAbsoluteTab.dateFormatButtonLabel": any;
"euiAbsoluteTab.dateFormatError": any;
"euiRecentlyUsed.legend": any;
"euiQuickSelectPopover.buttonLabel": any;
"euiQuickSelect.quickSelectTitle": any;
"euiQuickSelect.previousLabel": any;
"euiQuickSelect.nextLabel": any;
"euiQuickSelect.tenseLabel": any;
"euiQuickSelect.valueLabel": any;
"euiQuickSelect.unitLabel": any;
"euiQuickSelect.applyButton": any;
"euiQuickSelect.fullDescription": any;
"euiCommonlyUsedTimeRanges.legend": any;
"euiDataGridCell.focusTrapExitPrompt": any;
"euiDataGridCell.focusTrapEnterPrompt": any;
"euiDataGridCell.focusTrapEnteredExitPrompt": any;
"euiDataGridCellActions.expandButtonTitle": any;
"euiDataGridCell.position": any;
"euiDataGridCell.expansionEnterPrompt": any;
"euiDataGridHeaderCell.sortedByAscendingSingle": any;
"euiDataGridHeaderCell.sortedByDescendingSingle": any;
"euiDataGridHeaderCell.sortedByAscendingFirst": any;
"euiDataGridHeaderCell.sortedByDescendingFirst": any;
"euiDataGridHeaderCell.sortedByAscendingMultiple": any;
"euiDataGridHeaderCell.sortedByDescendingMultiple": any;
"euiDataGridHeaderCell.actionsButtonAriaLabel": any;
"euiDataGridHeaderCell.actionsEnterKeyInstructions": any;
"euiDataGridHeaderCell.actionsPopoverScreenReaderText": any;
"euiColumnActions.hideColumn": any;
"euiColumnActions.moveLeft": any;
"euiColumnActions.moveRight": any;
"euiColumnActions.unsort": any;
"euiColumnActions.sort": any;
"euiCollapsedNavButton.ariaLabelButtonIcon": any;
  }
}