/** spec §16 — ONE card shell, three laws.
 *
 *  Every consent/status card in the product is this shell with different
 *  CONTENTS: eyebrow · one-size icon well · title · the mandatory plain-words
 *  line · field rows or a list · actions · byline. Standing-access and the
 *  resolved record are contents only, and every surface that shows one (thread,
 *  waiting strip, activities, mobile sheet, voice, embeds) renders the SAME
 *  shell.
 *
 *  The SENTENCE family — the approval ask (M1), the connect row (C2) and the
 *  automation rule (A1) — is headless: its first line IS the card (a question,
 *  a toolkit name, a rule), with one quiet line under it carrying the rest.
 *  Those three wear no eyebrow and no icon well (connect shows the toolkit's
 *  raw mark, deliberately not a well: the well cropped the Gmail M). They are
 *  still this shell, and law 3 lives across each pair of lines.
 *
 *  1. Ancestors may set width/max-width on `.fl-cardshell` — never undress it.
 *  2. ONE icon well (28px), ONE primary button (`.fl-btn-primary`), ONE
 *     ceremony button (`.fl-btn-ceremony`). No card wears the ceremony register
 *     today: the approval ask carries irreversibility in plain words instead.
 *  3. The plain-words line is mandatory: a card always says what it DOES.
 *
 *  Geometry lives in the `.fl-card-*` CSS. Some elements also
 *  carry their legacy `.fl-approval*` / `.fl-grant` class: three suites, the
 *  corpus harness and the thread's morph start-rect lookup select on those
 *  names. They are markers only — the `.fl-card-*` rules are declared later in
 *  the one stylesheet, so the shell's geometry always wins.
 *
 *  Deliberately NOT re-exported from `chrome/index.ts`: the shell is internal
 *  vocabulary (the export-surface test pins the public list), so surfaces
 *  import this module directly.
 */
import { type HTMLAttributes, type ReactNode } from "react";
import type { CardFieldRow } from "./field-rows.js";
/** The eyebrow strings, once (six were hardcoded across the card files). Each
    card that joined the sentence family took its entry with it: the approval
    ask, the connect row and the automation rule are their own first line, so
    only the kinds that still wear a head are left here. */
export declare const CARD_EYEBROWS: {
    readonly standingAccess: "Standing access";
    readonly resolved: "Approval";
    readonly waiting: "Waiting on you";
};
/** What separates the facts on the sentence family's one quiet line
    (`ul.fl-approval-sub` — the ask, the press modal, the connect row). It leads
    every item but the first, as REAL text inside the `<li>`, where a CSS
    `content` rule used to draw it between them.
    Generated content is not invisible to a screen reader — Chromium puts it in
    the accessibility tree, and the item reads "· Permanent: Yes" either way. It
    is invisible to the CLIPBOARD: copying the line gave back "This makes a
    change you can’t undo, as you.asked in an app", every fact run into the
    next. Inside the item is the only place that fixes the copy and keeps the
    list a list — a separator BETWEEN the items is a text node whose parent is
    the `<ul>`, which axe fails as WCAG 1.3.1 ("<ul> and <ol> must only directly
    contain <li>"). */
export declare const NOTE_SEPARATOR = " \u00B7 ";
/** A tool with no brand of its own. */
export declare const TOOL_GLYPH: ReactNode;
export declare const LINK_GLYPH: ReactNode;
export declare const CLOCK_GLYPH: ReactNode;
/** The settled mark (was inlined five times). */
export declare const TICK_GLYPH: import("react").JSX.Element;
export interface CardShellProps extends HTMLAttributes<HTMLElement> {
    /** The card's accessible name, e.g. `Approval for Send money`. */
    label: string;
    /** Destructive/irreversible register: the amber edge over the same card. */
    ceremony?: boolean;
    /** The card is a receipt, not an ask. */
    settled?: boolean;
    children: ReactNode;
}
export declare function CardShell({ label, className, ceremony, settled, children, ...rest }: CardShellProps): import("react").JSX.Element;
export declare function CardHead({ icon, eyebrow, title, aside }: {
    /** A `<ToolkitLogo>` or a glyph in the 28px well. */
    icon?: ReactNode;
    eyebrow: string;
    title: ReactNode;
    /** Trailing chip (risk, OAuth) — sits opposite the copy column. */
    aside?: ReactNode;
}): import("react").JSX.Element;
/** The mandatory plain-words line. */
export declare function CardLine({ className, children }: {
    className?: string;
    children: ReactNode;
}): import("react").JSX.Element;
export declare function CardActions({ children }: {
    children: ReactNode;
}): import("react").JSX.Element;
/** Who is asking, or when it settled. Always last, always quiet. */
export declare function CardByline({ children }: {
    children: ReactNode;
}): import("react").JSX.Element;
export declare function CardList({ label, className, children }: {
    label?: string;
    className?: string;
    children: ReactNode;
}): import("react").JSX.Element;
/**
 * The one body: the real inputs, as a person must read them.
 *
 * L37 — the `dd` used to carry `title={row.raw}` whenever display changed the
 * value, "keeping the raw input one hover away". A tooltip is an END-USER
 * surface: on a consent card that put raw JSON, `true`, `4750` and the
 * developer's literals one hover from a bank customer — and the law's sweep
 * could not see any of it, because `readable()` excluded `title` by
 * construction. RULING: the honesty contract is satisfied by the
 * ROWS (every real input is displayed, always); the raw literal is a developer's
 * aid and rides the tooltip in dev mode only. `CardFieldRow.raw` still exists —
 * it is what dev mode shows, and what tests assert on.
 */
export declare function CardFields({ rows, label }: {
    rows: CardFieldRow[];
    label?: string;
}): import("react").JSX.Element | null;
/** A remote toolkit mark that can always fail: Composio's logo CDN was called
    from four places and only ONE carried an `onError`, so a network failure or
    an unknown slug left an empty well. Keyed to `src` so a prop change retries. */
export declare function ToolkitLogo({ src, fallback, className }: {
    src?: string;
    fallback?: ReactNode;
    className?: string;
}): import("react").JSX.Element;