/** A floor under a pressable cell, whose whole box is the target; taller content grows the band. */
export declare const REGISTER_ROW = 40;
/** The row's height, or a header reads as a first row. */
export declare const REGISTER_HEAD = 40;
/** The floor of every row-shaped surface carrying a subject; the row is its content between two insets
 *  above it. `TableRow`'s `minHeight` lowers it for density. */
export declare const ROW_BEAT: number;
/** A row's own air above and below its content. */
export declare const ROW_INSET = 10;
/** Between columns of words: a region rung, so two readings never touch however the slack falls. */
export declare const REGISTER_INSET = 24;
/** Between columns of glyphs, whose cells are one object. */
export declare const REGISTER_CELL_GAP = 2;
/** With no flexible column the widths become floors and share the slack, rather than leaving the container
 *  blank. */
export declare function columnsShareSlack(columns: ReadonlyArray<{
    width?: number;
}>): boolean;
/** The fit layer for `Table`: everything fits, else droppable columns go by `priority`, else every row
 *  stacks — all from the container width. Purity is the chain's: `control_surface` stays importable only
 *  while its React Native import is type-only. */
/** The column fields the fit reads; `TableColumn` extends this. */
export interface TableFitColumn {
    key: string;
    /** The header's words, and the stacked overline; a fit field because a column must fit its own name. */
    label?: string;
    /** Omit for a flexible column. Side by side, the column's width; stacked, this line's value floor. */
    width?: number;
    /** The `width` in a register whose rows are two lines (a column reserves `lines: 2`), where the cell's
     *  secondary reading (an age, a `+N`) takes the second line instead of sitting beside the value. */
    beneath?: number;
    /** Fixed chrome inside a flexible cell plus its gap, added to the read floor so the text keeps
     *  {@link FLEX_READ_WIDTH}. Ignored with `width`. On the name, `Table` holds it to what its rows' pictures
     *  draw (`Row.Lead picture`). */
    lead?: number;
    /** The column naming the row — stated, since the subject is not always first. Never shed; a register
     *  that cannot seat it stacks. */
    subject?: boolean;
    /** The column's claim on space, **`1` = highest** like P1/P2/P3: larger numbers drop sooner, ties
     *  right-to-left, and a dropped column is reseated wherever room returns. The first column never drops.
     *  `"never"` tops the same scale: never shed, the register stacks instead — only for the fact the row is
     *  scanned for. Unannotated defaults to `columns.length + index`, above real ranks, so explicit priority
     *  is strictly safer than none. */
    priority?: number | "never";
    /** What the rows draw, in px, measured by the caller ({@link textWidthSm}); bounds the column at both
     *  ends, since unmeasured a flexible column holds {@link FLEX_READ_WIDTH} and its full `flex` share
     *  whatever it draws. Only for measurable text, not a meter or a caller's node. */
    content?: number;
    /** The widest statement the supporting line must seat whole (`Ship to Harbour Works Ltd`): an uncapped
     *  floor, so a width that cannot seat it sheds or stacks rather than draw `Ship … Crestline`. */
    statement?: number;
    /** The line this column becomes under the subject when shed (`Due date 09/20/2026`, a meter and figure):
     *  a set shedding it seats the subject at least this wide ({@link seated}). */
    folds?: number;
    /** Most rows leave it blank: it holds no column at any width, and reads on the line of each row that has
     *  it — a seat most rows leave empty is width the readings lose. */
    sparse?: boolean;
    /** The subject's name alone in px, apart from the line under it: a phone's name column holds only it, since
     *  the line runs the row's width under the reading beside it. */
    nameInk?: number;
    /** On a phone it reads on the name's line, never in the one seat beside the name, which holds only what
     *  the row is scanned for (its status, else its figure): a stated column cut to four letters says less
     *  than the same reading whole on the line. */
    phoneLine?: true;
    /** Its heading is a `SortHeader`: the words and the arrow beside them are the heading's ink. The `key`
     *  doubles as the `sortKey`. */
    sortable?: boolean;
    /** `right` for a figure, as numbers are set — a fit field because on a phone a figure gives way to the row's
     *  name, never the name to it ({@link phoneNameLeast}). */
    align?: "left" | "right";
    /** A figure's narrowest whole form over the rows, in px, measured by the caller: its digits in fewer
     *  characters, its unit always. Beside a phone's name it is seated only where this stands whole, else it
     *  leads the line — a figure is whole or folded away, never cut inside its digits or its unit. Unstated,
     *  its `content`. */
    least?: number;
}
/** Zero because the washed row bleeds outward (`ROW_WASH_BLEED`); named so band, rows and fit agree. */
export declare const ROW_GUTTER = 0;
/** One control at the content rung, read from `control_surface` so a scale change moves it. */
export declare const ROW_ACTION_GUTTER = 28;
/** A pair, so the rung inside a pair. */
export declare const ROW_VERB_GAP = 4;
/** Below this a flexible column is ellipsis soup; `DataGrid`, which sheds nothing, uses it as a hard
 *  floor, while `Table` asks {@link FLEX_READ_WIDTH}. */
export declare const FLEX_MIN_WIDTH = 120;
/** A sortable heading's arrow (`SortHeader`'s glyph) and the gap before it (`sort_header.css`). */
export declare const SORT_GLYPH = 14;
/** What a fixed column lays out at — declared width, or its heading if wider; read by the fit and the
 *  rendered box alike. */
export declare function fixedColumnWidth(width: number, label: string | undefined, sortable?: boolean): number;
/** Read by the fit and the layout, so a column never lays out below what it was fitted at. `heading: false`
 *  is a phone's column, whose heading ends in an ellipsis rather than hold its one reading's seat open. */
