@fluentui/react-utilities 9.26.5 → 9.74.3-experimental.esm.20260709-49ee7a20cf.0

package/dist/index.d.cts

@@ -0,0 +1,1249 @@
+import * as React_2 from 'react';
+
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `elementType` - the base element type of a slot, defaults to `'div'`
+ * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.
+ */
+declare function always<Props extends UnknownSlotProps>(value: Props | SlotShorthandValue | undefined, options: SlotOptions<Props>): SlotComponentType<Props>;
+
+/**
+ * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.
+ *
+ * @internal
+ */
+export declare function applyTriggerPropsToChildren<TriggerChildProps>(children: TriggerProps<TriggerChildProps>['children'], triggerChildProps: TriggerChildProps): React_2.ReactElement | null;
+
+/**
+ * Helper type for inferring the type of the as prop from a Props type.
+ *
+ * For example:
+ * ```
+ * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
+ * ```
+ */
+declare type AsIntrinsicElement<As extends JSXIntrinsicElementKeys> = {
+    as?: As;
+};
+
+/**
+ * Assertion method to ensure state slots properties are properly declared.
+ * A properly declared slot must be declared by using the `slot` method.
+ *
+ * @internal
+ * @example
+ * ```tsx
+ * export const renderInput_unstable  = (state: InputState): JSXElement => {
+ *     assertSlots<InputSlots>(state);
+ *     return (
+ *       <state.root>
+ *         {state.contentBefore && <state.contentBefore />}
+ *         <state.input />
+ *         {state.contentAfter && <state.contentAfter />}
+ *       </state.root>
+ *     );
+ *   };
+ * ```
+ */
+export declare function assertSlots<Slots extends SlotPropsRecord>(state: unknown): asserts state is SlotComponents<Slots>;
+
+/**
+ * Verifies if an application can use DOM.
+ */
+export declare function canUseDOM(): boolean;
+
+/**
+ * Clamps `value` to a number between the min and max.
+ *
+ * @internal
+ * @param value - the value to be clamped
+ * @param min - the lowest valid value
+ * @param max - the highest valid value
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+
+/**
+ * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
+ */
+declare interface ComponentClass<P = {}, S = React_2.ComponentState> extends React_2.StaticLifecycle<P, S> {
+    new (props: P): React_2.Component<P, S>;
+}
+
+/**
+ * Defines the Props type for a component given its slots and the definition of which one is the primary slot,
+ * defaulting to root if one is not provided.
+ */
+export declare type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> = Omit<Slots, Primary & 'root'> & PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;
+
+/**
+ * Defines the State object of a component given its slots.
+ */
+export declare type ComponentState<Slots extends SlotPropsRecord> = {
+    /**
+     * @deprecated
+     * The base element type for each slot.
+     * This property is deprecated and will be removed in a future version.
+     * The slot base element type is declared through `slot.*(slotShorthand, {elementType: ElementType})` instead.
+     */
+    components: {
+        [Key in keyof Slots]-?: React_2.ElementType;
+    };
+} & {
+    [Key in keyof Slots]: ReplaceNullWithUndefined<WithoutSlotRenderFunction<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>>;
+};
+
+/**
+ * With react 18, our `children` type starts leaking everywhere and that causes conflicts on component declaration, specially in the `propTypes` property of
+ * both `ComponentClass` and `FunctionComponent`.
+ *
+ * This type substitutes `React.ComponentType` only keeping the function signature, it omits `propTypes`, `displayName` and other properties that are not
+ * required for the inference.
+ *
+ * @internal
+ */
+declare type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+
+/**
+ * @internal
+ * @param compare - comparison function for items
+ * @returns Priority queue implemented with a min heap
+ */
+export declare function createPriorityQueue<T>(compare: PriorityQueueCompareFn<T>): PriorityQueue<T>;
+
+/**
+ * Helper type that works similar to Omit,
+ * but when modifying an union type it will distribute the omission to all the union members.
+ *
+ * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information
+ */
+export declare type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : T;
+
+/**
+ * Similar functionality to `element.contains` DOM API for use without of order DOM elements that
+ * checks the virtual parent hierarchy. If a virtual parents exists, it is chosen over the actual parent
+ *
+ * @internal
+ * @returns true if the child can find the parent in its virtual hierarchy
+ */
+export declare function elementContains(parent: Node | null, child: Node | null): boolean;
+
+/**
+ * HTML element types that are not allowed to have children.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
+ */
+declare type EmptyIntrinsicElements = 'area' | 'base' | 'br' | 'col' | 'embed' | 'hr' | 'img' | 'input' | 'link' | 'meta' | 'param' | 'source' | 'track' | 'wbr';
+
+/**
+ * Data type for event handlers. It makes data a discriminated union, where each object requires `event` and `type` property.
+ * - `event` is the specific event type
+ * - `type` is a string literal. It serves as a clear identifier of the event type that reflects the component's state when the event occurred.
+ *    For example, the Tree component's `onNavigation` event handler has different `type` for different key presses: `{ event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowRight } | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowLeft }`.
+ *    Developers can use the `type` property to identify and filter events of interest.
+ * See RFC event-handlers-event-type.md for more details.
+ *
+ * Example usage:
+ * type OnOpenChangeData = (
+ *   | EventData\<'click', React.MouseEvent\<MyComponentElement\>\>
+ *   | EventData\<'keydown', React.KeyboardEvent\<MyComponentElement\>\>
+ * ) & \{ open: boolean; \};
+ */
+export declare type EventData<Type extends string, TEvent> = {
+    type: undefined;
+    event: React_2.SyntheticEvent | Event;
+} | {
+    type: Type;
+    event: TEvent;
+};
+
+/**
+ * Type for props that are event handlers.
+ * See RFC event-handlers-event-type.md for more details.
+ *
+ * Example usage:
+ * type OnSomeEventData = EventData\<'click', React.MouseEvent\<MyComponentElement\>\> & \{ open: boolean; \};
+ * type SomeProps = \{ onSomeEvent?: EventHandler\<OnSomeEventData\>; \};
+ */
+export declare type EventHandler<TData extends EventData<string, unknown>> = (ev: React_2.SyntheticEvent | Event, data: TData) => void;
+
+declare interface ExoticComponent<P> {
+    (props: P): any;
+    $$typeof: symbol;
+}
+
+/**
+ * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.
+ */
+export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;
+
+/**
+ * Allows a component to be tagged as a FluentUI trigger component.
+ *
+ * Triggers are special-case components: they attach event listeners and other props on their child,
+ * and use them to trigger another component to show. Examples include `MenuTrigger` and `Tooltip`.
+ *
+ * A component can be tagged as a trigger as follows:
+ * ```ts
+ * const MyComponent: React.FC<MyComponentProps> & FluentTriggerComponent = ...;
+ *
+ * MyComponent.isFluentTriggerComponent = true; // MUST also set this to true
+ * ```
+ *
+ * @internal
+ */
+export declare type FluentTriggerComponent = {
+    isFluentTriggerComponent?: boolean;
+};
+
+/**
+ * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
+ *
+ * @remarks
+ * {@link React.RefAttributes} is {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/69756 | leaking string references} into `forwardRef` components
+ *  after introducing {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68720 | RefAttributes Type Extension}, which shipped in `@types/react@18.2.61`
+ * - `forwardRef` component do not support string refs.
+ * - uses custom `RefAttributes` which is compatible with all React versions enforcing no `string` allowance.
+ */
+export declare type ForwardRefComponent<Props> = NamedExoticComponent<Props & RefAttributes<InferredElementRefType<Props>>>;
+
+/**
+ * On types/react 18 there are two types being delivered,
+ * they rely on the typescript version to decide which will be consumed {@link https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b59dc3ac1e2770fbd6cdbb90ba52abe04c168196/types/react/package.json#L10}
+ *
+ * If TS is higher than 5.0 then the `FunctionComponent` will be returning ReactNode (which we don't support)
+ * If TS is below or equal to 5.0 then the `FunctionComponent` will be returning ReactElement | null (which we support)
+ *
+ * Since it's not possible to have a single type that works for both cases
+ * (as ReactNode is more specific, and this will break while evaluating functions),
+ * we need to create our own `FunctionComponent` type
+ * that will work for both cases.
+ *
+ * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
+ */
+declare interface FunctionComponent<P> {
+    (props: P): any;
+    displayName?: string;
+}
+
+/**
+ * Returns an object with clientX, clientY for TouchOrMouseEvent.
+ * Returns zeros in case the event is not a mouse or a touch event.
+ */
+export declare function getEventClientCoords(event: TouchOrMouseEvent): {
+    clientX: number;
+    clientY: number;
+};
+
+/**
+ * Given an element tagname and user props, filters the props to only allowed props for the given
+ * element type.
+ *
+ * Equivalent to {@link getNativeElementProps}, but more type-safe.
+ *
+ * @param tagName - The slot's default element type (e.g. 'div')
+ * @param props - The component's props object
+ * @param excludedPropNames - List of native props to exclude from the returned value
+ */
+export declare const getIntrinsicElementProps: <Props extends UnknownSlotProps, ExcludedPropKeys extends Extract<keyof Props, string> = never>(tagName: NonNullable<Props["as"]>, props: Props & React_2.RefAttributes<InferredElementRefType<Props>>, excludedPropNames?: ExcludedPropKeys[]) => DistributiveOmit<Props, ExcludedPropKeys | Exclude<keyof Props, "as" | keyof HTMLAttributes>>;
+
+/**
+ * Given an element tagname and user props, filters the props to only allowed props for the given
+ * element type.
+ * @param tagName - Tag name (e.g. "div")
+ * @param props - Props object
+ * @param excludedPropNames - List of props to disallow
+ *
+ * @deprecated use getIntrinsicElementProps instead, it is a type-safe version of this method
+ */
+export declare function getNativeElementProps<TAttributes extends React_2.HTMLAttributes<any>>(tagName: string, props: {}, excludedPropNames?: string[]): TAttributes;
+
+/**
+ * Gets the element which is the parent of a given element.
+ * This method prefers the virtual parent over real DOM parent when present.
+ * @internal
+ */
+export declare function getParent(child: Node | null, options?: GetParentOptions): Node | null;
+
+declare type GetParentOptions = {
+    /**
+     * Indicates if getParent() should ignore a virtual parent.
+     * @internal
+     */
+    skipVirtual?: boolean;
+};
+
+/**
+ * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.
+ *
+ * This function is only for use with components that have a primary slot other than `root`.
+ * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.
+ *
+ * @returns An object containing the native props for the `root` and primary slots.
+ */
+export declare const getPartitionedNativeProps: <Props extends Pick<React_2.HTMLAttributes<HTMLElement>, "style" | "className">, ExcludedPropKeys extends Extract<keyof Props, string> = never>({ primarySlotTagName, props, excludedPropNames, }: {
+    /** The primary slot's element type (e.g. 'div') */
+    primarySlotTagName: JSXIntrinsicElementKeys;
+    /** The component's props object */
+    props: Props;
+    /** List of native props to exclude from the returned value */
+    excludedPropNames?: ExcludedPropKeys[];
+}) => {
+    root: {
+        style: React_2.CSSProperties | undefined;
+        className: string | undefined;
+    };
+    primary: Omit<Props, ExcludedPropKeys>;
+};
+
+/**
+ * Returns a ref for the React element in a backwards-compatible way.
+ *
+ * @param element - The element to get the ref for.
+ * @returns The ref for the element.
+ */
+export declare function getReactElementRef<T>(element: React_2.ReactElement | null | undefined): React_2.Ref<T> | undefined;
+
+/**
+ * Finds and swaps a provided key for it's right to left format.
+ *
+ * @internal
+ */
+export declare const getRTLSafeKey: (key: string, dir: "ltr" | "rtl") => string;
+
+/**
+ * Get the className prop set on the slot by the user, without including the default classes added by the component.
+ * Custom style hooks should merge this className _after_ any additional classes added by the hook, to ensure that
+ * classes added by the user take precedence over the custom style hook.
+ *
+ * Example usage in a custom style hook:
+ * ```ts
+ * state.root.className = mergeClasses(
+ *   state.root.className,
+ *   customStyles.root,
+ *   getSlotClassNameProp_unstable(state.root));
+ * ```
+ *
+ * @returns The className prop set on the slot by the user, or undefined if not set.
+ */
+export declare const getSlotClassNameProp_unstable: (slot: UnknownSlotProps) => string | undefined;
+
+/**
+ * Given the state and an array of slot names, will break out `slots` and `slotProps`
+ * collections.
+ *
+ * The root is derived from a mix of `components` props and `as` prop.
+ *
+ * Slots will render as null if they are rendered as primitives with undefined children.
+ *
+ * The slotProps will always omit the `as` prop within them, and for slots that are string
+ * primitives, the props will be filtered according to the slot type by the type system.
+ * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable
+ * anchor props. Note that this is only enforced at build time by Typescript -- there is no
+ * runtime code filtering props in this function.
+ *
+ * @deprecated use slot.always or slot.optional combined with assertSlots instead
+ *
+ * @param state - State including slot definitions
+ * @returns An object containing the `slots` map and `slotProps` map.
+ */
+export declare function getSlots<R extends SlotPropsRecord>(state: unknown): {
+    slots: Slots<R>;
+    slotProps: ObjectSlotProps<R>;
+};
+
+/**
+ * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma
+ *
+ * This is an internal temporary method, this method will cease to exist eventually!
+ *
+ * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️
+ *
+ * @internal
+ * @deprecated use slot.always or slot.optional combined with assertSlots instead
+ */
+export declare function getSlotsNext<R extends SlotPropsRecord>(state: unknown): {
+    slots: Slots<R>;
+    slotProps: ObjectSlotProps<R>;
+};
+
+/**
+ * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).
+ *
+ * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,
+ * it returns the first descendant that is _not_ a FluentTriggerComponent or Fragment.
+ * This allows multiple triggers to be stacked, and still apply their props to the actual trigger element.
+ *
+ * For example, the following returns `<div id="child" />`:
+ * ```jsx
+ * getTriggerChild(
+ *   <Tooltip>
+ *     <MenuTrigger>
+ *       <div id="child" />
+ *     </MenuTrigger>
+ *   </Tooltip>
+ * );
+ * ```
+ *
+ * In the case where the immediate child is not a valid element,
+ * null is returned
+ *
+ * @internal
+ */
+export declare function getTriggerChild<TriggerChildProps>(children: TriggerProps<TriggerChildProps>['children']): (React_2.ReactElement<Partial<TriggerChildProps>> & {
+    ref?: React_2.Ref<any>;
+}) | null;
+
+declare type HTMLAttributes = React_2.HTMLAttributes<any>;
+
+declare type HTMLElementConstructorName = 'HTMLElement' | 'HTMLAnchorElement' | 'HTMLAreaElement' | 'HTMLAudioElement' | 'HTMLBaseElement' | 'HTMLBodyElement' | 'HTMLBRElement' | 'HTMLButtonElement' | 'HTMLCanvasElement' | 'HTMLDataElement' | 'HTMLDataListElement' | 'HTMLDetailsElement' | 'HTMLDivElement' | 'HTMLDListElement' | 'HTMLEmbedElement' | 'HTMLFieldSetElement' | 'HTMLFormElement' | 'HTMLHeadingElement' | 'HTMLHeadElement' | 'HTMLHRElement' | 'HTMLHtmlElement' | 'HTMLIFrameElement' | 'HTMLImageElement' | 'HTMLInputElement' | 'HTMLModElement' | 'HTMLLabelElement' | 'HTMLLegendElement' | 'HTMLLIElement' | 'HTMLLinkElement' | 'HTMLMapElement' | 'HTMLMetaElement' | 'HTMLMeterElement' | 'HTMLObjectElement' | 'HTMLOListElement' | 'HTMLOptGroupElement' | 'HTMLOptionElement' | 'HTMLOutputElement' | 'HTMLParagraphElement' | 'HTMLParamElement' | 'HTMLPreElement' | 'HTMLProgressElement' | 'HTMLQuoteElement' | 'HTMLSlotElement' | 'HTMLScriptElement' | 'HTMLSelectElement' | 'HTMLSourceElement' | 'HTMLSpanElement' | 'HTMLStyleElement' | 'HTMLTableElement' | 'HTMLTableColElement' | 'HTMLTableRowElement' | 'HTMLTableSectionElement' | 'HTMLTemplateElement' | 'HTMLTextAreaElement' | 'HTMLTimeElement' | 'HTMLTitleElement' | 'HTMLTrackElement' | 'HTMLUListElement' | 'HTMLVideoElement';
+
+/**
+ * Allows to define a prefix that will be used for all IDs generated by useId() hook. It's useful to avoid collisions
+ * between different bundles.
+ */
+export declare const IdPrefixProvider: React_2.Provider<string | undefined>;
+
+/**
+ * Infers the element type from props that are declared using ComponentProps.
+ */
+export declare type InferredElementRefType<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React_2.PointerEventHandler<infer Element> ? Element : never : never;
+
+/**
+ * Helper type for {@link Slot}. Modifies `JSXIntrinsicElements<Type>`:
+ * * Removes legacy string ref.
+ * * Disallows children for empty tags like 'img'.
+ */
+declare type IntrinsicElementProps<Type extends JSXIntrinsicElementKeys> = Type extends EmptyIntrinsicElements ? PropsWithoutChildren<React_2.PropsWithRef<JSXIntrinsicElement<Type>>> : React_2.PropsWithRef<JSXIntrinsicElement<Type>>;
+
+/**
+ * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).
+ * See the {@link FluentTriggerComponent} type for more info.
+ *
+ * @internal
+ */
+export declare function isFluentTrigger(element: React_2.ReactElement): element is React_2.ReactElement<TriggerProps>;
+
+/**
+ * Verifies if a given node is an HTMLElement,
+ * this method works seamlessly with frames and elements from different documents
+ *
+ * This is preferred over simply using `instanceof`.
+ * Since `instanceof` might be problematic while operating with [multiple realms](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)
+ *
+ * @example
+ * ```ts
+ * isHTMLElement(event.target) && event.target.focus()
+ * isHTMLElement(event.target, {constructorName: 'HTMLInputElement'}) && event.target.value // some value
+ * ```
+ *
+ */
+export declare function isHTMLElement<ConstructorName extends HTMLElementConstructorName = 'HTMLElement'>(element?: unknown, options?: {
+    /**
+     * Can be used to provide a custom constructor instead of `HTMLElement`,
+     * Like `HTMLInputElement` for example.
+     */
+    constructorName?: ConstructorName;
+}): element is InstanceType<(typeof globalThis)[ConstructorName]>;
+
+/**
+ * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys
+ *
+ * @internal
+ */
+export declare function isInteractiveHTMLElement(element: unknown): boolean;
+
+/**
+ * Returns true if event is a mouse event. Useful when sharing logic between touch and mouse interactions.
+ */
+export declare function isMouseEvent(event: TouchOrMouseEvent): event is MouseEvent | React_2.MouseEvent;
+
+/**
+ * Guard method that validates if a shorthand is a slot
+ * can be used to extends properties provided by a slot
+ *
+ * @example
+ * ```
+ * const backdropSlot = resolveShorthand(backdrop, {
+ *  defaultProps: {
+ *    onClick: useEventCallback(event => {
+ *     if (isResolvedShorthand(backdrop)) {
+ *        backdrop.onClick?.(event)
+ *      }
+ *      // do something after passing click down the line
+ *    }),
+ *  },
+ * })
+ * ```
+ * @example
+ * ```
+ * const handleBackDropClick = (event) => {
+ *  // do your thing
+ * }
+ * const backdropSlot = resolveShorthand(backdrop, {
+ *  defaultProps: {
+ *    onClick: useEventCallback(
+ *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)
+ *    )
+ * })
+ * ```
+ */
+export declare function isResolvedShorthand<Shorthand extends Slot<UnknownSlotProps>>(shorthand?: Shorthand): shorthand is ExtractSlotProps<Shorthand>;
+
+/**
+ * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
+ *
+ * ```
+ * IsSingleton<'a'> // true
+ * IsSingleton<'a' | 'b' | 'c'> // false
+ * ```
+ */
+declare type IsSingleton<T extends string> = {
+    [K in T]: Exclude<T, K> extends never ? true : false;
+}[T];
+
+/**
+ * Guard method to ensure a given element is a slot.
+ * This is mainly used internally to ensure a slot is being used as a component.
+ */
+export declare function isSlot<Props extends {}>(element: unknown): element is SlotComponentType<Props>;
+
+/**
+ * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.
+ */
+export declare function isTouchEvent(event: TouchOrMouseEvent): event is TouchEvent | React_2.TouchEvent;
+
+/**
+ * Our own alias for `JSX.Element` type that is compatible with both React 17 and React 18+.
+ * Use this type when annotating JSX markup in all our code in order to avoid issues between different React versions.
+ *
+ * Example usage:
+ *
+ * BAD:
+ * ```tsx
+ * const renderFoo = (state: FooState) = <div {...props}>Hello World</div>;
+ * // infers
+ * // R17:  declare const renderFoo: (state: FooState) => JSX.Element;
+ * // R18+: declare const renderFoo: (state: FooState) => React.JSX.Element;
+ * ```
+ *
+ * GOOD:
+ * ```tsx
+ * import type { JSXElement } from '@fluentui/react-utilities';
+ * const renderFoo = (state: FooState): JSXElement = <div {...props}>Hello World</div>;
+ * ```
+ */
+export declare type JSXElement = React_2.ReactElement<any, any>;
+
+/**
+ * Our own alias for `JSX.IntrinsicElements` type that is compatible with both React 17 and React 18+.
+ * Use this type to get the intrinsic elements from React types in order to avoid issues between different React versions.
+ */
+export declare type JSXIntrinsicElement<Element extends JSXIntrinsicElementKeys> = React_2.ComponentProps<Element>;
+
+/**
+ * Type representing all valid JSX intrinsic element names (e.g., 'div', 'button', 'input').
+ * It's derived from `React.ElementType` by excluding all custom component types (`React.ComponentType`), ensuring it only includes standard HTML and SVG elements.
+ *
+ * Use this type when you need to restrict a type to only valid intrinsic element names.
+ *
+ * @example
+ * ```tsx
+ * import * as React from 'react';
+ * import type { JSXIntrinsicElementKeys } from '@fluentui/react-utilities';
+ *
+ * const createElement = (tag: JSXIntrinsicElementKeys) => React.createElement(tag, {});
+ *
+ * createElement('div'); // Valid
+ * createElement('span'); // Valid
+ * createElement('unknown'); // Error: Argument of type '"unknown"' is not assignable to parameter of type 'JSXIntrinsicElementKeys'.
+ * ```
+ *
+ * This type helps ensure that only valid intrinsic elements are used in scenarios where custom components are not allowed.
+ */
+export declare type JSXIntrinsicElementKeys = Exclude<React_2.ElementType, React_2.ComponentType>;
+
+/**
+ * Combine two event callbacks into a single callback function that calls each one in order.
+ *
+ * Usage example:
+ * ```ts
+ * state.slot.onChange = mergeCallbacks(state.slot.onChange, ev => {
+ *   // Handle onChange
+ * });
+ * ```
+ *
+ * The primary use is to avoid the need to capture an existing callback (`state.slot.onChange` in the example) to a
+ * local variable before replacing with a new listener that calls the existing one. This helps avoid bugs like:
+ * * Infinite recursion by calling the re-assigned state.slot.onChange if it's not captured to a local variable.
+ * * Missing a call to the original onChange due to an early return or other conditional.
+ *
+ * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.
+ *
+ * @internal
+ * @param callback1 - The first callback to be called, or undefined
+ * @param callback2 - The second callback to be called, or undefined
+ *
+ * @returns A function that that calls the provided functions in order
+ */
+export declare function mergeCallbacks<Args extends unknown[]>(callback1: ((...args: Args) => void) | undefined, callback2: ((...args: Args) => void) | undefined): (...args: Args) => void;
+
+declare interface NamedExoticComponent<P> extends ExoticComponent<P> {
+    displayName?: string;
+}
+
+export declare type NativeTouchOrMouseEvent = MouseEvent | TouchEvent;
+
+/**
+ * @deprecated - use slot.always or slot.optional combined with assertSlots instead
+ */
+declare type ObjectSlotProps<S extends SlotPropsRecord> = {
+    [K in keyof S]-?: any;
+};
+
+/**
+ * This is part of a hack to infer the element type from a native element *props* type.
+ * The only place the original element is found in a native props type (at least that's workable
+ * for inference) is in the event handlers, so some of the helper types use this event handler
+ * name to infer the original element type.
+ *
+ * Notes:
+ * - Using an extremely obscure event handler reduces the likelihood that its signature will be
+ *   modified in any component's props.
+ * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be
+ *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.
+ */
+declare type ObscureEventName = 'onLostPointerCaptureCapture';
+
+/**
+ * Tiny helper to do the minimal amount of work in duplicating an object but omitting some
+ * props. This ends up faster than using object ...rest or reduce to filter.
+ *
+ * This behaves very much like filteredAssign, but does not merge many objects together,
+ * uses an exclusion object map, and avoids spreads all for optimal performance.
+ *
+ * See perf test for background:
+ * https://jsperf.com/omit-vs-rest-vs-reduce/1
+ *
+ * @param obj - The object to clone
+ * @param exclusions - The array of keys to exclude
+ */
+export declare function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(obj: TObj, exclusions: Exclusions): Omit<TObj, Exclusions[number]>;
+
+export declare type OnSelectionChangeCallback = (event: React_2.SyntheticEvent, selectedItems: Set<SelectionItemId>) => void;
+
+export declare type OnSelectionChangeData = {
+    selectedItems: Set<SelectionItemId>;
+};
+
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `elementType` - the base element type of a slot, defaults to `'div'`
+ * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided
+ * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.
+ * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`
+ * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object
+ * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content
+ * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`
+ */
+declare function optional<Props extends UnknownSlotProps>(value: Props | SlotShorthandValue | undefined | null, options: {
+    renderByDefault?: boolean;
+} & SlotOptions<Props>): SlotComponentType<Props> | undefined;
+
+/**
+ * @internal
+ */
+export declare interface PriorityQueue<T> {
+    all: () => T[];
+    clear: () => void;
+    contains: (item: T) => boolean;
+    dequeue: () => T;
+    enqueue: (item: T) => void;
+    peek: () => T | null;
+    remove: (item: T) => void;
+    size: () => number;
+}
+
+/**
+ * @internal
+ */
+declare type PriorityQueueCompareFn<T> = (a: T, b: T) => number;
+
+/**
+ * Removes the 'children' prop from the given Props type, leaving unions intact (such as the discriminated union created by
+ * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.
+ */
+declare type PropsWithoutChildren<P> = 'children' extends keyof P ? DistributiveOmit<P, 'children'> : P;
+
+/**
+ * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
+ * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.
+ */
+declare type PropsWithoutRef<P> = 'ref' extends keyof P ? DistributiveOmit<P, 'ref'> : P;
+
+/**
+ * on types/react 18 ReactNode becomes a more strict type, which is not compatible with our current implementation. to avoid any issues we are creating our own ReactNode type which allows anything.
+ *
+ * This type should only be used for inference purposes, and should never be exposed.
+ *
+ * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
+ */
+declare type ReactNode = any;
+
+export declare type ReactTouchOrMouseEvent = React_2.MouseEvent | React_2.TouchEvent;
+
+/**
+ * This type is used to determine if the current version of React is 18+ or not.
+ *
+ * It checks if the `React.ReactNode` has `{}` it its type.
+ * If it is, then it means that the current version of React is lower than 18.
+ * If it is not, then it means that the current version of React is 18 or higher.
+ * This is useful for ensuring compatibility with different versions of React.
+ *
+ * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
+ */
+declare type ReactVersionDependent<Modern, Legacy> = {} extends React_2.ReactNode ? Legacy : Modern;
+
+/**
+ * This type should be used in place of `React.RefAttributes<T>` in all components that specify `ref` prop.
+ *
+ * If user is using React 18 types `>=18.2.61`, they will run into type issues of incompatible refs, using this type mitigates this issues across react type versions.
+ *
+ * @remarks
+ *
+ * React 18 types introduced Type Expansion Change to the `RefAttributes` interface as patch release.
+ * These changes were released in `@types/react@18.2.61` (replacing ref with `LegacyRef`, which leaks `string` into the union type, causing breaking changes between v8/v9 libraries):
+ *  - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68720 | PR }
+ *  - {@link https://app.unpkg.com/@types/react@18.2.61/files/index.d.ts | shipped definitions }
+ *
+ *
+ * In React 19 types this was "reverted" back to the original `Ref<T>` type.
+ * In order to maintain compatibility with React 17,18,19, we are forced to use our own version of `RefAttributes`.
+ *
+ */
+export declare interface RefAttributes<T> extends React_2.Attributes {
+    ref?: React_2.Ref<T> | undefined;
+}
+
+/**
+ * A Ref function which can be treated like a ref object in that it has an attached
+ * current property, which will be updated as the ref is evaluated.
+ */
+export declare type RefObjectFunction<T> = React_2.RefObject<T | null> & ((value: T | null) => void);
+
+/**
+ * If type T includes `null`, remove it and add `undefined` instead.
+ *
+ * @internal
+ */
+declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
+
+/**
+ * Resets generated IDs, should be used only in tests.
+ */
+export declare function resetIdsForTests(): void;
+
+/**
+ *
+ * Resolves shorthands into slot props, to ensure normalization of the signature
+ * being passed down to getSlots method
+ * @param value - the base shorthand props
+ * @param options - options to resolve shorthand props
+ *
+ * @deprecated use slot.always, slot.optional, slot.resolveShorthand combined with assertSlots instead
+ */
+export declare const resolveShorthand: ResolveShorthandFunction<UnknownSlotProps>;
+
+/**
+ * Helper function that converts a slot shorthand or properties to a slot properties object
+ * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object
+ * @param value - the value of the slot, it can be a slot shorthand or a slot properties object
+ */
+declare function resolveShorthand_2<Props extends UnknownSlotProps | null | undefined>(value: Props | SlotShorthandValue): Props;
+
+/**
+ * @deprecated use slot.always or slot.optional combined with assertSlots instead
+ */
+export declare type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {
+    <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): WithoutSlotRenderFunction<P>;
+    <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>): WithoutSlotRenderFunction<P> | undefined;
+};
+
+/**
+ * @deprecated - use slot.always or slot.optional combined with assertSlots instead
+ */
+export declare type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true ? {
+    required: true;
+    defaultProps?: Props;
+} : {
+    required?: Required;
+    defaultProps?: Props;
+};
+
+export declare type SelectionHookParams = {
+    selectionMode: SelectionMode_2;
+    /**
+     * Used in uncontrolled mode to set initial selected items on mount
+     */
+    defaultSelectedItems?: Iterable<SelectionItemId>;
+    /**
+     * Used to control selected items
+     */
+    selectedItems?: Iterable<SelectionItemId>;
+    /**
+     * Called when selection changes
+     */
+    onSelectionChange?(event: React_2.SyntheticEvent, data: OnSelectionChangeData): void;
+};
+
+export declare type SelectionItemId = string | number;
+
+export declare interface SelectionMethods {
+    toggleItem(event: React_2.SyntheticEvent, id: SelectionItemId): void;
+    selectItem(event: React_2.SyntheticEvent, id: SelectionItemId): void;
+    deselectItem(event: React_2.SyntheticEvent, id: SelectionItemId): void;
+    clearItems(event: React_2.SyntheticEvent): void;
+    isSelected(id: SelectionItemId): boolean;
+    toggleAllItems(event: React_2.SyntheticEvent, itemIds: SelectionItemId[]): void;
+}
+
+declare type SelectionMode_2 = 'single' | 'multiselect';
+export { SelectionMode_2 as SelectionMode }
+
+/**
+ * Sets the virtual parent of an element.
+ *
+ * @internal
+ * @param child - Theme element to set the virtual parent
+ * @param parent - The virtual parent, use `undefined` to remove a virtual parent relationship
+ */
+export declare function setVirtualParent(child: Node, parent?: Node): void;
+
+/**
+ * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,
+ * or a component like `typeof Button`.
+ *
+ * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).
+ *
+ * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,
+ * wrap with `NonNullable` (see examples below).
+ *
+ * @example
+ * ```
+ * // Intrinsic element examples:
+ * Slot<'div'> // Slot is always div
+ * Slot<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
+ * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as="div" or as="pre"
+ * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)
+ *
+ * // Component examples:
+ * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props
+ * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)
+ * ```
+ */
+export declare type Slot<Type extends JSXIntrinsicElementKeys | ComponentType<any> | UnknownSlotProps, AlternateAs extends JSXIntrinsicElementKeys = never> = IsSingleton<Extract<Type, string>> extends true ? WithSlotShorthandValue<Type extends JSXIntrinsicElementKeys ? {
+    as?: Type;
+} & WithSlotRenderFunction<IntrinsicElementProps<Type>> : Type extends ComponentType<infer Props> ? Props extends UnknownSlotProps ? Props : WithSlotRenderFunction<Props> : Type> | (AlternateAs extends unknown ? {
+    as: AlternateAs;
+} & WithSlotRenderFunction<IntrinsicElementProps<AlternateAs>> : never) | null : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';
+
+declare namespace slot {
+    export {
+        always,
+        optional,
+        resolveShorthand_2 as resolveShorthand,
+        SlotOptions
+    }
+}
+export { slot }
+
+/**
+ * Internal cache of the original className prop for the slot, before being modified by the useStyles hook.
+ *
+ * @internal
+ */
+export declare const SLOT_CLASS_NAME_PROP_SYMBOL: unique symbol;
+
+/**
+ * Internal reference for the render function
+ *
+ * @internal
+ */
+export declare const SLOT_ELEMENT_TYPE_SYMBOL: unique symbol;
+
+/**
+ * Internal reference for the render function
+ *
+ * @internal
+ */
+export declare const SLOT_RENDER_FUNCTION_SYMBOL: unique symbol;
+
+/**
+ * Helper type to correctly define the slot class names object.
+ */
+export declare type SlotClassNames<Slots> = {
+    [SlotName in keyof Slots]-?: string;
+};
+
+declare type SlotComponents<Slots extends SlotPropsRecord> = {
+    [K in keyof Slots]: SlotComponentType<ExtractSlotProps<Slots[K]>> | (null extends Slots[K] ? undefined : never);
+};
+
+/**
+ * A definition of a slot, as a component, very similar to how a React component is declared,
+ * but with some additional metadata that is used to determine how to render the slot.
+ */
+export declare type SlotComponentType<Props> = WithoutSlotRenderFunction<Props> & FunctionComponent<{
+    children?: ReactNode;
+}> & {
+    /**
+     * @internal
+     */
+    [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<Props>;
+    /**
+     * @internal
+     */
+    [SLOT_ELEMENT_TYPE_SYMBOL]: ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : JSXIntrinsicElementKeys);
+    /**
+     * The original className prop for the slot, before being modified by the useStyles hook.
+     *
+     * @internal
+     */
+    [SLOT_CLASS_NAME_PROP_SYMBOL]?: string;
+};
+
+export declare type SlotOptions<Props extends UnknownSlotProps> = {
+    elementType: React_2.ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : JSXIntrinsicElementKeys);
+    defaultProps?: Partial<Props>;
+};
+
+/**
+ * Matches any component's Slots type (such as ButtonSlots).
+ *
+ * This should ONLY be used in type templates as in `extends SlotPropsRecord`;
+ * it shouldn't be used as a component's Slots type.
+ */
+export declare type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;
+
+export declare type SlotRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'as'>) => ReactNode;
+
+/**
+ * @deprecated - use slot.always or slot.optional combined with assertSlots instead
+ */
+export declare type Slots<S extends SlotPropsRecord> = {
+    [K in keyof S]: React_2.ElementType<any>;
+};
+
+/**
+ * The shorthand value of a slot allows specifying its child
+ */
+export declare type SlotShorthandValue = React_2.ReactElement | string | number | Iterable<ReactNode> | React_2.ReactPortal;
+
+/**
+ * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids
+ * are consistent between the client and server.
+ *
+ * @public
+ */
+export declare const SSRProvider: React_2.FC<{
+    children: React_2.ReactNode;
+}>;
+
+export declare type TouchOrMouseEvent = NativeTouchOrMouseEvent | ReactTouchOrMouseEvent;
+
+/**
+ * A trigger may have a children that could be either:
+ * 1. A single element
+ * 2. A render function that will receive properties and must return a valid element or null
+ * 3. null or undefined
+ */
+export declare type TriggerProps<TriggerChildProps = unknown> = {
+    children?: React_2.ReactElement | ((props: TriggerChildProps) => React_2.ReactElement | null) | null;
+};
+
+/**
+ * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)
+ */
+export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
+
+/**
+ * Matches any slot props type.
+ *
+ * This should ONLY be used in type templates as in `extends UnknownSlotProps`;
+ * it shouldn't be used as the type of a slot.
+ */
+export declare type UnknownSlotProps = Pick<React_2.HTMLAttributes<HTMLElement>, 'className' | 'style'> & {
+    as?: JSXIntrinsicElementKeys;
+    children?: ReactNode;
+};
+
+/**
+ * Helper to manage a browser requestAnimationFrame.
+ * Ensures that the requestAnimationFrame isn't set multiple times at once and is cleaned up
+ * when the component is unloaded.
+ *
+ * @internal
+ * @returns A pair of [requestAnimationFrame, cancelAnimationFrame] that are stable between renders.
+ */
+export declare function useAnimationFrame(): readonly [(fn: FrameRequestCallback) => number, () => void];
+
+/**
+ * A React hook that provides a ref for applying the browser's scrollbar width as a CSS property.
+ *
+ * This hook is SSR-safe and caches measurements per document to avoid redundant calculations.
+ * When the ref is attached to an element, the hook automatically applies the measured scrollbar
+ * width to the specified CSS property (defaults to 'width').
+ *
+ * @example
+ * ```tsx
+ * const scrollbarRef = useApplyScrollbarWidth({ targetDocument: document });
+ * return <div ref={scrollbarRef} />;
+ * ```
+ */
+export declare function useApplyScrollbarWidth<T extends HTMLElement>(options?: UseApplyScrollbarWidthOptions): React_2.RefCallback<T>;
+
+declare interface UseApplyScrollbarWidthOptions {
+    /**
+     * Does not use the cache and recalculates the scrollbar width
+     */
+    force?: boolean;
+    /**
+     * CSS property to apply the scrollbar width to.
+     * @default 'width'
+     */
+    property?: string;
+}
+
+/**
+ * A [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate)-like hook
+ * to manage a value that could be either `controlled` or `uncontrolled`,
+ * such as a checked state or text input string.
+ *
+ * @internal
+ * @see https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components for more details on `controlled`/`uncontrolled`
+ *
+ * @returns an array of the current value and an updater (dispatcher) function.
+ * The updater function is referentially stable (won't change during the component's lifecycle).
+ * It can take either a new value, or a function which is passed the previous value and returns the new value.
+ *
+ * ❗️❗️ Calls to the dispatcher will only modify the state if the state is `uncontrolled`.
+ * Meaning that if a state is `controlled`, calls to the dispatcher do not modify the state.
+ */
+export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React_2.Dispatch<React_2.SetStateAction<State>>];
+
+/**
+ * @internal
+ */
+export declare type UseControllableStateOptions<State> = {
+    /**
+     * User-provided default state or initializer, for uncontrolled usage.
+     */
+    defaultState?: State | (() => State);
+    /**
+     * User-provided controlled state. `undefined` means internal state will be used.
+     */
+    state: State | undefined;
+    /**
+     * Used as the initial state if `state` and `defaultState` are both `undefined`.
+     * If `undefined` is the correct initial state, pass that here.
+     */
+    initialState: State;
+};
+
+/**
+ * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
+ *
+ * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when
+ * e.g. user props are dependencies which could change on every render
+ * e.g. volatile values (i.e. useState/useDispatch) are dependencies which could change frequently
+ *
+ * This should not be used often, but can be a useful re-render optimization since the callback is a ref and
+ * will not be invalidated between re-renders
+ *
+ * @internal
+ * @param fn - The callback function that will be used
+ */
+export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => ((...args: Args) => Return);
+
+/**
+ * Checks if components was mounted the first time.
+ * Supports React concurrent/strict mode by using `useEffect`
+ * to track the first mount instead of mutating refs during render.
+ *
+ * @internal
+ * @example
+ * const isFirstMount = useFirstMount();
+ */
+export declare function useFirstMount(): boolean;
+
+/**
+ * Forces a re-render, similar to `forceUpdate` in class components.
+ *
+ * @internal
+ */
+export declare function useForceUpdate(): React_2.DispatchWithoutAction;
+
+/**
+ * Hook to generate a unique ID.
+ *
+ * @param prefix - Optional prefix for the ID. Defaults to 'fui-'.
+ * @param providedId - Optional id provided by a parent component. Defaults to the provided value if present,
+ *  without conditioning the hook call
+ * @returns The ID
+ */
+export declare function useId(prefix?: string, providedId?: string): string;
+
+/**
+ * React currently throws a warning when using useLayoutEffect on the server. To get around it, we can conditionally
+ * useEffect on the server (no-op) and useLayoutEffect in the browser. We occasionally need useLayoutEffect to
+ * ensure we don't get a render flash for certain operations, but we may also need affected components to render on
+ * the server.
+ *
+ * https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85
+ * https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.js
+ */
+export declare const useIsomorphicLayoutEffect: typeof React_2.useEffect;
+
+/**
+ * Returns whether the component is currently being server side rendered or hydrated on the client. Can be used to delay
+ * browser-specific rendering until after hydration. May cause re-renders on a client when is used within SSRProvider.
+ */
+export declare function useIsSSR(): boolean;
+
+/**
+ * React hook to merge multiple React refs (either MutableRefObjects or ref callbacks) into a single ref callback that
+ * updates all provided refs
+ * @param refs - Refs to collectively update with one ref value.
+ * @returns A function with an attached "current" prop, so that it can be treated like a RefObject.
+ */
+export declare function useMergedRefs<T>(...refs: (React_2.Ref<T> | undefined)[]): RefObjectFunction<T>;
+
+/**
+ * @internal
+ */
+export declare type UseOnClickOrScrollOutsideOptions = {
+    /**
+     * The element to listen for the click event
+     */
+    element: Document | undefined;
+    /**
+     * Refs to elements that check if the click is outside
+     */
+    refs: React_2.MutableRefObject<HTMLElement | undefined | null>[];
+    /**
+     * By default uses element.contains, but custom contain function can be provided
+     *
+     * @param parent - provided parent element
+     * @param child - event target element
+     */
+    contains?(parent: HTMLElement | null, child: HTMLElement): boolean;
+    /**
+     * Disables event listeners
+     */
+    disabled?: boolean;
+    /**
+     * Disables custom focus event listeners for iframes
+     */
+    disabledFocusOnIframe?: boolean;
+    /**
+     * Called if the click is outside the element refs
+     */
+    callback: (ev: MouseEvent | TouchEvent) => void;
+};
+
+/**
+ * Utility to perform checks where a click/touch event was made outside a component
+ *
+ * @internal
+ */
+export declare const useOnClickOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
+
+/**
+ * Utility to perform checks where a click/touch event was made outside a component
+ *
+ * @internal
+ */
+export declare const useOnScrollOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
+
+/**
+ * @internal
+ */
+export declare const usePrevious: <ValueType = unknown>(value: ValueType) => ValueType | null;
+
+/**
+ * @returns The width in pixels of the scrollbar in the user agent
+ * @remarks This hook is not SSR-safe. For SSR-safe scrollbar width application, use the `useApplyScrollbarWidth` from {@link file://./useApplyScrollbarWidth.ts} instead.
+ */
+export declare function useScrollbarWidth(options: UseScrollbarWidthOptions): number | undefined;
+
+declare interface UseScrollbarWidthOptions {
+    /**
+     * Reference document to measure the scrollbar width
+     */
+    targetDocument: Document | null | undefined;
+    /**
+     * Does not use the cache and recalculates the scrollbar width
+     */
+    force?: boolean;
+}
+
+export declare function useSelection(params: SelectionHookParams): readonly [Set<SelectionItemId>, SelectionMethods];
+
+/**
+ * Helper to manage a browser timeout.
+ * Ensures that the timeout isn't set multiple times at once and is cleaned up
+ * when the component is unloaded.
+ *
+ * @internal
+ * @returns A pair of [setTimeout, clearTimeout] that are stable between renders.
+ */
+export declare function useTimeout(): readonly [(fn: () => void, delay?: number) => number, () => void];
+
+/**
+ * @internal
+ */
+declare type WithoutSlotRenderFunction<Props> = Props extends unknown ? 'children' extends keyof Props ? Omit<Props, 'children'> & {
+    children?: Exclude<Props['children'], Function>;
+} : Props : never;
+
+/**
+ * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`
+ * to be a render function that takes those props.
+ *
+ * Notes: For React 17 and earlier, `children` can be a render function that returns a ReactNode.
+ * For React 18 and later, `children` can be any value, as React.ReactNode is a more strict type and does not allow functions anymore.
+ * This means that the render functions need to be asserted as `SlotRenderFunction<Props>` for React 18 and later.
+ *
+ * @internal
+ * @example
+ * ```tsx
+ * // For React 17 and earlier:
+ * <Component slot={{ children: (Component, props) => <Component {...props} /> }} />
+ *
+ * // For React 18 and later:
+ * <Component slot={{ children: (Component, props) => <Component {...props} /> as SlotRenderFunction<SlotProps> }} />
+ * ```
+ */
+declare type WithSlotRenderFunction<Props> = PropsWithoutChildren<Props> & {
+    children?: 'children' extends keyof Props ? ReactVersionDependent<ReactNode, Props['children'] | SlotRenderFunction<Props>> : never;
+};
+
+/**
+ * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.
+ */
+declare type WithSlotShorthandValue<Props> = Props | ('children' extends keyof Props ? Extract<SlotShorthandValue, Props['children']> : never);
+
+export { }