import "./mark_stack.css";
import type * as React from "react";
import { useRender } from "@base-ui/react/use-render";
import { type Picture } from "./avatar";
import { type BrandName } from "./brand_mark";
import { type CalloutTone } from "./callout";
import { type IconName } from "./icon";
import { type MarkSize } from "./mark";
import { type StyleProps } from "./style_props";
/** A person takes the disc, a group the rounded square (`Avatar`'s subject axis), a thing its picture —
 *  never initials; with none, its kind's glyph, else its picture's placeholder. */
export interface StackedMark {
    /** The React key; never the display name, which colleagues share. */
    id: string;
    name: string;
    kind: "person" | "group" | "thing";
    /** A photo, a picture, or the file the subject is; absent falls back to {@link StackedMark.brand}, then
     *  the kind's empty face. A file, not a URL, lets a video show its first frame and a paper its type; a
     *  clip URL renders a torn box that reads as a broken row. */
    image?: Picture | null;
    /** A pictureless thing's glyph — its kind's, where kinds are mixed (an automation, a system); absent, the
     *  thing's picture not held: the dashed tile with the picture's glyph — in a list's lead, only beside a lead
     *  holding a picture or a document. Never on a person or group, whose empty face is initials. */
    icon?: IconName;
    /** The channel drawn where there is no picture, since a page's initials identify nothing; a fallback,
     *  never a second mark. */
    brand?: BrandName;
    /** A corner tone dot per member. A set with states spreads instead of tucking, since the tuck hides that
     *  corner. Pass it on all marks or none. */
    state?: CalloutTone;
    /** The dot's meaning in words; absent, it is decoration and the surface owes the word elsewhere. */
    stateLabel?: string;
}
/**
 * A stack's width in px on a line or in a cell, as it draws: a document's chip, or its tucked marks and then its
 * count (`count`, the words it is drawn in) or its `+N` — for the line or column budgeting it.
 */
export declare function markStackWidth(marks: readonly StackedMark[], size: MarkSize, max?: number, count?: string): number;
export interface MarkStackProps extends StyleProps {
    marks: readonly StackedMark[];
    max?: number;
    /** Silences the marks. Unlike `Avatar`, the default announces each `name`, since a stack often has no
     *  name beside it; pass this where the row already names them. */
    decorative?: boolean;
    /** A rung of the mark scale (`identityRung`); unstated, the row-lead reading (`useLeadRung`), a thing
     *  flooring at `lg`. */
    size?: MarkSize;
    /** How many a set holding a document among several holds, in the reader's words, drawn after its marks
     *  ("3 papers" on a line); absent, the bare number — a column's, whose header names what it counts. */
    count?: string;
    /** A set of files that opens where it stands — the viewer on them, at its first, claiming its press from a row
     *  behind it: the stack is one button. Absent, the stack is inert. */
    onPress?: (id: string) => void;
    /** The button's name, required with `onPress`: what the set is ("Giấy tờ: 3 tệp"). */
    accessibilityLabel?: string;
    testID?: string;
    ref?: React.Ref<HTMLElement>;
    render?: useRender.RenderProp;
}
/** A set as marks in one cell. The overflow counts what actually renders. A group is one mark with its
 *  name, never members' faces it may not be entitled to show. Marks overlap, first on top, the remainder
 *  last; things tuck shallower; marks with states spread so every dot reads. A document alone is its chip; a set
 *  holding one among several is its marks and how many it holds (`count`), so a row keeps one height. Inert — a
 *  pressing row must not hold a second destination (`member_peek.tsx`) — save a set of files, whose `onPress`
 *  opens them where they stand, as a file's thumbnail does. Pure. */
export declare function MarkStack(props: MarkStackProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;