import { AriaLabelingProps, RefObject, DOMProps as SharedDOMProps } from '@react-types/shared';
import React, { AnchorHTMLAttributes, Context, CSSProperties, DetailedHTMLProps, ForwardedRef, JSX, ReactElement, ReactNode, RefCallback } from 'react';
export declare const DEFAULT_SLOT: unique symbol;
interface SlottedValue<T> {
    slots?: Record<string | symbol, T>;
}
export type SlottedContextValue<T> = SlottedValue<T> | T | null | undefined;
export type ContextValue<T, E> = SlottedContextValue<WithRef<T, E>>;
type ProviderValue<T> = [Context<T>, T];
type ProviderValues<A, B, C, D, E, F, G, H, I, J, K, L> = [ProviderValue<A>] | [ProviderValue<A>, ProviderValue<B>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>, ProviderValue<D>] | [ProviderValue<A>, ProviderValue<B>, ProviderValue<C>, ProviderValue<D>, ProviderValue<E>] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>,
    ProviderValue<H>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>,
    ProviderValue<H>,
    ProviderValue<I>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>,
    ProviderValue<H>,
    ProviderValue<I>,
    ProviderValue<J>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>,
    ProviderValue<H>,
    ProviderValue<I>,
    ProviderValue<J>,
    ProviderValue<K>
] | [
    ProviderValue<A>,
    ProviderValue<B>,
    ProviderValue<C>,
    ProviderValue<D>,
    ProviderValue<E>,
    ProviderValue<F>,
    ProviderValue<G>,
    ProviderValue<H>,
    ProviderValue<I>,
    ProviderValue<J>,
    ProviderValue<K>,
    ProviderValue<L>
];
interface ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L> {
    values: ProviderValues<A, B, C, D, E, F, G, H, I, J, K, L>;
    children: ReactNode;
}
export declare function Provider<A, B, C, D, E, F, G, H, I, J, K, L>({ values, children }: ProviderProps<A, B, C, D, E, F, G, H, I, J, K, L>): JSX.Element;
export interface StyleProps {
    /**
     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
     * element.
     */
    className?: string;
    /**
     * The inline [style](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style) for the
     * element.
     */
    style?: CSSProperties;
}
export interface DOMProps extends StyleProps, SharedDOMProps {
    /** The children of the component. */
    children?: ReactNode;
}
export type ClassNameOrFunction<T> = string | ((values: T & {
    defaultClassName: string | undefined;
}) => string);
type StyleOrFunction<T> = CSSProperties | ((values: T & {
    defaultStyle: CSSProperties;
}) => CSSProperties | undefined);
export interface StyleRenderProps<T, E extends keyof React.JSX.IntrinsicElements = 'div'> extends DOMRenderProps<E, T> {
    /**
     * The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the
     * element. A function may be provided to compute the class based on component state.
     */
    className?: ClassNameOrFunction<T>;
    /**
     * The inline [style](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style) for the
     * element. A function may be provided to compute the style based on component state.
     */
    style?: StyleOrFunction<T>;
}
export type ChildrenOrFunction<T> = ReactNode | ((values: T & {
    defaultChildren: ReactNode | undefined;
}) => ReactNode);
export interface RenderProps<T, E extends keyof React.JSX.IntrinsicElements = 'div'> extends StyleRenderProps<T, E> {
    /**
     * The children of the component. A function may be provided to alter the children based on
     * component state.
     */
    children?: ChildrenOrFunction<T>;
}
interface RenderPropsHookOptions<T, E extends keyof React.JSX.IntrinsicElements> extends RenderProps<T, E>, SharedDOMProps, AriaLabelingProps {
    values: T;
    defaultChildren?: ReactNode;
    defaultClassName?: string;
    defaultStyle?: CSSProperties;
}
interface RenderPropsHookRetVal<T, E extends keyof React.JSX.IntrinsicElements> {
    className?: string;
    style?: CSSProperties;
    children?: ReactNode;
    'data-rac': string;
    render?: DOMRenderFunction<E, T>;
}
export declare function useRenderProps<T, E extends keyof React.JSX.IntrinsicElements>(props: RenderPropsHookOptions<T, E>): RenderPropsHookRetVal<T, E>;
/**
 * A helper function that accepts a user-provided render prop value (either a static value or a
 * function), and combines it with another value to create a final result.
 */
