/**
 * ModelSelector — Popover + Command combobox for switching models at runtime.
 *
 * Built on the same primitives as `AgentPicker` (Popover → Command), so the
 * dropdown portals via `Floating` (never clips in the composer/iframe) and gets
 * keyboard nav + search for free. Rows show the real provider logo from
 * models.dev. Two trigger styles via `variant`: `pill` (logo + label + chevron)
 * or `icon` (logo only, like Studio's desktop picker).
 *
 * @module react/components/chat/model-selector
 */
import * as React from "react";
/** A "provider/model" value and its display label. */
export interface ModelOption {
    /** "provider/model" string (e.g. "openai/gpt-4o") */
    value: string;
    /** Display label (e.g. "GPT-4o") */
    label: string;
    /** Provider name for grouping + logo (e.g. "openai") */
    provider?: string;
    /** Short description shown beneath the label */
    description?: string;
    /** Badge text (e.g. "Local", "New") */
    badge?: string;
}
/** Props accepted by `<ModelSelector>`. */
export interface ModelSelectorProps {
    /** Available models */
    models: ModelOption[];
    /** Currently selected model (undefined = agent default) */
    value?: string;
    /** Called when user selects a model */
    onChange: (model: string) => void;
    /** Additional class names for the trigger */
    className?: string;
    /** Disabled state */
    disabled?: boolean;
    /**
     * Trigger style: `pill` (logo + label + chevron) or `icon` (provider logo
     * only, like Studio's desktop picker). @default "pill"
     */
    variant?: "pill" | "icon";
    /**
     * Render each model yourself instead of using `ModelSelector.Item`.
     */
    renderItem?: (options: {
        item: ModelOption;
        index: number;
    }) => React.ReactNode;
    /**
     * Compose your own menu from `ModelSelector.Trigger` / `Content` / `List` /
     * `Item`. When omitted, the default data-driven preset is rendered.
     */
    children?: React.ReactNode;
}
/** Shared selection + open state exposed to `ModelSelector.*` sub-parts. */
export interface ModelSelectorContextValue {
    /** Selected model value ("provider/model"). */
    value?: string;
    /** The resolved selected option (from `value`, else the first model). */
    selectedModel?: ModelOption;
    /** Select a model by value (also closes the menu). */
    onSelect: (value: string) => void;
    /** Popover open state. */
    open: boolean;
    /** Set the popover open state. */
    setOpen: (open: boolean) => void;
    /** Whether the selector is disabled. */
    disabled?: boolean;
}
/**
 * Read the current `ModelSelector`'s selection + open state from a
 * `ModelSelector.*` sub-part. Throws when called outside a `ModelSelector` /
 * `ModelSelector.Root`.
 *
 * @example
 * ```tsx
 * function CurrentModel() {
 *   const { selectedModel, onSelect } = useModelSelector();
 *   return <button onClick={() => onSelect("openai/gpt-4o")}>{selectedModel?.label}</button>;
 * }
 * // <ModelSelector.Root models={models} onChange={setModel}><CurrentModel /></ModelSelector.Root>
 * ```
 */
export declare const useModelSelector: () => ModelSelectorContextValue;
/** Props for `ModelSelector.Trigger` — the pill/icon combobox button. */
export interface ModelSelectorTriggerProps {
    /** Trigger style. @default "pill" */
    variant?: "pill" | "icon";
    /** Override the trigger contents; defaults to the selected model. */
    children?: React.ReactNode;
    className?: string;
    ref?: React.Ref<HTMLButtonElement>;
}
/** The pill (or icon) combobox trigger. Toggles the popover. */
declare function ModelSelectorTrigger({ variant, children, className, ref }: ModelSelectorTriggerProps): React.ReactElement;
declare namespace ModelSelectorTrigger {
    var displayName: string;
}
/** Props for `ModelSelector.Search`, the addressable search input leaf. */
export interface ModelSelectorSearchProps {
    /** Search input placeholder. */
    placeholder?: string;
    className?: string;
    ref?: React.Ref<HTMLInputElement>;
}
/** Search input for a composed model menu. */
declare function ModelSelectorSearch({ placeholder, className, ref }: ModelSelectorSearchProps): React.ReactElement;
declare namespace ModelSelectorSearch {
    var displayName: string;
}
/** Props for `ModelSelector.Content` — the popover surface + `Command` shell. */
export interface ModelSelectorContentProps extends React.HTMLAttributes<HTMLDivElement> {
    ref?: React.Ref<HTMLDivElement>;
}
/** The popover surface wrapping a `Command` (search + list region). */
declare function ModelSelectorContent({ children, className, ref, ...props }: ModelSelectorContentProps): React.ReactElement;
declare namespace ModelSelectorContent {
    var displayName: string;
}
/** The scrollable `Command` list region. */
declare function ModelSelectorList({ children, className, ref, ...props }: React.HTMLAttributes<HTMLDivElement> & {
    ref?: React.Ref<HTMLDivElement>;
}): React.ReactElement;
declare namespace ModelSelectorList {
    var displayName: string;
}
/** Props for `ModelSelector.Item` — a single selectable model row. */
export interface ModelSelectorItemProps {
    /** The model this row represents. Its `value` is the selection value. */
    model: ModelOption;
    /** Force selected styling; defaults to matching the context `value`. */
    selected?: boolean;
    className?: string;
    ref?: React.Ref<HTMLDivElement>;
}
/** A single model row (provider logo + label + optional badge + check). */
declare function ModelSelectorItem({ model, selected, className, ref }: ModelSelectorItemProps): React.ReactElement;
declare namespace ModelSelectorItem {
    var displayName: string;
}
/**
 * `ModelSelector.Root` — context provider + the popover shell. No children
 * renders the default data-driven preset; pass children to recompose from
 * `ModelSelector.Trigger` / `Content` / `List` / `Item`.
 */
declare function ModelSelectorRoot({ models, value, onChange, className, disabled, variant, renderItem, children, }: ModelSelectorProps): React.ReactElement;
declare namespace ModelSelectorRoot {
    var displayName: string;
}
/**
 * ModelSelector — render `<ModelSelector models={...} .../>` for the default
 * data-driven combobox, or compose `ModelSelector.Trigger`, `Content`, `Search`,
 * `List`, and `Item` for a custom menu.
 */
export declare const ModelSelector: typeof ModelSelectorRoot & {
    Root: typeof ModelSelectorRoot;
    Trigger: typeof ModelSelectorTrigger;
    Content: typeof ModelSelectorContent;
    Search: typeof ModelSelectorSearch;
    List: typeof ModelSelectorList;
    Item: typeof ModelSelectorItem;
};
export {};
//# sourceMappingURL=model-selector.d.ts.map