import { type ButtonProps } from '../button';
import { type BandedGaugeBand } from './banded-gauge';
export type InsertMode = 'text' | 'image' | 'text-image';
export type InsertVariant = 'insert' | 'copy';
/**
 * The handful of lucide glyphs the result-card header can carry. Each maps to a
 * static native-SVG geometry string in {@link ICON_GEOMETRY}, hand-transcribed
 * from lucide-react 1.8.0's `__iconNode` arrays (pinned to that version so the
 * paths match the on-screen React glyphs exactly). We do NOT import the lucide
 * React components into the raster path — they can't be serialised into the
 * `<img>` data-URI — so the geometry is inlined as raw `<path>` elements.
 */
export type IconKey = 'activity' | 'scale' | 'ruler' | 'calendar' | 'calendar-heart' | 'baby' | 'heart' | 'droplets' | 'clock' | 'tag' | 'trending-up' | 'percent';
export interface InsertCardField {
    label: string;
    value: string;
    /**
     * Optional leading glyph for the row, drawn at {@link FIELD_ICON_SLOT} in
     * place of the default bullet dot. One of the known {@link IconKey} names; an
     * unknown / omitted value falls back to the muted bullet (fully
     * back-compatible — a field without an icon renders exactly as before).
     */
    icon?: IconKey;
}
/**
 * Radial gauge — a hand-rolled native-SVG donut (track `<circle>` + value arc
 * via `stroke-dasharray`) drawn in the card's inline-end corner box. Survives
 * the `<img>` → `<canvas>` → `toBlob` raster. No `<foreignObject>`, no charting
 * lib.
 *
 * This is the original gauge shape; `variant` is optional and defaults to
 * `'radial'`, so a gauge object authored before the banded variant existed
 * renders exactly as before.
 */
export interface InsertCardRadialGauge {
    /** Discriminant. Optional — omitted means `'radial'` (back-compat). */
    variant?: 'radial';
    /** Big number rendered in the gauge centre (e.g. `'22.4'`). */
    value: string;
    /**
     * Filled fraction of the ring, `0`–`1`. Takes precedence when supplied;
     * otherwise derived from a `value`/`max` numeric parse (falling back to a
     * full ring when neither is numeric).
     */
    fraction?: number;
    /** Denominator used to derive `fraction` when `fraction` is omitted. */
    max?: number;
    /**
     * Number of evenly-spaced segment gaps to notch into the ring (e.g. `4` for
     * a quartered dial). `0`/omitted draws a continuous arc.
     */
    segments?: number;
    /**
     * DS token NAME for the arc colour — e.g. `'--success'`, `'--warning'`,
     * `'--destructive'`, `'--info'`, or the light-orange overweight override.
     * Resolved to a concrete colour from a probe span at raster time; never a
     * hex literal in source.
     */
    colorToken: string;
    /** Small category label under the value inside the ring. */
    label?: string;
}
/**
 * Banded gauge — a full-width horizontal track split into coloured zones with a
 * marker at the value's position (the WHO BMI dial, drawn via the shared
 * `banded-gauge` module). It spans the card edge-to-edge below the field rows.
 * Same raster-safety guarantees as the radial donut: pure native SVG, no
 * `<foreignObject>`.
 *
 * Every visible string (`valueLabel`, `categoryLabel`, `rangeLabel`,
 * `ariaLabel`) arrives ALREADY TRANSLATED — the calculator supplies `t()`-
 * resolved text. Every band's `colorToken` is registered for probe sampling so
 * the baked raster carries theme-correct fills.
 */
export interface InsertCardBandedGauge {
    /** Discriminant for the banded layout. */
    variant: 'banded';
    /** The true value (printed verbatim even when clamped to a bar end). */
    value: number;
    /** Ascending coloured zones; the last `upTo` should equal `max`. */
    bands: BandedGaugeBand[];
    /** Low end of the drawn scale (maps to the bar's inline start). */
    min: number;
    /** High end of the drawn scale (maps to the bar's inline end). */
    max: number;
    /** Big number rendered above the marker (e.g. `'24.6'`). */
    valueLabel: string;
    /** Band name shown beside the value (e.g. `'normal'`). Pre-translated. */
    categoryLabel?: string;
    /** Range string for the band (e.g. `'18.5–24.9'`). Pre-translated. */
    rangeLabel?: string;
    /** Full accessible name, e.g. `'BMI 24.6 — normal (18.5–24.9)'`. */
    ariaLabel: string;
    /** Threshold tick values drawn under the bar (e.g. `[18.5, 25, 30]`). */
    ticks?: number[];
}
/**
 * Optional in-card gauge. A discriminated union on `variant`:
 *
 *   • `'radial'` (default when `variant` is omitted) — the corner-box donut.
 *   • `'banded'` — a full-width horizontal banded bar below the fields.
 */