export declare function composeRenderProps<T, U, V extends T>(value: T extends any ? T | ((renderProps: U) => V) : never, wrap: (prevValue: T, renderProps: U) => V): (renderProps: U) => V;
export type WithRef<T, E> = T & {
    ref?: ForwardedRef<E>;
};
export interface SlotProps {
    /**
     * A slot name for the component. Slots allow the component to receive props from a parent
     * component. An explicit `null` value indicates that the local props completely override all
     * props received from a parent.
     */
    slot?: string | null;
}
export declare function useSlottedContext<T>(context: Context<SlottedContextValue<T>>, slot?: string | null): T | null | undefined;
export declare function useContextProps<T, U extends SlotProps, E extends Element>(props: T & SlotProps, ref: ForwardedRef<E> | undefined, context: Context<ContextValue<U, E>>): [T, RefObject<E | null>];
export declare function useSlot(initialState?: boolean | (() => boolean)): [RefCallback<Element>, boolean];
/**
 * Filters out `data-*` attributes to keep them from being passed down and duplicated.
 *
 * @param props
 */
export declare function removeDataAttributes<T>(props: T): T;
export interface RACValidation {
    /**
     * Whether to use native HTML form validation to prevent form submission
     * when the value is missing or invalid, or mark the field as required
     * or invalid via ARIA.
     *
     * @default 'native'
     */
    validationBehavior?: 'native' | 'aria';
}
export type DOMRenderFunction<E extends keyof React.JSX.IntrinsicElements, T> = (props: React.JSX.IntrinsicElements[E], renderProps: T) => ReactElement;
export interface DOMRenderProps<E extends keyof React.JSX.IntrinsicElements, T> {
    /**
     * Overrides the default DOM element with a custom render function.
     * This allows rendering existing components with built-in styles and behaviors
     * such as router links, animation libraries, and pre-styled components.
     *
     * Requirements:
     *
     * - You must render the expected element type (e.g. if `<button>` is expected, you cannot render an
     *   `<a>`).
     * - Only a single root DOM element can be rendered (no fragments).
     * - You must pass through props and ref to the underlying DOM element, merging with your own prop
     *   as appropriate.
     */
    render?: DOMRenderFunction<E, T>;
}
type LinkWithRequiredHref = Required<Pick<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>> & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>;
export interface PossibleLinkDOMRenderProps<Fallback extends keyof React.JSX.IntrinsicElements, T> {
    /**
     * Overrides the default DOM element with a custom render function.
     * This allows rendering existing components with built-in styles and behaviors
     * such as router links, animation libraries, and pre-styled components.
     *
     * Note: You can check if `'href' in props` in order to tell whether to render an `<a>` element.
     *
     * Requirements:
     *
     * - You must render the expected element type (e.g. if `<a>` is expected, you cannot render a
     *   `<button>`).
     * - Only a single root DOM element can be rendered (no fragments).
     * - You must pass through props and ref to the underlying DOM element, merging with your own prop
     *   as appropriate.
     */
    render?: (props: DetailedHTMLProps<LinkWithRequiredHref, HTMLAnchorElement> | React.JSX.IntrinsicElements[Fallback], renderProps: T) => ReactElement;
}
type DOMComponents = {
    [E in keyof React.JSX.IntrinsicElements]: (props: DOMRenderProps<E, any> & React.JSX.IntrinsicElements[E]) => ReactElement;
};
export declare const dom: DOMComponents;
export {};