export type TriggerChildren<State> = React.ReactNode | ((state: State) => React.ReactNode);
/**
 * Props for a Base UI trigger part whose children are the trigger. Pair with
 * `resolveTrigger`, which turns those children into the part's `render`.
 */
export type WithTriggerChildren<Props, State> = Omit<Props, "children"> & {
    /**
     * An element is used as the trigger itself. A string, or a function of the
     * trigger's state, is content: it renders inside a focusable
     * `role="button"` span, and a function re-renders as the state changes.
     * With your own `render`, children are its content, as in Base UI, so
     * pass a node rather than a function.
     */
    children?: TriggerChildren<State>;
};
/**
 * Whether these children, or a caller's own `render`, amount to a trigger.
 * A composed component skips its Trigger part when this is false, so nothing
 * stands in for a trigger nobody passed: a controlled dialog opened from
 * elsewhere would otherwise get an empty focusable span as a tab stop.
 *
 * What React renders as nothing is no trigger either — see `isRenderable`.
 * `trigger={cond && <Button />}` is the common way one goes missing, and it
 * arrives as `false`.
 */
export declare const hasTrigger: <State>(children: TriggerChildren<State>, render?: unknown) => boolean;
type ResolvedTrigger<State> = {
    nativeButton?: boolean;
    render?: React.ReactElement | ((props: React.ComponentPropsWithRef<"span">, state: State) => React.ReactElement);
    children?: React.ReactNode;
};
/**
 * The `nativeButton` and `render` a Base UI trigger part needs for the given
 * children. Let the caller's own values win with `??` rather than by
 * spreading their props after it: a spread `render: undefined` or
 * `nativeButton: undefined` would clear the resolved value.
 *
 * The trigger travels only through `render`, never as the part's children:
 * Base UI falls back to the part's children when the render element has none,
 * so a childless element trigger would otherwise render inside itself.
 *
 * Pass the caller's own `render`, if any, and this steps aside: the children
 * go to the part as content for that element, and `nativeButton` is left to
 * the caller, exactly as Base UI takes them.
 */
export declare const resolveTrigger: <State>(children: TriggerChildren<State>, render?: unknown) => ResolvedTrigger<State>;
export {};
//# sourceMappingURL=trigger.d.ts.map