import "./filter_band.css";
import { type ReactNode } from "react";
import type * as React from "react";
import { useRender } from "@base-ui/react/use-render";
import { type StyleProps } from "./style_props";
/** Whether the band's line asks the status to stand as its one chip; never outside a band. */
export declare function useFilterBandFoldsStatus(): boolean;
/**
 * Where a band draws what it holds: on its `line`; in a phone's `sheet`, each its whole control under its
 * name; or as the words of the `summary` that says, under a phone's line, what narrows the rows.
 */
export type FilterBandPlace = "line" | "sheet" | "summary";
export interface FilterBandPlacement {
    place: FilterBandPlace;
    /** In the summary: what narrows reports it, under a key of its own, so the band's press counts it. */
    narrows?: (key: string, on: boolean) => void;
}
/** Where the band draws the control reading it — `line` outside any band. */
export declare function useFilterBandPlace(): FilterBandPlacement;
/** One filter of the band, in the order its author listed it. */
export interface FilterBandFilter {
    /** Unique among the band's filters. */
    key: string;
    /** Its `FilterChip`. */
    chip: ReactNode;
}
export interface FilterBandLabels {
    /** The phone's one press holding every filter, and its sheet's title. */
    filters: string;
    /** The sheet's close once its filters are set. */
    apply: string;
}
export interface FilterBandProps extends StyleProps {
    /** Stays at every width: the filter people reach for without thinking. */
    search?: ReactNode;
    /** Stays at every width: a screen whose only verb hides in a sheet reads as read-only. */
    action?: ReactNode;
    /** The `StatusChips`: after the search, as its one chip wherever the line cannot hold them side by side. */
    status?: ReactNode;
    /** The few a register is narrowed by daily, in that order — every one on a desk's line, none behind a press. */
    filters?: readonly FilterBandFilter[];
    /** The reader's arrangement of the rows (`GroupByMenu`): one chip closing the filters. */
    group?: ReactNode;
    /** The rows' order (`SortMenu`) wherever no header offers every order: rows with no header row (`headers:
     *  false` — cards, a calendar) at every width, and every register's on a phone. */
    sort?: {
        menu: ReactNode;
        headers: boolean;
    };
    /** What closes a desk's line — a register's charts toggle where its band states no figure — measured into
     *  the fit. Not drawn on a phone, where the caller keeps it on a line of its own. */
    trailing?: ReactNode;
    labels?: Partial<FilterBandLabels>;
    testID?: string;
    ref?: React.Ref<HTMLElement>;
    render?: useRender.RenderProp;
}
/**
 * Search, the status, the filters, the grouping and the primary action, on ONE line at a desk — every one
 * drawn, none waiting behind a press: the status folds into its one chip where its chips side by side would
 * not leave the line room, and only where even that cannot seat them do the chips take lines of their own
 * under the search, each chip whole on the line that seats it — measured, so the first line never wraps. On a
 * phone the line is the search, one "Filters" press counting what narrows the rows, and the action; under it
 * the words of what narrows them, and the press opens the sheet holding every filter, the grouping and the
 * order, each its whole control, the rows following each change and "Apply" closing it.
 * Not a Base UI `Toolbar`, which selects an input's whole value on focus and claims its arrow keys;
 * `SelectionBar` is one because it holds no text field.
 */
export declare function FilterBand(props: FilterBandProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;