export type InsertCardGauge = InsertCardRadialGauge | InsertCardBandedGauge;
export interface InsertCardData {
    /** Card heading. */
    title: string;
    /** Key/value rows. */
    fields: InsertCardField[];
    /**
     * Optional header glyph drawn inline-end of the title, tinted with the card's
     * category colour ({@link InsertCardData.highlightToken}). One of the known
     * {@link IconKey} names; an unknown / omitted value simply skips the glyph
     * (fully back-compatible — a card without an icon renders as before).
     */
    icon?: IconKey;
    /** Optional highlighted line, rendered as a category chip (pill). */
    highlight?: string;
    /**
     * DS token NAME for the highlight chip fill. Defaults to the accent token
     * (`--primary`). The chip text uses the matching `<token>-foreground` when it
     * resolves, else falls back to the card background for contrast.
     */
    highlightToken?: string;
    /** Optional radial gauge drawn natively in the card. */
    gauge?: InsertCardGauge;
    /**
     * Optional brand wordmark line printed at the foot of the card.
     *
     * - omitted / `false` → no brand line and no footer at all; the card ends
     *   after the fields/gauge.
     * - a string → that wordmark, rendered as a single quiet line (no hairline
     *   rule above it).
     *
     * A `brand` passed to {@link SvgCardToPngOptions} overrides this per-render.
     */
    brand?: string | false;
}
export interface InsertPayload {
    /** Which button the user chose. */
    mode: InsertMode;
    /** Plain-text summary. Always present. */
    text: string;
    /** Rich HTML summary (heading + list). Always present. */
    html: string;
    /**
     * Branded SVG result-card markup. Empty for mode `'text'`.
     *
     * Kept for back-compat and for callers that need the live, copy-pasteable
     * vector. NOTE: SVG can carry `<script>` and is routinely stripped by
     * rich-text sanitisers, so it is NOT the format to insert into an editor —
     * use {@link InsertPayload.pngDataUri} for that.
     */
    svg: string;
    /**
     * SVG as an `image/svg+xml` data URI for `<img src>`. Empty for `'text'`.
     *
     * Same caveat as {@link InsertPayload.svg}: fine for a preview `<img>`, but a
     * sanitiser-stripped vector once it reaches an editor. Prefer
     * {@link InsertPayload.pngDataUri}.
     */
    imageDataUri: string;
    /**
     * Async thunk that resolves the result-card raster — the format intended for
     * editor insertion. PNG is a flat raster: it carries no script and survives
     * the rich-text sanitiser that strips SVG.
     *
     * Resolves to `{ dataUri, width, height }` where `width`/`height` are the
     * **logical (un-scaled) CSS pixel** dimensions: set them on the inserted
     * `<img width height>` and the supersampled (`>= 2×`) PNG renders crisp with
     * no consumer-side shim. For mode `'text'` resolves to an empty
     * `{ dataUri: '', width: 0, height: 0 }`. Rendered lazily so the synchronous
     * payload stays cheap; `await payload.pngDataUri()` only when you need it.
     *
     * @since 0.43.0 — this return shape changed from a bare `Promise<string>` to
     * `Promise<{ dataUri; width; height }>` (see CHANGELOG).
     */
    pngDataUri: () => Promise<InsertPngResult>;
}
/** Resolved PNG raster plus its logical (un-scaled) `<img>` dimensions. */
export interface InsertPngResult {
    /** `image/png` data URI, or `''` for the text-only mode. */
    dataUri: string;
    /** Logical (CSS px) width to set on the inserted `<img>`. `0` when empty. */
    width: number;
    /** Logical (CSS px) height to set on the inserted `<img>`. `0` when empty. */
    height: number;
}
export interface InsertButtonProps {
    /** Structured result used to build every payload representation. */
    card: InsertCardData;
    /**
     * Verb the buttons perform. Defaults to `'insert'`.
     *
     * - `'insert'` — fires `onInsert(payload)` (editor-extension context).
     * - `'copy'` — writes the chosen representation(s) to the clipboard as a
     *   multi-format `ClipboardItem` (app-shell context).
     */
    variant?: InsertVariant;
    /**
     * Receives the built payload when a button is pressed.
     *
     * Required for the `insert` variant; optional (and ignored) for `copy`.
     */
    onInsert?: (payload: InsertPayload) => void;
    /** `copy` variant only — fired after a successful clipboard write. */
    onCopy?: (mode: InsertMode) => void;
    /** `copy` variant only — fired if the clipboard write can't proceed. */
    onError?: (error: unknown) => void;
    /** Trigger size. Defaults to `'sm'`. */
    size?: 'sm' | 'md' | 'lg';
    /**
     * Visual intent of the three trigger buttons (text / image / text+image).
     * Mirrors the `Button` `intent` prop and applies to every trigger uniformly
     * so the three stay visually consistent. Defaults to `'primary'`.
     */
    intent?: ButtonProps['intent'];
}
interface ThemeColours {
    fg: string;
    muted: string;
    accent: string;
    border: string;
    bg: string;
    font: string;
    /**
     * Concrete colours resolved from arbitrary DS token names, keyed by the token
     * name the caller passed (e.g. `'--success'`). Populated for the gauge arc
     * and the highlight chip; consulted by {@link buildResultCardSvg} via
     * {@link resolveToken}.
     */
    tokens?: Record<string, string>;
}
/**
 * Internal resolved-colour shape, re-exported for tests that construct a card
 * raster without a live DOM probe. Not part of the public component API.
 */
