import "./select.css";
import type * as React from "react";
import { type ReactNode } from "react";
import { Combobox } from "@base-ui/react/combobox";
import { useRender } from "@base-ui/react/use-render";
import type { Controlled, SelfCommitting } from "./commit_mode";
import { type FieldOptionsSource } from "./option_picker";
import { type StyleProps } from "./style_props";
export interface SelectOption<T extends string = string, D = unknown> {
    label?: string;
    value: T;
    disabled?: boolean;
    testID?: string;
    /** Arbitrary payload, so a rich `renderOptionContent` renders from the source
     *  row without a side lookup. */
    data?: D;
}
export type SelectValue<T extends string, MULTI extends boolean> = MULTI extends true ? T[] : T;
/** What a picker ANSWERS with — the single arm answers `null` for nothing
 *  chosen, never the empty string, a value a field could legitimately hold. */
export type SelectAnswer<T extends string, MULTI extends boolean> = MULTI extends true ? T[] : T | null;
export type SelectOnValueChange<T extends string, MULTI extends boolean> = (value: SelectAnswer<T, MULTI>) => void;
interface SelectBase<T extends string, D> extends StyleProps {
    /** {@link SelectNativeProps} is the other dropdown; this arm is the kit's own. */
    native?: never;
    options?: (SelectOption<T, D> | undefined | false)[];
    /** A SELECT FIELD, straight from the SDK (`useFieldOptions().fields.<column>`) —
     *  its whole option set becomes this picker's options, keys and colours intact.
     *  `options` wins where a caller states both. */
    fieldOptions?: FieldOptionsSource<T>;
    /** DRAW EACH OF THE FIELD'S OPTIONS AS ITS OWN MARK — `dot` in a list of
     *  choices, `tonal` where the value is the surface's one prominent status. */
    badge?: "tonal" | "dot";
    /** How each OPTION renders in the menu, and the trigger's selection display
     *  where `renderSelected` is omitted. */
    renderOptionContent?: (option: SelectOption<T, D>) => ReactNode;
    /** A single-line subtitle under each option's label in the menu. */
    getOptionDescription?: (option: SelectOption<T, D>) => string | undefined;
    /** A NODE renders as-is; a string is drawn as muted placeholder text. */
    placeholder?: string | ReactNode;
    /** What the LIST says when it has nothing to offer. Default: "No results". */
    emptyText?: string;
    /** THE READER MAY EMPTY THIS FIELD — single-select only, as a named row
     *  (`emptyLabel`) at the head of the list. */
    clearable?: boolean;
    /** The name of that empty row (locale default: "None"), as distinct from
     *  `placeholder`. */
    emptyLabel?: string;
    searchable?: boolean;
    /** Worth setting under `allowCustom`: the only always-visible place that can
     *  say a new value is allowed. */
    searchPlaceholder?: string;
    /** THE CALLER NARROWS THE SET: the query arrives debounced and `options` is the
     *  answer to it. Implies `searchable`. */
    onSearchChange?: (query: string) => void;
    /** Offer a "create" row when the query matches no option. Implies `searchable`:
     *  there has to be a query to create from. */
    allowCustom?: boolean;
    /** Label for the create row (default: `Add "<query>"`). */
    customOptionLabel?: (query: string) => string | null;
    /** Where the create row sits — default "bottom". Pass "top" for a find-or-create
     *  REFERENCE picker over a long registry: the keyboard highlight stays on the
     *  first MATCH, so Enter on a partial query attaches rather than duplicating. */
    customOptionPlacement?: "top" | "bottom";
    /** WHICH BAND this select sits in: `lg` (default) is the 40px control height,
     *  `md` the DENSE strip of a document toolbar. */
    size?: "md" | "lg";
    disabled?: boolean;
    /** Focus the field on mount; to open the LIST on mount pass `defaultOpen`. */
    autoFocus?: boolean;
    defaultOpen?: boolean;
    /** Required in spirit with no visible label beside the field: the selected text
     *  describes the value, not the control. */
    accessibilityLabel?: string;
    /** On the TRIGGER — the element a test presses to open the list. */
    testID?: string;
    /** Base UI's own trigger ref. A `<div>`, not a `<button>`: see the trigger below. */
    ref?: React.Ref<HTMLDivElement>;
    render?: Combobox.Trigger.Props["render"];
}
interface SelectArity<T extends string, MULTI extends boolean, D> {
    /** Pick SEVERAL: the value becomes a set, the rows carry checkboxes and the
     *  list stays open between ticks. */
    multi?: MULTI;
    /** How each chosen option renders in the field; `controls.remove` detaches THAT
     *  one. Omitted, the option's own content, then a comma summary of the labels. */
    renderSelected?: (item: SelectOption<T, D>, controls: {
        remove: () => void;
    }) => ReactNode;
    /** Multi only: a footer link that ticks every enabled row. */
    enableSelectAll?: boolean;
    selectAllLabel?: string;
    deselectAllLabel?: string;
}
/** WHO OWNS THE DRAFT, for a control whose draft is a LIST that is open.
 *  `onClose` is the CONTROLLED commit seam, which `onSave` already is. */
export type SelectCommit<V> = (Controlled<V> & {
    onClose?: (value: V) => void;
}) | (SelfCommitting<V> & {
    onClose?: never;
    controls?: never;
});
/** The PLATFORM's dropdown: the OS's own popup, its typeahead and a phone's
 *  wheel. No multi, no search, no create and no self-committing arm. */
export interface SelectNativeProps<T extends string = string> extends StyleProps {
    native: true;
    options?: (SelectOption<T> | undefined | false)[];
    /** A select FIELD's own options (`useFieldOptions().fields.<column>`). */
    fieldOptions?: FieldOptionsSource<T>;
    value: T | null;
    onValueChange: (value: T | null) => void;
    placeholder?: string;
    clearable?: boolean;
    emptyLabel?: string;
    size?: "md" | "lg";
    disabled?: boolean;
    autoFocus?: boolean;
    accessibilityLabel?: string;
    testID?: string;
    ref?: React.Ref<HTMLElement>;
    render?: useRender.RenderProp;
}
export type SelectProps<T extends string = string, MULTI extends boolean = false, D = unknown> = (SelectBase<T, D> & SelectArity<T, MULTI, D> & SelectCommit<SelectAnswer<T, MULTI>>) | SelectNativeProps<T>;
/**
 * Pick one from a known set — single or `multi`, in a form or writing for itself.
 *
 * The kit's own listbox is the default: a styled Base UI `Combobox` in its
 * input-inside-the-popup form. Under 768px the popup is a modal bottom sheet.
 * `native` is the platform's `<select>` instead — for options that are labels and
 * a control as light as possible (a filter operator, a month inside a calendar).
 *
 * Pass `onValueChange` and a form holds the value; pass `onSave` and the FIELD
 * writes for itself, the list's close being the commit (`commit_mode.ts`).
 *
 * To SEARCH a large/remote set with the input AS the control (type-in-place,
 * free text reflected in the field) use `Combobox`.
 */
export declare function Select<T extends string, MULTI extends boolean = false, D = unknown>(props: SelectProps<T, MULTI, D>): React.JSX.Element;
export {};