export declare function columnFloor(column: TableFitColumn, heading?: boolean): number;
/** What it draws, else {@link columnFloor}, so ink settles before `flex` ranking; never below the floor. */
export declare function columnBasis(column: TableFitColumn, heading?: boolean): number;
/** The subject's statement raised to the widest line of a column the set sheds
 *  ({@link TableFitColumn.folds}) — read by fit and layout, so a budgeted line is a drawn one. */
export declare function seated<C extends TableFitColumn>(columns: readonly C[], kept: ReadonlySet<string>): C[];
export interface TableFit {
    /** All keys when `stacked`. */
    visibleKeys: ReadonlySet<string>;
    /** The minimum set cannot fit; rows render as label-over-value stacks. */
    stacked: boolean;
    /** Columns this width could not seat, in drop order; empty when all fit or when stacked. The renderer
     *  warns: a `console` here would make the fit untestable. */
    shed: readonly string[];
}
/** The declared rank, else the place-derived one, and `"never"` for column 0, a `"never"` rank and the
 *  `subject` — all carried into the stacked fork. One definition, since a frame ranking columns beneath
 *  these must use the same scale. */
export declare function columnRank(columns: readonly TableFitColumn[], index: number): number | "never";
/** The row name's share cap. The identity is measured off the longest row, so uncapped one long name took
 *  a third of the register while readings sat at their floors. A third, read off rendered registers: below
 *  it a desk's two-line identity clips, above it the readings fall to their floors. A ceiling, never a
 *  width. */
export declare const IDENTITY_SHARE = 0.32;
/** The `subject`, else the first — one definition, or the layout could cap a column the fit may drop. */
export declare function identityKeyOf(columns: readonly TableFitColumn[]): string | undefined;
/** Undefined where the room given up has nowhere to go: with one flexible column the register would end at
 *  a third of its frame. A measured column (`content`) takes no share, so it is no place for that room —
 *  capped beside them, a long name was cut while the slack sat between the readings. */
export declare function cappedIdentity(columns: readonly TableFitColumn[]): string | undefined;
/** Whether a row's verb stands as its button in a line `width` wide — a third of it at most — or waits in its ⋯. */
export declare function rowVerbDraws(verb: string, glyph?: boolean, width?: number): boolean;
/** The ⋯, the one verb at its word's ink, and the pair's gap; zero where no row acts. Budgeted from the
 *  word, since a gutter at the ⋯'s 28px pushes the ⋯ off the register; a verb too long to draw is the ⋯'s. */
export declare function rowGutterWidth(verb: string | undefined, menu: boolean, glyph?: boolean, width?: number): number;
export declare function computeTableFit(columns: TableFitColumn[], leading: number, trailing: number, width: number): TableFit;
/** Under this a register is a phone's column (a 430px phone less its gutters and more): room for a name
 *  and one reading, never a table. A record's main column and a drawer stay registers. */
export declare const PHONE_COLUMN = 480;
/** A phone's name floor, twelve characters or so: the most of its ink a name's column claims, and the least a
 *  reading's words beside it leave it — the name takes all the row they leave. */
export declare const PHONE_NAME = 96;
/** What a phone's name gives way to beside the one reading, read by the fit and the layout alike: beside a
 *  figure or a meter ({@link givesWay}) a stated, flexible `subject` gives none of its name, which is budgeted
 *  first; beside words every name holds its floor ({@link PHONE_NAME}), since words that would cut it lead the
 *  line instead. */
export declare function phoneNameLeast(column: TableFitColumn, beside?: TableFitColumn): number;
/** A phone's fit, and the width the one reading beside the name is drawn at. */
export interface PhoneFit extends TableFit {
    /** `compact`: its chrome (a meter's track) does not fit beside its words there, so it reads as its words. */
    seat?: {
        key: string;
        width: number;
        compact?: true;
    };
    /** The reading the row is scanned for where seating it would cut the name: it leads the line. */
    unseated?: string;
    /** The name's lead where its picture stepped down to a face's to keep the name's room. */
    lead?: number;
}
/**
 * A PHONE-SHAPED REGISTER READS ONE THING BESIDE THE NAME: the column that ranks highest — on each row as wide
 * as its words, the name taking the rest — and every other reading folded onto the name's one line. Row chrome
 * (the ticks' box, the ⋯) is no column, never a seat. A narrower column ranked lower never takes that seat, or a
 * row's status would give way to whichever reading is short. Only columns that never drop, piled past the
 * width, stack the rows. Two or three columns beside a name leave rows three to six lines tall and each
 * folding differently; one keeps every row two lines and alike.
 *
 * THE NAME NEVER LOSES TO THE READING: words — a status, a person — are seated only where their widest stands
 * whole beside the name at its floor ({@link phoneNameLeast}), else they lead the line, mark and words whole; a
 * figure gives way to its words, then to the line — seated only where its narrowest form stands whole, unit and
 * all ({@link TableFitColumn.least}). Every input is a stated or measured width, never where a reading was last
 * drawn, so moving it cannot move the fit.
 *
 * THE PICTURE GIVES WAY BEFORE THE NAME: where the widest name would be cut beside a lead wider than `face` (a
 * face's mark and its gap) and the one reading at its widest, the lead steps down to `face` — every row's, so
 * the titles keep one edge — and the reading keeps the room it was seated in, so the name is cut only once the
 * picture has given it its room.
 */
export declare function oneReadingBeside(columns: readonly TableFitColumn[], leading: number, trailing: number, width: number, face?: number): PhoneFit;