import { type InjectionKey, type PropType, type VNode } from "vue";
/**
 * Shared context contract between {@link SelectableList} and its slotted
 * {@link SelectableRow} children. The list owns selection + the roving tabindex
 * and exposes the getters/callbacks the rows read to derive their own `role` /
 * `tabindex` / `aria-selected`. When a row is used STANDALONE (no provider)
 * `inject` returns undefined and the row falls back to its own state.
 */
export type SelectableListContext = {
    /** Reactive bump incremented on every selection / focus / registry change. */
    version: {
        value: number;
    };
    /** True when the list manages selection/roving for its rows. */
    readonly managed: true;
    /** listbox role for the wrapper → rows are "option". */
    readonly itemRole: "option";
    /** Register a row element; returns an unregister callback. disabled is forwarded so the list can skip it during keyboard navigation. */
    register: (el: HTMLElement, value: string | undefined, disabled?: boolean) => () => void;
    /** Is the row with this element currently selected? */
    isSelected: (el: HTMLElement) => boolean;
    /** Should the row with this element be the roving-tabindex stop (tabindex 0)? */
    isTabStop: (el: HTMLElement) => boolean;
    /** Row was activated (click / Space / Enter). The list toggles selection. */
    activate: (el: HTMLElement) => void;
    /** Row received focus → becomes the roving tab stop. */
    focusRow: (el: HTMLElement) => void;
    /** Arrow / Home / End navigation from a row. */
    navigate: (el: HTMLElement, key: string) => void;
};
export declare const SELECTABLE_LIST_KEY: InjectionKey<SelectableListContext>;
export type SelectableRowProps = {
    /**
     * Selected state. Honoured when the row is used STANDALONE; inside a
     * {@link SelectableList} the list is the source of truth, so this prop is
     * ignored for managed rows.
     */
    selected?: boolean;
    /** Notified on every toggle with the new selected state (standalone rows). */
    onSelect?: (selected: boolean) => void;
    /** Non-interactive when true. */
    disabled?: boolean;
    /** Stable value, surfaced as `data-value` and used by the list for `value`. */
    value?: string;
    /** Native link target. When set on a standalone row, the row renders as an anchor. */
    href?: string;
    /**
     * ARIA role for the standalone row. Defaults to "option" so a lone row still
     * reads as a selectable item. Inside a list the role is forced to "option".
     */
    role?: string;
    /**
     * Opt-in left accent bar on the selected state. Off by default so the
     * selected item is a calm tinted surface + accented text (two signals only).
     */
    accentBar?: boolean;
    class?: string;
};
/**
 * Compact, full-width selectable list/rail row. By DEFAULT the selected state
 * is two calm signals — a tinted surface + accented text — deliberately NOT the
 * off-theme "boudin box" it replaces, and NOT a reflow-causing font-weight
 * bump. The fine left accent bar is OPT-IN via the `accentBar` prop. Focus is an
 * EXTERNAL offset outline. role="option" + aria-selected, keyboard-activatable
 * (Enter / Space), inert when disabled. Inside a {@link SelectableList} the list
 * (via provide/inject) owns selection and the roving tabindex.
 * Slots: default (content), leading (icon / avatar), trailing (meta / icon).
 */
export declare const SelectableRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    selected: {
        type: BooleanConstructor;
        default: boolean;
    };
    onSelect: {
        type: PropType<(selected: boolean) => void>;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: StringConstructor;
        default: undefined;
    };
    href: {
        type: StringConstructor;
        default: undefined;
    };
    role: {
        type: StringConstructor;
        default: string;
    };
    accentBar: {
        type: BooleanConstructor;
        default: boolean;
    };
    class: {
        type: StringConstructor;
        default: undefined;
    };
}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    select: (_selected: boolean) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    selected: {
        type: BooleanConstructor;
        default: boolean;
    };
    onSelect: {
        type: PropType<(selected: boolean) => void>;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    value: {
        type: StringConstructor;
        default: undefined;
    };
    href: {
        type: StringConstructor;
        default: undefined;
    };
    role: {
        type: StringConstructor;
        default: string;
    };
    accentBar: {
        type: BooleanConstructor;
        default: boolean;
    };
    class: {
        type: StringConstructor;
        default: undefined;
    };
}>> & Readonly<{
    onSelect?: ((_selected: boolean) => any) | undefined;
}>, {
    class: string;
    onSelect: (selected: boolean) => void;
    disabled: boolean;
    role: string;
    href: string;
    value: string;
    selected: boolean;
    accentBar: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=SelectableRow.d.ts.map