@openpresentation/opf 0.10.1 → 0.11.1

package/dist/composition-DzLwY-Mi.d.ts

@@ -0,0 +1,887 @@
+/** 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[];
+
+/**
+ * Deterministic header/footer field formatting. Nothing here consults a clock,
+ * the host locale or the host time zone: dates are calendar dates supplied by the
+ * document or the host, and month/weekday names are fixed English names.
+ */
+/** A live field inside displayed furniture text, as half-open UTF-16 offsets into the part's `text`. */
+interface FurnitureField {
+    type: 'slideNumber' | 'date';
+    start: number;
+    end: number;
+    /** Resolved date pattern for a current (`date: true`) date. */
+    format?: string;
+}
+/** PowerPoint's first Insert > Date and Time choice for en-US (`datetime1`). */
+declare const DEFAULT_FURNITURE_DATE_FORMAT = "M/d/yyyy";
+declare const DEFAULT_SLIDE_NUMBER_FORMAT = "{current}";
+/** Format an ISO calendar date with an LDML-style pattern. Returns an error message when either input is unsupported. */
+declare function formatFurnitureDate(iso: string, pattern: string): {
+    text: string;
+} | {
+    error: string;
+};
+/** Resolve a slide-number template. `{current}` becomes a live field; `{total}` is fixed text. */
+declare function formatSlideNumber(format: string, current: number, total: number | undefined): {
+    text: string;
+    fields: FurnitureField[];
+} | {
+    error: string;
+};
+
+/** 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" | "unsupported-image-treatment";
+    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;
+}
+/** Shared last-resort font-scheme id when neither the slide, the deck nor the resolved theme names one.
+ * One default for every engine, so preview matches export (font-fidelity-everywhere owner decision). */
+declare const DEFAULT_FONT_SCHEME = "aptos";
+/** Reported when a font-scheme id matches no inline or bundled record. Every engine then uses the
+ * DEFAULT_FONT_SCHEME record as the base, with any sibling overrides on top. */
+interface FontSchemeDiagnostic {
+    code: "unresolved-font-scheme";
+    /** Where the unresolved id is written: `slides.N.design.fontScheme`, `design.fontScheme`, or the
+     * `design.theme` reference whose record names it. */
+    path: string;
+    message: string;
+    /** The unresolved font-scheme id. */
+    id: string;
+    /** The font scheme used instead (DEFAULT_FONT_SCHEME). */
+    fallback: string;
+}
+interface ResolvedFontScheme {
+    scheme: Record<string, unknown>;
+    diagnostic?: FontSchemeDiagnostic;
+}
+/** Resolve a font-scheme reference the same way in every engine. A string id, or the `id` of an object
+ * reference, resolves through `lookup` (inline records, then bundled or host catalogs). An unresolved id
+ * returns a diagnostic, and the DEFAULT_FONT_SCHEME record becomes the base, so preview and export use
+ * the same families. An object without `id` is an inline scheme on the same base. Sibling fields on an
+ * object reference override the base per key. */
+declare function resolveFontSchemeReference(reference: unknown, lookup: (id: string) => unknown, path?: string): ResolvedFontScheme;
+/** Resolve role families from an already-merged font scheme (catalog record plus design overrides).
+ * A scheme that names no heading or body family gets the DEFAULT_FONT_SCHEME families (Aptos Display, Aptos).
+ * `code` comes from the scheme's `code` role, which catalog records such as consolas and courier-new
+ * carry; otherwise it is Roboto Mono. Heading and body families are never reused for code. */
+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;
+    /**
+     * Resolved horizontal text alignment for this item: titleAlignment for the
+     * title, contentAlignment for every other item (slide design, then host
+     * option, then left). Engines anchor native and preview text to this value.
+     */
+    alignment: 'left' | 'center' | 'right';
+}
+/**
+ * Slide-level image resolved from design.slideImage. It is active when the slide sets its own
+ * design.slideImage, or when the deck sets one and either the slide's layout record declares
+ * slideImage: true or the slide's root image is the same source.
+ * Content composes in the part of the slide the image does not occupy; 'background' leaves the whole slide.
+ */
+interface ComposedSlideImage {
+    /** The design value that configured the image: 'design.slideImage' or 'slides.N.design.slideImage'. */
+    path: string;
+    /** Path of the drawn asset value: the design value, or the slide's root image payload it replaced. */
+    sourcePath: string;
+    /** Asset value (string or Asset object) that engines resolve like any other image. */
+    value: unknown;
+    position: 'background' | 'top' | 'bottom' | 'left' | 'right';
+    /** crop covers the frame (centered); fit shows the whole image centered inside it. */
+    fill: 'crop' | 'fit';
+    /** Band allocated to the image. */
+    region: LayoutBox;
+    /** Image frame inside the region. */
+    box: LayoutBox;
+    /** True when the slide's root image payload became this slide image instead of a content item. */
+    replacesContent: boolean;
+    /** Treatment alt text; engines fall back to the asset's own alt text. */
+    alt?: string;
+    /** Mask on the frame: a DrawingML preset with its guide values, and the same outline as an SVG path. */
+    shape: SlideImageShape;
+    /** Line centered on the shape outline; width in reference pixels (already scaled to the canvas). */
+    border?: {
+        color: unknown;
+        width: number;
+    };
+    /** Image opacity below 1; the border and overlay are not affected. */
+    opacity?: number;
+    /** Luminance-based recolor (Rec. 601 weights on sRGB values). */
+    recolor?: {
+        type: 'grayscale';
+    } | {
+        type: 'duotone';
+        dark: unknown;
+        light: unknown;
+    };
+    /** Scrim over the frame (same shape) or over an edge band of a rectangle frame. */
+    overlay?: {
+        color: unknown;
+        opacity: number;
+        box: LayoutBox;
+        shape: SlideImageShape;
+    };
+}
+/** A frame mask. path follows the ECMA-376 preset formula for preset/adjust exactly, in reference pixels. */
+interface SlideImageShape {
+    kind: 'rectangle' | 'rounded' | 'circle' | 'hexagon';
+    preset: 'rect' | 'roundRect' | 'ellipse' | 'hexagon';
+    /** DrawingML avLst guide values (for example adj and vf), in 1/100000 units. */
+    adjust: Record<string, number>;
+    path: string;
+}
+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;
+    /** Active slide-level image; absent when design.slideImage does not apply to this slide. */
+    slideImage?: ComposedSlideImage;
+    explanation?: CompositionExplanation;
+}
+interface ComposeSlideOptions {
+    /** Context for inherited furniture, generated organization names and social profiles. */
+    presentation?: {
+        design?: {
+            header?: unknown;
+            footer?: unknown;
+            slideImage?: unknown;
+            imageFill?: unknown;
+        };
+        organization?: unknown;
+        slides?: unknown;
+        catalogs?: unknown;
+    };
+    /**
+     * Host-resolved social-platform records for generated `socials` furniture.
+     * Inline `presentation.catalogs.socialPlatforms.records` take precedence. Hosts
+     * normally pass the bundled catalog; without a matching record a handle renders
+     * as its raw value, as the Socials contract specifies.
+     */
+    socialPlatforms?: readonly SocialPlatformRecord[];
+    /** One-based displayed number; source paths still use slideIndex. */
+    slideNumber?: number;
+    /** Displayed slide count for `{total}` in slideNumberFormat. Defaults to `presentation.slides.length`. */
+    slideCount?: number;
+    /**
+     * Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` furniture. Core never
+     * consults a clock; without this option a current date is reported as unresolved content.
+     */
+    date?: string;
+    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);
+}
+/**
+ * Outline of a DrawingML preset in a box, following the ECMA-376 presetShapeDefinitions formulas:
+ * roundRect (adj; ss = min(w,h), radius = ss*adj/100000), ellipse, and hexagon (adj, vf).
+ */
+declare function slideImageShape(kind: SlideImageShape['kind'], box: LayoutBox, cornerRadius?: number): SlideImageShape;
+interface FurniturePartBase {
+    kind: 'header' | 'footer';
+    zone: 'left' | 'center' | 'right';
+    field: 'text' | 'image' | 'organization' | 'socials' | '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;
+    /**
+     * Live values inside `text`: every `{current}` slide number, and a whole current
+     * (`date: true`) date. Hosts such as PPTX may emit them as native fields; all other
+     * text, including `{total}` and formatted fixed dates, is fixed.
+     */
+    fields?: FurnitureField[];
+    /**
+     * Generated `socials` only: one entry per explicit source line of `text`, in
+     * order. A part may carry both `fields` and `links`; hosts apply each link to
+     * its whole source line and each field range within it.
+     */
+    links?: FurnitureSocialLink[];
+}
+/** Optional generated metadata for one furniture text part (live fields and/or social links). */
+interface FurnitureTextExtras {
+    fields?: FurnitureField[];
+    links?: FurnitureSocialLink[];
+}
+/** Social-platform catalog fields used to format a profile. */
+interface SocialPlatformRecord {
+    id: string;
+    name?: string;
+    baseUrl?: string;
+    profileUrlPattern?: string;
+    companyUrlPattern?: string;
+    handlePrefix?: string;
+}
+interface SocialProfile {
+    /** Single-line display text: the profile URL without an `https://` scheme, or the raw value. */
+    text: string;
+    /** Full http(s) URL when the value is one or its platform record formats one. */
+    href?: string;
+    /** Whether a socialPlatforms record formatted a handle. */
+    resolved: boolean;
+}
+interface FurnitureSocialLink extends SocialProfile {
+    /** Socials key (platform id). */
+    platform: string;
+    /** Authored value path, such as `organization.socials.x`. */
+    sourcePath: string;
+}
+/**
+ * Format one Socials value through its platform record, deterministically and
+ * without network access. `owner` selects companyUrlPattern for organizations.
+ * URLs pass through; unknown platforms and unformattable values stay raw.
+ */
+declare function resolveSocialProfile(platform: string, value: string, records?: readonly SocialPlatformRecord[], owner?: 'organization' | 'speaker'): SocialProfile;
+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 {
+    /** Tabs are source-preserving layout controls with a fixed advance, not glyph text. */
+    kind?: 'tab';
+    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 QuoteTextSource as $, type FurnitureSocialLink as A, type FurnitureTextExtras as B, type ComposeSlideOptions as C, DEFAULT_FONT_SCHEME as D, type FurnitureTextPart as E, type FontSchemeDiagnostic as F, type LayoutBox as G, type ListEntryLayout as H, type ListFit as I, type ListText as J, type ListValue as K, type LayoutDiagnostic as L, MAX_COMPOSITION_DEPTH as M, type MeasureTextWidth as N, type MetricContent as O, type MetricLayout as P, type MetricLayoutDiagnostic as Q, type MetricLayoutOptions as R, type MetricTextPart as S, type TextMeasurement as T, type MetricTextSource as U, OPFCompositionError as V, type QuoteContent as W, type QuoteLayout as X, type QuoteLayoutDiagnostic as Y, type QuoteLayoutOptions as Z, type QuoteTextPart as _, type CodeContent as a, slideImageShape as a$, type ResolveColorRefOptions as a0, type ResolveColorRefRoles as a1, type ResolvedFontScheme as a2, type RichTextFit as a3, type RichTextFragment as a4, type RichTextLine as a5, type RichTextOptions as a6, type RichTextRun as a7, type SlideComposition as a8, type SlideImageShape as a9, measureText as aA, measureTextOutline as aB, normalizeHexColor as aC, placeTextLines as aD, resolveCanvasDimensions as aE, resolveColorRef as aF, resolveFontFamilies as aG, resolveFontSchemeReference as aH, resolveSocialProfile as aI, resolveTextStyle as aJ, textColorForFill as aK, textWidthMeasurer as aL, wrapText as aM, type FontFaceSelection as aN, type SourceTextFit as aO, type TableBorder as aP, type TableCellLayout as aQ, type TableCellStyle as aR, type TableGrid as aS, type TableGridCell as aT, type TableGridIssue as aU, type TableLayout as aV, type TableLayoutOptions as aW, type TableRowLayout as aX, type TextLineSegment as aY, type TextLineSource as aZ, layoutTable as a_, type SocialPlatformRecord as aa, type SocialProfile as ab, type TextFit as ac, type TextLineInk as ad, type TextPlacement as ae, type TextPlacementLine as af, type TextStyle as ag, type TimelineContent as ah, type TimelineEvent as ai, type TimelineLayout as aj, type TimelineLayoutDiagnostic as ak, type TimelineLayoutOptions as al, type TimelineTextPart as am, chartColorForFill as an, colorContrast as ao, composeSlide as ap, fitList as aq, fitRichText as ar, fitText as as, formatFurnitureDate as at, formatSlideNumber as au, layoutCode as av, layoutFurniture as aw, layoutMetric as ax, layoutQuote as ay, layoutTimeline as az, type CodeLayout as b, tableGrid as b0, tableRowBoundaries as b1, type CodeLayoutDiagnostic as c, type CodeLayoutOptions as d, type CodeLineSegment as e, type CodeLineSource as f, type CodeTextFit as g, type CodeTextPart as h, type ComposedFlow as i, type ComposedGroup as j, type ComposedItem as k, type ComposedSlideImage as l, type Composition as m, type CompositionCandidate as n, type CompositionDecision as o, type CompositionExplanation as p, type CompositionPenalties as q, type CompositionTrack as r, DEFAULT_FURNITURE_DATE_FORMAT as s, DEFAULT_SLIDE_NUMBER_FORMAT as t, type FontFamilies as u, type FurnitureField as v, type FurnitureImagePart as w, type FurnitureLayout as x, type FurniturePart as y, type FurniturePartBase as z };