export type ThemeColoursForTest = ThemeColours;
export declare function buildResultText(card: InsertCardData): string;
export declare function buildResultHtml(card: InsertCardData): string;
export declare function buildResultCardSvg(card: InsertCardData, c: ThemeColours, brand?: string | false): string;
/** Options for {@link svgCardToPngDataUri}. */
export interface SvgCardToPngOptions {
    /**
     * Resolved theme colours to paint into the card. When omitted, the card
     * renders with `currentColor` / transparent fallbacks (see
     * {@link buildResultCardSvg}) — pass sampled colours for a branded raster.
     */
    colours?: ThemeColours;
    /**
     * Device-pixel scale factor for the raster. `2` yields a retina-sharp PNG.
     * Defaults to `Math.max(2, devicePixelRatio)` so the inserted image is crisp
     * without a consumer-side supersampling shim.
     */
    scale?: number;
    /**
     * Brand wordmark for the footer. Omitted → the card's own `brand` (then the
     * default `'AlfaDocs'`); a string overrides it; `false` removes it.
     */
    brand?: string | false;
}
/**
 * Render an {@link InsertCardData} result card to an `image/png` data URI.
 *
 * This is the format intended for editor insertion: a flat raster carries no
 * `<script>` and survives the rich-text sanitiser that strips inline SVG. The
 * card is built as SVG, loaded into an `<img>`, painted onto a canvas at the
 * card's intrinsic size (optionally scaled), and read back as `image/png`.
 *
 * Browser-only — relies on `Image`, `<canvas>`, and `canvas.toBlob`. Throws if
 * called in a non-DOM context or if the SVG fails to decode.
 */
export declare function svgCardToPngDataUri(card: InsertCardData, opts?: SvgCardToPngOptions): Promise<string>;
/**
 * Like {@link svgCardToPngDataUri} but also returns the **logical (un-scaled)**
 * card dimensions so consumers can size the inserted `<img width height>` and
 * drop their own supersampling shim. The PNG itself is rasterised at `scale`
 * (default `Math.max(2, devicePixelRatio)`) for crispness.
 */
export declare function svgCardToPng(card: InsertCardData, opts?: SvgCardToPngOptions): Promise<InsertPngResult>;
export declare const InsertButton: import("react").ForwardRefExoticComponent<InsertButtonProps & import("react").RefAttributes<HTMLDivElement>>;
export {};
//# sourceMappingURL=insert-result.d.ts.map