import { type ComponentPropsWithRef, type ComponentPropsWithoutRef, type ElementType } from 'react';
export type AsProp<As extends ElementType> = {
    /**
     * An override of the default HTML tag.
     * Can also be another React component.
     */
    as?: As;
};
/**
 * Allows for extending a set of props (`ExtendedProps`) by an overriding set of props
 * (`OverrideProps`), ensuring that any duplicates are overridden by the overriding
 * set of props.
 */
export type ExtendableProps<ExtendedProps = object, OverrideProps = object> = OverrideProps & Omit<ExtendedProps, keyof OverrideProps>;
/**
 * Allows for inheriting the props from the specified element type so that
 * props like children, className & style work, as well as element-specific
 * attributes like aria roles. The component (`C`) must be passed in.
 */
export type InheritableElementProps<C extends ElementType, Props = object> = ExtendableProps<ComponentPropsWithoutRef<C>, Props>;
/**
 * A more sophisticated version of `InheritableElementProps` where
 * the passed in `as` prop will determine which props can be included
 */
export type PolymorphicComponentProps<C extends ElementType, Props = object> = InheritableElementProps<C, Props & AsProp<C>>;
/**
 * Utility type to extract the `ref` prop from a polymorphic component
 */
export type PolymorphicRef<C extends ElementType> = ComponentPropsWithRef<C>['ref'];
export type RefProps<C extends ElementType> = {
    /**
     * A ref to the root element.
     */
    ref?: PolymorphicRef<C>;
};
/**
 * A wrapper of `PolymorphicComponentProps` that also includes the `ref`
 * prop for the polymorphic component
 */
export type PolymorphicComponentPropsWithRef<C extends ElementType, Props = object> = PolymorphicComponentProps<C, Props> & RefProps<C>;
/**
 * A type that represents the exclusive props of `T` and `U`.
 *
 * Example usage:
 *
 * ```typescript
 * type A = { a: string, b: number };
 * type B = { b: string, c: boolean };
 *
 * type ExclusiveAB = Exclusive<A, B>;
 *
 * // ExclusiveAB will be either:
 * // { a: string, b: number, c?: undefined }
 * // or
 * // { b: string, c: boolean, a?: undefined }
 * ```
 */
export type Exclusive<T, U> = (T & {
    [K in keyof U]?: undefined;
}) | (U & {
    [K in keyof T]?: undefined;
});
export type SetTimeoutReturn = ReturnType<typeof setTimeout>;