import type { PropsLike } from "./merge-props-n.js";
type MaybeAccessor<T> = T | (() => T);
export interface UseFocusableWhenDisabledOptions {
    /**
     * Whether the component should remain focusable while disabled.
     * - `true` on a native button emits `aria-disabled` and clears the native
     *   `disabled` attr so the browser doesn't skip it in the tab order.
     * - `false` on a composite item skips `aria-disabled` entirely (and keeps
     *   native `disabled` on native buttons).
     *
     * Left unset, composite items are focusable by default (React parity).
     */
    focusableWhenDisabled?: MaybeAccessor<boolean | undefined> | undefined;
    /**
     * The disabled state of the component. Coerced through `read()` so either
     * a plain `boolean` or a `() => boolean` accessor is fine.
     */
    disabled: MaybeAccessor<boolean | undefined>;
    /**
     * `true` when the component is an item in a composite widget. In that
     * case `tabIndex` is managed externally and we skip it in the returned
     * props bag.
     * @default false
     */
    composite?: MaybeAccessor<boolean | undefined> | undefined;
    /**
     * Explicit `tabIndex` override. Only consulted when `composite` is false.
     * @default 0
     */
    tabIndex?: MaybeAccessor<number | undefined> | undefined;
    /**
     * `true` when the rendered element is a real `<button>`. On native
     * buttons we mirror the React version: swallow the native `disabled`
     * attr when `focusableWhenDisabled` wins, and emit `aria-disabled` so
     * AT still announces the state.
     * @default true
     */
    isNativeButton?: MaybeAccessor<boolean | undefined> | undefined;
}
export interface UseFocusableWhenDisabledReturn {
    /**
     * A reactive props source to pass into a `mergePropsN` / `renderElement`
     * chain. Backed by getters so accessor-based inputs stay live.
     */
    props: PropsLike;
}
/**
 * Port of Base UI React's `useFocusableWhenDisabled`
 * (`packages/react/src/utils/useFocusableWhenDisabled.ts`). Produces the
 * narrow set of overrides that let a disabled button-like element remain
 * focusable when the consumer opts in.
 *
 * Solid 2 notes:
 *
 * - Every input may be an accessor. Reads happen inside getters / handlers,
 *   so there is no top-level reactive read in the primitive's body.
 * - ARIA boolean attributes surface as the literal `"true"` / `"false"`
 *   strings (RFC 07) rather than native booleans, matching how `useButton`
 *   already serializes them.
 * - The returned props are a plain proxy-shaped object — splice it into a
 *   `params.props` array and `mergePropsN` handles the rest. Handlers
 *   compose right-to-left with any consumer keybindings.
 */
export declare function useFocusableWhenDisabled(options: UseFocusableWhenDisabledOptions): UseFocusableWhenDisabledReturn;
export {};
//# sourceMappingURL=use-focusable-when-disabled.d.ts.map