@openpresentation/opf 0.10.0 → 0.11.0

package/dist/composition-Tv9Wm3Oh.d.ts

@@ -0,0 +1,691 @@
+/** Canonical table grid. No renderer, fonts, DOM or network dependencies. */
+interface TableBorder {
+    color: string;
+    width: number;
+    dash?: 'solid' | 'dash' | 'dot';
+}
+interface TableCellStyle {
+    fill?: string;
+    color?: string;
+    align?: 'left' | 'center' | 'right';
+    verticalAlign?: 'top' | 'middle' | 'bottom';
+    padding?: Partial<Record<'top' | 'right' | 'bottom' | 'left', number>>;
+    borders?: Partial<Record<'top' | 'right' | 'bottom' | 'left', TableBorder>>;
+}
+interface TableGridCell {
+    input: unknown;
+    value: unknown;
+    style: TableCellStyle;
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+    header: boolean;
+    path: string;
+    valuePath: string;
+}
+interface TableGridIssue {
+    path: string;
+    message: string;
+}
+interface TableGrid {
+    rows: TableGridCell[][];
+    columnCount: number;
+    rowCount: number;
+    hasHeaders: boolean;
+    /** Anchor at each covered position; covered positions are not additional cells. */
+    owners: (TableGridCell | undefined)[][];
+    issues: TableGridIssue[];
+}
+declare function tableGrid(value: unknown, path?: string): TableGrid;
+/** Row boundaries that preserve every vertical merge, used by pagination. */
+declare function tableRowBoundaries(value: unknown): number[];
+
+/** Normalize a literal hex color to uppercase #RRGGBB. */
+declare function normalizeHexColor(value: unknown): string | undefined;
+type ResolveColorRefRoles = Partial<Record<'primary' | 'secondary' | 'accent' | 'background' | 'surface' | 'text' | 'textSecondary', string>>;
+interface ResolveColorRefOptions {
+    /** Effective color scheme after design resolution (OOXML slots plus optional role hex overrides). */
+    colorScheme: Record<string, unknown>;
+    /** Optional resolved chrome colors (e.g. renderer `design.colors` with `textSecondary` mapped to `mutedText`). */
+    roles?: ResolveColorRefRoles;
+    /** Top-level presentation `variables` map. */
+    variables?: Record<string, unknown>;
+    /** Theme text color returned when a reference cannot be resolved. */
+    fallback: string;
+}
+/** Resolve a ColorRef or TextRun.color string to a literal hex color. */
+declare function resolveColorRef(reference: string, options: ResolveColorRefOptions): string;
+declare function colorContrast(foreground: string, background: string): number | undefined;
+/** Keep an inherited text color at >=4.5:1; otherwise select black or white.
+ * Callers must preserve explicit text-color overrides before using this fallback.
+ * An unresolved/translucent fill preserves the preferred color, without a contrast claim.
+ */
+declare function textColorForFill(fill: string, preferred: string): string;
+/** Keep an inherited chart mark at >=3:1 against its opaque panel. Otherwise
+ * mix toward black or white in bounded 1/255 steps, choosing the first passing
+ * step (higher contrast breaks a tie). This retains a recognizable palette;
+ * it does not establish distinction between adjacent series or colorblind safety.
+ * Explicit mark overrides belong to the caller; unresolved alpha is preserved.
+ */
+declare function chartColorForFill(fill: string, preferred: string): string;
+
+/** Portable layout geometry. No fonts, DOM, renderer, or network dependencies. */
+interface Composition {
+    mode?: "auto" | "grid" | "row" | "column";
+    columns?: number;
+    gap?: number;
+    padding?: number;
+    weights?: number[];
+    minFontSize?: number;
+    overflow?: "warn" | "error";
+}
+declare const MAX_COMPOSITION_DEPTH = 32;
+interface LayoutBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface LayoutDiagnostic {
+    code: "text-overflow" | "small-cell" | "unresolved-content";
+    path: string;
+    message: string;
+}
+/** Physical legacy-family selection supplied by a font provider, independently of its numeric weight. */
+interface FontFaceSelection {
+    family: string;
+    bold: boolean;
+    italic: boolean;
+}
+interface TextStyle {
+    fontFamily: string;
+    fontWeight: number;
+    italic?: boolean;
+    path?: string;
+    fontFace?: FontFaceSelection;
+}
+interface FontFamilies {
+    heading: string;
+    body: string;
+    code: string;
+}
+declare function resolveFontFamilies(input: unknown): FontFamilies;
+interface TextMeasurement {
+    measure: (text: string, fontSize: number, style: TextStyle) => number;
+    resolveStyle?: (style: TextStyle) => TextStyle;
+    /** Shaped vector ink relative to the left baseline origin (positive y down).
+     * Null means no outline. These are not hinted/antialiased raster bounds. */
+    outlineBounds?: (text: string, fontSize: number, style: TextStyle) => LayoutBox | null;
+}
+type MeasureTextWidth = (text: string, fontSize: number) => number;
+declare function resolveTextStyle(style: TextStyle, measurement?: TextMeasurement): TextStyle;
+declare function textWidthMeasurer(style: TextStyle, measurement?: TextMeasurement): MeasureTextWidth;
+/** Validate an optional host outline measurement without inventing raster coverage. */
+declare function measureTextOutline(text: string, fontSize: number, style: TextStyle, measurement?: TextMeasurement): LayoutBox | null | undefined;
+interface TextLineInk {
+    width: number;
+    y: number;
+    baseline: number;
+    height: number;
+    outline: LayoutBox | null;
+}
+interface TextPlacementLine {
+    x: number;
+    y: number;
+    baseline: number;
+    height: number;
+    width: number;
+    outline: LayoutBox | null;
+}
+interface TextPlacement {
+    alignment: 'left' | 'center' | 'right';
+    /** Reference-pixel clearance around vector outlines; not a universal raster guarantee. */
+    rasterPadding: number;
+    lines: TextPlacementLine[];
+    height: number;
+    overflow: boolean;
+}
+interface TextFit {
+    lines: string[];
+    fontSize: number;
+    lineHeight: number;
+    overflow: boolean;
+    placement?: TextPlacement;
+}
+/** Place complete measured lines, preserving alignment where it leaves room for ink.
+ * Move following baselines together when outlines need more vertical separation. */
+declare function placeTextLines(lines: readonly TextLineInk[], box: LayoutBox, alignment?: TextPlacement['alignment'], rasterPadding?: number): TextPlacement;
+interface ComposedItem {
+    path: string;
+    field: string;
+    type: string;
+    value: unknown;
+    payload: Record<string, unknown>;
+    box: LayoutBox;
+    /** Optional visible card allocation; box and all accepted internals occupy its padded interior. */
+    frameBox?: LayoutBox;
+    text?: TextFit | RichTextFit | ListFit | CodeTextFit;
+    textStyle?: TextStyle;
+    /** Complete accepted quote internals; consumers must reuse these fits and styles. */
+    quoteLayout?: QuoteLayout;
+    /** Complete accepted code internals, including source lines and literal tab positions. */
+    codeLayout?: CodeLayout;
+    /** Complete shared metric geometry, including its unit, label and metadata. */
+    metricLayout?: MetricLayout;
+    /** Complete timeline fields, markers and connector accepted by composition. */
+    timelineLayout?: TimelineLayout;
+    /** Effective container settings, including inherited readability constraints. */
+    composition: Composition;
+}
+interface ComposedGroup {
+    path: string;
+    box: LayoutBox;
+    contentBox: LayoutBox;
+    composition: Composition;
+}
+interface CompositionTrack {
+    offset: number;
+    size: number;
+}
+/** Resolved flow geometry, including empty reserved slots. Promoted regions are not flows. */
+interface ComposedFlow {
+    path: string;
+    box: LayoutBox;
+    composition: Composition;
+    columns: CompositionTrack[];
+    rows: CompositionTrack[];
+    gap: number;
+    itemCount: number;
+    slotCount: number;
+}
+/** Additive penalties in grid-score-v9; lower is preferred. These are not quality percentages. */
+interface CompositionPenalties {
+    cellProportions: number;
+    fontReduction: number;
+    textOverflow: number;
+    tableOverflow: number;
+    smallCells: number;
+    emptySlots: number;
+}
+interface CompositionCandidate {
+    columns: number;
+    rows: number;
+    score: number;
+    penalties: CompositionPenalties;
+}
+interface CompositionDecision {
+    path: string;
+    mode: NonNullable<Composition['mode']> | 'regions';
+    reason: 'lowest-score' | 'configured-mode' | 'promoted-regions';
+    selectedColumns?: number;
+    /** Only candidates actually evaluated by automatic selection, in tie-break order. */
+    candidates: CompositionCandidate[];
+}
+interface CompositionExplanation {
+    algorithm: 'grid-score-v9';
+    /** Provided widths do not establish shaping, glyph coverage or native fidelity. */
+    textMeasurement: 'estimated' | 'provided';
+    /** Optional vector coverage for headings and scalar/rich text, not every payload. */
+    textOutlines: 'provided' | 'unavailable';
+    /** Effective body-text reference pixels; furniture reports its own placement padding. Not a universal raster tolerance. */
+    textRasterPadding: number;
+    decisions: CompositionDecision[];
+    /** Payloads whose complete internal fit is not covered by this scoring model. */
+    unmeasuredPayloads: string[];
+}
+interface SlideComposition {
+    width: number;
+    height: number;
+    contentBox: LayoutBox;
+    items: ComposedItem[];
+    groups: ComposedGroup[];
+    flows: ComposedFlow[];
+    diagnostics: LayoutDiagnostic[];
+    composition: Composition;
+    /** Repeated furniture is measured separately from body pagination leaves. */
+    furniture?: FurnitureLayout;
+    explanation?: CompositionExplanation;
+}
+interface ComposeSlideOptions {
+    /** Context for inherited furniture and generated organization names. */
+    presentation?: {
+        design?: {
+            header?: unknown;
+            footer?: unknown;
+        };
+        organization?: unknown;
+    };
+    /** One-based displayed number; source paths still use slideIndex. */
+    slideNumber?: number;
+    fonts?: Partial<FontFamilies>;
+    /** Host-resolved alignment for shared content; slide design can override it. */
+    contentAlignment?: 'left' | 'center' | 'right';
+    titleAlignment?: 'left' | 'center' | 'right';
+    /** Unscaled reference pixels around provided vector outlines; defaults to 1 for body text and 2 for furniture. Explicit values apply to both. */
+    textRasterPadding?: number;
+    /** Host-resolved body cards. A slide's explicit design.contentBox overrides this value. */
+    contentBox?: boolean;
+    textMeasurement?: TextMeasurement;
+    width?: number;
+    height?: number;
+    slideIndex?: number;
+    layout?: Record<string, unknown>;
+    /** Return candidate scores and coverage without changing the selected geometry. */
+    explain?: boolean;
+}
+declare class OPFCompositionError extends Error {
+    readonly diagnostics: LayoutDiagnostic[];
+    readonly code = "layout-overflow";
+    readonly explanation?: CompositionExplanation;
+    constructor(diagnostics: LayoutDiagnostic[], explanation?: CompositionExplanation);
+}
+interface FurniturePartBase {
+    kind: 'header' | 'footer';
+    zone: 'left' | 'center' | 'right';
+    field: 'text' | 'image' | 'organization' | 'section' | 'slideNumber' | 'date';
+    /** Literal field or controlling flag, with the actual inherited/local path. */
+    path: string;
+    /** String/asset source, when different from a generated field's flag. */
+    sourcePath?: string;
+    generated: boolean;
+    box: LayoutBox;
+    alignment: 'left' | 'center' | 'right';
+}
+interface FurnitureTextPart extends FurniturePartBase {
+    type: 'text';
+    text: string;
+    style: TextStyle;
+    requestedFontSize: number;
+    minFontSize: number;
+    fit: SourceTextFit;
+}
+interface FurnitureImagePart extends FurniturePartBase {
+    type: 'image';
+    image: unknown;
+}
+type FurniturePart = FurnitureTextPart | FurnitureImagePart;
+interface FurnitureLayout {
+    algorithm: 'furniture-flow-v2';
+    /** Includes explicitly empty definitions, which override inherited furniture. */
+    configured: boolean;
+    textMeasurement: 'estimated' | 'provided';
+    textOutlines: 'provided' | 'unavailable';
+    parts: FurniturePart[];
+    /** Outer occupied edges; composeSlide adds its normal content gap. */
+    headerBottom: number;
+    footerTop: number;
+    diagnostics: LayoutDiagnostic[];
+    overflow: boolean;
+}
+/** Resolve and measure repeated fields without mutating metadata or consulting a clock. */
+declare function layoutFurniture(input: unknown, options?: ComposeSlideOptions): FurnitureLayout;
+/** Deterministic estimate, not a font shaping engine. Preserves explicit line breaks. */
+declare function measureText(text: string, fontSize: number): number;
+declare function wrapText(text: string, width: number, fontSize: number, measure?: MeasureTextWidth): string[];
+declare function fitText(text: string, box: LayoutBox, requestedSize?: number, minFontSize?: number, measure?: MeasureTextWidth): SourceTextFit;
+interface QuoteContent {
+    text: string;
+    attribution?: string;
+    source?: string;
+}
+/** Source and displayed-text ranges are half-open UTF-16 offsets. Added punctuation has no source range. */
+interface QuoteTextSource {
+    path: string;
+    start: number;
+    end: number;
+    outputStart: number;
+    outputEnd: number;
+}
+interface QuoteTextPart {
+    role: 'body' | 'footer';
+    path: string;
+    text: string;
+    sources: QuoteTextSource[];
+    /** Available space, before fitting. Invalid dimensions remain visible in failed results. */
+    box: LayoutBox;
+    requestedFontSize: number;
+    minFontSize: number;
+    requestedStyle: TextStyle;
+    style: TextStyle;
+    /** Absent when the available box is invalid; never fit against an invented one-pixel box. */
+    fit?: TextFit;
+}
+interface QuoteLayoutDiagnostic extends LayoutDiagnostic {
+    reason: 'invalid-part-box' | 'part-outside-cell' | 'text-fit' | 'part-overlap';
+    parts: QuoteTextPart['role'][];
+}
+interface QuoteLayout {
+    algorithm: 'quote-flow-v1';
+    textMeasurement: 'estimated' | 'provided';
+    parts: QuoteTextPart[];
+    diagnostics: QuoteLayoutDiagnostic[];
+    overflow: boolean;
+}
+interface QuoteLayoutOptions {
+    /** Canvas short edge divided by 720. Insets retain the current 18 reference-pixel contract. */
+    scale?: number;
+    fonts?: Partial<FontFamilies>;
+    /** Readability floor in reference pixels, before canvas scaling. */
+    minFontSize?: number;
+    overflow?: Composition['overflow'];
+    path?: string;
+    textMeasurement?: TextMeasurement;
+}
+/**
+ * Allocate and measure quote body/footer space for composition, rendering and export. Callers must
+ * check overflow before accepting the parts. Line boxes are not shaped glyph or native raster bounds.
+ */
+declare function layoutQuote(value: string | QuoteContent, box: LayoutBox, options?: QuoteLayoutOptions): QuoteLayout;
+interface MetricContent {
+    value: string | number;
+    label?: string;
+    description?: string;
+    unit?: string;
+    delta?: string | number;
+    trend?: 'up' | 'down' | 'flat';
+}
+/** Ranges address String(sourceValue), not the numeric token spelling in serialized JSON. */
+interface MetricTextSource {
+    path: string;
+    value: string | number;
+    start: number;
+    end: number;
+}
+interface MetricTextPart {
+    role: keyof MetricContent;
+    path: string;
+    text: string;
+    sources: MetricTextSource[];
+    /** Empty optional fields retain their source mapping but occupy no visible space. */
+    visible: boolean;
+    /** Accepted absolute origin/baseline for each fit.sourceLines entry, including blank lines. */
+    linePositions: {
+        x: number;
+        baseline: number;
+    }[];
+    box: LayoutBox;
+    requestedFontSize: number;
+    minFontSize: number;
+    requestedStyle: TextStyle;
+    style: TextStyle;
+    /** Source-preserving line/segment representation shared with code, with proportional fonts. */
+    fit?: CodeTextFit;
+}
+interface MetricLayoutDiagnostic extends LayoutDiagnostic {
+    reason: 'invalid-part-box' | 'part-outside-cell' | 'text-fit' | 'part-overlap';
+    parts: MetricTextPart['role'][];
+}
+interface MetricLayout {
+    algorithm: 'metric-flow-v1';
+    alignment: 'left' | 'center' | 'right';
+    textMeasurement: 'estimated' | 'provided';
+    arrangement: 'inline-unit' | 'stacked';
+    /** At most 48 arrangements; value fitting is bounded by 77 reference-size trials per arrangement. */
+    attempts: number;
+    parts: MetricTextPart[];
+    diagnostics: MetricLayoutDiagnostic[];
+    overflow: boolean;
+}
+interface MetricLayoutOptions extends QuoteLayoutOptions {
+    align?: 'left' | 'center' | 'right';
+    /** Unscaled clearance around available vector outlines; defaults to one reference pixel. */
+    textRasterPadding?: number;
+}
+/**
+ * Measure every metric field before accepting geometry. Short single-line values and units can
+ * share a baseline; longer values or units stack. No locale formatting, trend icons or rewritten
+ * source text are invented. Consumers must reuse these accepted parts and source ranges.
+ */
+declare function layoutMetric(value: string | number | MetricContent, box: LayoutBox, options?: MetricLayoutOptions): MetricLayout;
+interface TimelineEvent {
+    when?: string;
+    what: string;
+    description?: string;
+}
+interface TimelineContent {
+    name?: string;
+    description?: string;
+    events: TimelineEvent[];
+}
+interface TimelineTextPart {
+    role: 'name' | 'description' | 'when' | 'what' | 'event-description';
+    eventIndex?: number;
+    path: string;
+    text: string;
+    sources: {
+        path: string;
+        start: number;
+        end: number;
+    }[];
+    box: LayoutBox;
+    alignment: 'left' | 'center';
+    requestedFontSize: number;
+    minFontSize: number;
+    requestedStyle: TextStyle;
+    style: TextStyle;
+    fit?: SourceTextFit;
+}
+interface TimelineLayoutDiagnostic extends LayoutDiagnostic {
+    reason: 'text-fit' | 'part-outside-cell' | 'event-space';
+}
+interface TimelineLayout {
+    algorithm: 'timeline-flow-v1';
+    arrangement: 'alternating' | 'vertical';
+    attempts: number;
+    textMeasurement: 'provided' | 'estimated';
+    textOutlines: 'provided' | 'unavailable';
+    parts: TimelineTextPart[];
+    markers: {
+        path: string;
+        eventIndex: number;
+        x: number;
+        y: number;
+        radius: number;
+    }[];
+    connector: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    diagnostics: TimelineLayoutDiagnostic[];
+    overflow: boolean;
+}
+interface TimelineLayoutOptions extends QuoteLayoutOptions {
+    textRasterPadding?: number;
+}
+/** Preserve event order and field boundaries while trying at most 50 readable arrangements. */
+declare function layoutTimeline(value: readonly TimelineEvent[] | TimelineContent, box: LayoutBox, options?: TimelineLayoutOptions): TimelineLayout;
+interface CodeContent {
+    source: string;
+    language?: string;
+    filename?: string;
+}
+interface TextLineSegment {
+    kind: 'text' | 'tab';
+    start: number;
+    end: number;
+    /** Measured position relative to this displayed line's origin, in reference pixels. */
+    x: number;
+    width: number;
+}
+/** Exact half-open UTF-16 offsets into the part text, including consumed hard line breaks. */
+interface TextLineSource {
+    start: number;
+    end: number;
+    nextStart: number;
+    boundary: 'soft' | 'hard' | 'end';
+    width: number;
+    /** Explicit tab placement is required in SVG; CSS tab-size alone does not implement it. */
+    segments: TextLineSegment[];
+}
+interface SourceTextFit extends TextFit {
+    sourceLines: TextLineSource[];
+    /** Tabs advance to the next multiple of four measured spaces from each displayed line's origin. */
+    tabSize: 4;
+    tabWidth: number;
+}
+/** Compatibility names for the shared source-preserving line contract. */
+type CodeLineSegment = TextLineSegment;
+type CodeLineSource = TextLineSource;
+interface CodeTextFit extends SourceTextFit {
+}
+interface CodeTextPart {
+    role: 'filename' | 'language' | 'body';
+    path: string;
+    /** Original text, without case conversion, whitespace normalization or discarded newlines. */
+    text: string;
+    sources: {
+        path: string;
+        start: number;
+        end: number;
+    }[];
+    generated: boolean;
+    box: LayoutBox;
+    requestedFontSize: number;
+    minFontSize: number;
+    requestedStyle: TextStyle;
+    style: TextStyle;
+    fit?: CodeTextFit;
+}
+interface CodeLayoutDiagnostic extends LayoutDiagnostic {
+    reason: 'invalid-part-box' | 'part-outside-cell' | 'text-fit' | 'part-overlap';
+    parts: CodeTextPart['role'][];
+}
+interface CodeLayout {
+    algorithm: 'code-flow-v1';
+    textMeasurement: 'estimated' | 'provided';
+    parts: CodeTextPart[];
+    diagnostics: CodeLayoutDiagnostic[];
+    overflow: boolean;
+}
+interface CodeLayoutOptions extends QuoteLayoutOptions {
+}
+/** Shared filename/language/body allocation. Consumers must reuse the accepted fits and styles. */
+declare function layoutCode(value: string | CodeContent, box: LayoutBox, options?: CodeLayoutOptions): CodeLayout;
+interface RichTextRun {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    color?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    link?: string;
+    superscript?: boolean;
+    subscript?: boolean;
+}
+interface RichTextFragment {
+    text: string;
+    runIndex: number;
+    start: number;
+    end: number;
+    x: number;
+    width: number;
+    fontSize: number;
+    baselineShift: number;
+    style: TextStyle;
+    run: RichTextRun;
+}
+interface RichTextLine {
+    fragments: RichTextFragment[];
+    width: number;
+    y: number;
+    baseline: number;
+    height: number;
+}
+interface RichTextFit extends TextFit {
+    richLines: RichTextLine[];
+    height: number;
+}
+interface RichTextOptions {
+    style: TextStyle;
+    textMeasurement?: TextMeasurement;
+    /** Use one measured line advance for every line, as native table cells do. */
+    uniformLineHeight?: boolean;
+}
+/** Fit mixed styles without flattening font metrics. Run fontSize is in points. */
+declare function fitRichText(input: readonly (string | RichTextRun)[], box: LayoutBox, requestedSize?: number, minFontSize?: number, options?: RichTextOptions): RichTextFit;
+type ListText = string | readonly (string | RichTextRun)[];
+type ListValue = ListText | {
+    text: ListText;
+    description?: ListText;
+    level?: number;
+};
+interface ListEntryLayout {
+    index: number;
+    level: number;
+    textPath?: string;
+    descriptionPath?: string;
+    value: ListText;
+    descriptionValue?: ListText;
+    text: RichTextFit;
+    description?: RichTextFit;
+    textBox: LayoutBox;
+    descriptionBox?: LayoutBox;
+    marker: {
+        text: string;
+        x: number;
+        y: number;
+        fontSize: number;
+        style: TextStyle;
+        indent: number;
+    };
+}
+interface ListFit extends TextFit {
+    listEntries: ListEntryLayout[];
+    height: number;
+}
+/** Shared hanging indents, mixed-run fitting and description spacing for list payloads. */
+declare function fitList(input: readonly ListValue[], box: LayoutBox, requestedSize?: number, minFontSize?: number, options?: RichTextOptions): ListFit;
+interface TableLayoutOptions {
+    scale?: number;
+    minFontSize?: number;
+    fontFamily?: string;
+    textMeasurement?: TextMeasurement;
+    path?: string;
+}
+interface TableCellLayout {
+    value: unknown;
+    input: unknown;
+    sourcePath: string;
+    style: TableCellStyle;
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+    path: string;
+    header: boolean;
+    rich: boolean;
+    box: LayoutBox;
+    textBox: LayoutBox;
+    textStyle: TextStyle;
+    fit: TextFit | RichTextFit;
+}
+interface TableRowLayout {
+    box: LayoutBox;
+    cells: TableCellLayout[];
+}
+interface TableLayout {
+    rows: TableRowLayout[];
+    columnCount: number;
+    height: number;
+    overflow: boolean;
+}
+/** Shared cell geometry and font fitting for SVG, native PPTX and pagination.
+ * Short rows retain their 54px preferred height. Multiline rows use the space
+ * their text needs; constrained tables consume row padding before readable text.
+ * All dimensions are canvas pixels; minFontSize is an unscaled canvas size.
+ */
+declare function layoutTable(value: unknown, box: LayoutBox, options?: TableLayoutOptions): TableLayout;
+/** Compose a validated Slide. Layout resolution remains the caller's responsibility. */
+declare function composeSlide(input: unknown, options?: ComposeSlideOptions): SlideComposition;
+/** Canonical physical slide size, converted to reference pixels at 96 pixels/inch. */
+declare function resolveCanvasDimensions(input: unknown): {
+    width: number;
+    height: number;
+};
+
+export { type TextFit as $, type ListValue as A, type MeasureTextWidth as B, type CodeContent as C, type MetricContent as D, type MetricLayout as E, type FontFamilies as F, type MetricLayoutDiagnostic as G, type MetricLayoutOptions as H, type MetricTextPart as I, type MetricTextSource as J, type QuoteLayout as K, type LayoutBox as L, MAX_COMPOSITION_DEPTH as M, type QuoteLayoutDiagnostic as N, OPFCompositionError as O, type QuoteLayoutOptions as P, type QuoteContent as Q, type QuoteTextPart as R, type QuoteTextSource as S, type ResolveColorRefOptions as T, type ResolveColorRefRoles as U, type RichTextFit as V, type RichTextFragment as W, type RichTextLine as X, type RichTextOptions as Y, type RichTextRun as Z, type SlideComposition as _, type CodeLayout as a, type TextLineInk as a0, type TextMeasurement as a1, type TextPlacement as a2, type TextPlacementLine as a3, type TextStyle as a4, type TimelineContent as a5, type TimelineEvent as a6, type TimelineLayout as a7, type TimelineLayoutDiagnostic as a8, type TimelineLayoutOptions as a9, type TableCellLayout as aA, type TableCellStyle as aB, type TableGrid as aC, type TableGridCell as aD, type TableGridIssue as aE, type TableLayout as aF, type TableLayoutOptions as aG, type TableRowLayout as aH, type TextLineSegment as aI, type TextLineSource as aJ, layoutTable as aK, tableGrid as aL, tableRowBoundaries as aM, type TimelineTextPart as aa, chartColorForFill as ab, colorContrast as ac, composeSlide as ad, fitList as ae, fitRichText as af, fitText as ag, layoutCode as ah, layoutFurniture as ai, layoutMetric as aj, layoutQuote as ak, layoutTimeline as al, measureText as am, measureTextOutline as an, normalizeHexColor as ao, placeTextLines as ap, resolveCanvasDimensions as aq, resolveColorRef as ar, resolveFontFamilies as as, resolveTextStyle as at, textColorForFill as au, textWidthMeasurer as av, wrapText as aw, type FontFaceSelection as ax, type SourceTextFit as ay, type TableBorder as az, type CodeLayoutDiagnostic as b, type CodeLayoutOptions as c, type CodeLineSegment as d, type CodeLineSource as e, type CodeTextFit as f, type CodeTextPart as g, type ComposeSlideOptions as h, type ComposedFlow as i, type ComposedGroup as j, type ComposedItem as k, type Composition as l, type CompositionCandidate as m, type CompositionDecision as n, type CompositionExplanation as o, type CompositionPenalties as p, type CompositionTrack as q, type FurnitureImagePart as r, type FurnitureLayout as s, type FurniturePart as t, type FurniturePartBase as u, type FurnitureTextPart as v, type LayoutDiagnostic as w, type ListEntryLayout as x, type ListFit as y, type ListText as z };