@openpresentation/opf 0.11.3 → 0.12.0

package/dist/composition-DWbCiMwF.d.ts

@@ -0,0 +1,1523 @@
+/** 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[];
+
+/** A positioned thing whose reading position is wanted. */
+interface ReadingBox {
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Visual reading order: rows from top to bottom, and within a row from the start to the end of the line.
+ *
+ * Items whose vertical centre falls inside an existing row's vertical extent join that row (so a full-height
+ * item shares one row with everything beside it and the row reads left to right). Rows are ordered by their
+ * top edge. Ties keep the input order, so the result is deterministic.
+ *
+ * The boxes are read as given: pass them in logical (unmirrored) coordinates and the order is the reading
+ * order of both a left-to-right and a right-to-left deck, because mirroring a deck moves where an item is
+ * drawn and where a line starts together. For boxes that are already mirrored, pass `direction: 'rtl'` to
+ * order each row from right to left. composeSlide uses this for promoted regions and `opf audit` uses it to
+ * check the composed order, so the two cannot drift apart.
+ */
+declare function visualReadingOrder<T extends ReadingBox>(items: readonly T[], direction?: 'ltr' | 'rtl'): T[];
+
+/**
+ * Text direction primitives shared by composition, the renderer and the PPTX exporter (RR-05).
+ * Pure: no fonts, DOM or catalogs. Deck direction comes from the presentation language's script
+ * (script-fonts.ts); a paragraph's own direction comes from its first strong character.
+ */
+/** Paragraph base direction. */
+type TextDirection = "ltr" | "rtl";
+/**
+ * The base direction of one paragraph in a deck, shared by the renderer and
+ * the PPTX exporter so preview and export agree. In a right-to-left deck a
+ * paragraph is right-to-left when its first strong character is
+ * right-to-left, or when it has no strong character (digits, punctuation or
+ * empty text); a paragraph whose first strong character is left-to-right
+ * (for example an English quote or code) stays left-to-right. In a
+ * left-to-right deck every paragraph is left-to-right.
+ *
+ * Strong characters follow UAX #9 rule P2: text inside directional isolates
+ * (LRI, RLI or FSI up to the matching PDI) is skipped. Letters count as
+ * strong; RTL letters are those of right-to-left scripts. The result does not
+ * depend on locale data, only on the JavaScript engine's Unicode tables.
+ */
+declare function paragraphDirection(text: string, deckDirection: TextDirection | string | undefined): TextDirection;
+/** Horizontal alignment as drawn: the physical left, centre or right of the text box. */
+type PhysicalAlignment = "left" | "center" | "right";
+/**
+ * Authored alignment is logical for right-to-left text (RR-05): `left` means the start edge and
+ * `right` the end edge, so in a right-to-left paragraph `left` is drawn at the right edge and
+ * `right` at the left edge. `center` is unchanged, and so is every left-to-right paragraph.
+ */
+declare function physicalAlignment(alignment: PhysicalAlignment | undefined, direction: TextDirection | undefined): PhysicalAlignment;
+/**
+ * The base direction at a UTF-16 offset of `text`, where paragraphs are the segments between hard
+ * line breaks (CR, LF or CRLF). Every wrapped line of a paragraph shares its direction, so a
+ * line made only of Latin words or digits never changes the paragraph it belongs to.
+ */
+declare function paragraphDirectionAt(text: string, deckDirection: TextDirection | string | undefined): (offset: number) => TextDirection;
+
+/**
+ * Numbered lists: the `numbering` field of `items` and `bullets` payloads.
+ *
+ * Pure helpers shared by composition (marker text and hanging indent), the validator, pagination and the
+ * exporters, so the preview and the native PowerPoint export number every entry identically. Nothing here
+ * measures text or reads a document beyond the items it is given.
+ */
+/** The five number styles OPF supports; each maps to a native PowerPoint auto-number scheme. */
+declare const NUMBERING_STYLES: readonly ["arabic", "roman-upper", "roman-lower", "alpha-upper", "alpha-lower"];
+type NumberingStyleName = typeof NUMBERING_STYLES[number];
+/** `period` draws `1.`, `paren` draws `1)` and `paren-both` draws `(1)`. */
+declare const NUMBERING_SUFFIXES: readonly ["period", "paren", "paren-both"];
+type NumberingSuffix = typeof NUMBERING_SUFFIXES[number];
+/** Object form of one level's numbering. Every field is optional. */
+interface Numbering {
+    /** Default `arabic`. */
+    style?: NumberingStyleName;
+    /** First number of the level, an integer from 1 to 32767 (the native `startAt` range). Default 1. */
+    start?: number;
+    /** Default `period`. */
+    suffix?: NumberingSuffix;
+}
+/**
+ * The `numbering` field: one style name, one {@link Numbering} object (both apply to every level) or an array with
+ * one entry per list level (index = level; the last entry repeats for deeper levels).
+ */
+type NumberingInput = NumberingStyleName | Numbering | readonly (NumberingStyleName | Numbering)[];
+/** One level's numbering with every default applied. */
+interface ResolvedNumbering {
+    style: NumberingStyleName;
+    start: number;
+    suffix: NumberingSuffix;
+}
+/** Largest value a native auto-number can start at (`a:buAutoNum@startAt`, ST_TextStartAt). */
+declare const MAX_NUMBERING_VALUE = 32767;
+/** Largest value drawn as a Roman numeral; larger values are drawn in arabic. */
+declare const MAX_ROMAN_VALUE = 3999;
+/** Deepest list level a native paragraph can carry (`a:pPr@lvl` is 0 to 8). */
+declare const MAX_NUMBERING_LEVELS = 9;
+/**
+ * Resolve a `numbering` value to one entry per authored level (a single entry when it applies to every level).
+ * Use {@link numberingAtLevel} to read the entry for a level. Throws on a value the schema rejects.
+ */
+declare function resolveNumbering(input: NumberingInput): ResolvedNumbering[];
+/** The numbering of one list level: the entry at that index, else the last entry. */
+declare function numberingAtLevel(levels: readonly ResolvedNumbering[], level: number): ResolvedNumbering;
+/** Whether `style` can draw `value` as that style (Roman numerals stop at 3999). */
+declare function numberingStyleDraws(style: NumberingStyleName, value: number): boolean;
+/**
+ * Format a list number as the preview draws it and PowerPoint's matching `a:buAutoNum` scheme draws it:
+ * `formatListNumber(4, 'roman-lower')` is `iv.`, `(3, 'alpha-upper', 'paren')` is `C)` and `(27, 'alpha-lower')` is `aa.`.
+ * Roman values above 3999 fall back to arabic (see {@link listNumbers} for the reported adaptation).
+ */
+declare function formatListNumber(value: number, style?: NumberingStyleName, suffix?: NumberingSuffix): string;
+/** The number of one list entry. */
+interface ListNumber {
+    /** Position of the entry in the list. */
+    index: number;
+    level: number;
+    /** The counted number (1 or more). */
+    value: number;
+    /** The style actually drawn: `arabic` when the authored style cannot draw `value`. */
+    style: NumberingStyleName;
+    suffix: NumberingSuffix;
+    /** The drawn marker, for example `iv.`. */
+    text: string;
+    /** Why the drawn style differs from the authored one: Roman numerals stop at 3999. */
+    adapted?: 'roman-range';
+}
+/**
+ * The numbers of a list, counted as PowerPoint counts them: consecutive entries of one level count up from that
+ * level's `start`; an entry of a shallower level restarts every deeper level; deeper entries between two entries of
+ * one level do not interrupt it. An object item's own `start` (an integer from 1 to 32767) restarts the count at that
+ * entry. Items are read for their `level` and `start` only.
+ */
+declare function listNumbers(items: readonly unknown[], numbering: NumberingInput): ListNumber[];
+/**
+ * The slice `items[from, to)` of a numbered list as the items of a continuation, with `start` set on every entry whose
+ * number would otherwise change, so a paginated list keeps the numbers of the whole list.
+ */
+declare function sliceNumberedItems<T>(items: readonly T[], numbering: NumberingInput, from: number, to?: number): T[];
+
+/**
+ * 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;
+/** Smallest CIE L* step kept between neighbouring series (a printed or greyscale chart tells them apart by lightness alone). */
+declare const CHART_SERIES_MIN_LIGHTNESS_STEP = 11;
+/** Smallest CIE76 colour difference kept between any two series that were at least that far apart before the surface adjustment. */
+declare const CHART_SERIES_MIN_DIFFERENCE = 12;
+/** Series colours for a chart drawn on `fill`: the palette in order, each colour adjusted for contrast
+ * (`chartColorForFill`) without letting the adjustment merge series.
+ *
+ * Lifting or darkening a colour for a dark or mid-tone surface moves every failing colour towards the same
+ * few lightness values, so two blues that differ on white can end up identical on a dark card. Colours that
+ * already have >= 3:1 contrast against `fill` are kept exactly. A colour the contrast adjustment would move is
+ * placed again on the lightness axis, keeping its hue and as much of its chroma as sRGB allows, subject to
+ * >= 3:1 contrast against `fill` and these separations from the other series (each capped at the separation
+ * that pair had in `palette`, so a pair the palette itself made close is not asked to be far apart):
+ *
+ * - a colour difference (CIE76) of at least {@link CHART_SERIES_MIN_DIFFERENCE} from every other series;
+ * - a lightness step of at least {@link CHART_SERIES_MIN_LIGHTNESS_STEP} (CIE L*) from the neighbouring
+ *   series, which is what keeps neighbours apart on a greyscale print;
+ * - the same lightness step from the remaining series, as a weaker aim.
+ *
+ * Series are placed in order against the kept colours and the colours placed before them. The placement
+ * with the lowest cost wins: its distance (in L*) from the contrast-adjusted colour plus a penalty for
+ * every point it falls short of those separations, so a colour that is already clear of the others is
+ * simply the adjusted colour, a near miss is not worth a large change, and a collision is resolved at the
+ * nearest lightness that clears it. The result is deterministic and in series order. An unresolved or
+ * translucent fill or colour is passed through, like `chartColorForFill`.
+ *
+ * It depends only on the surface and the palette, so every chart on a surface gets the same series colours,
+ * and preview and export (which both call this function) draw the same ones.
+ */
+declare function chartPaletteForFill(fill: string, palette: readonly string[]): string[];
+
+/**
+ * Footnotes, citations and captions (RR-34).
+ *
+ * - A TextRun may `cite` one or more ids of the deck's top-level `references`, or carry an inline
+ *   `footnote`. Markers are numbered per deck in reading order of first use (slides, then regions,
+ *   blocks and runs); the same reference id keeps its number, every footnote takes a new one. A run's
+ *   marker is a superscript fragment drawn directly after the run (`1`, or `1,2` for several ids);
+ *   `richTextLayouter` emits it from `RichTextOptions.citationMarker`, so it wraps with its word and
+ *   never shifts run indexes or source offsets.
+ * - A slide that carries markers gets a footnote area directly above the footer band: `layoutFootnotes`
+ *   lists `<n> <text>` for the slide's markers in number order, and `composeSlide` shrinks the content
+ *   area by exactly its height. Slides without markers are unchanged.
+ * - `caption` on an image, chart, table or video payload reserves a caption band inside the block's
+ *   region (`layoutCaption`): the media keeps the rest. Captions use the body family at the caption size
+ *   (0.6 of the body size, clamped to the readable floor) in the muted text colour.
+ *
+ * Geometry is shared: renderers and exporters only draw what these functions return.
+ */
+type CaptionPosition = 'below' | 'above';
+type CaptionAlignment = 'left' | 'center' | 'right';
+type RichText = string | readonly (string | RichTextRun)[];
+interface CaptionObject {
+    text: RichText;
+    position?: CaptionPosition;
+    align?: CaptionAlignment;
+}
+type Caption = RichText | CaptionObject;
+interface Reference {
+    id: string;
+    text: RichText;
+    url?: string;
+}
+interface CaptionSettings {
+    text: RichText;
+    position: CaptionPosition;
+    align: CaptionAlignment;
+}
+/**
+ * A marker is exported as a superscript run at the marked run's own size with DrawingML `baseline="30000"`, the way a user ticks
+ * Superscript. PowerPoint then draws the glyph at 2/3 of that nominal size and raises it by baseline x nominal size. Measured in
+ * PowerPoint 365 on Windows on 2026-10-01 with probe-superscript.pptx (Roboto and Aptos, 10 to 44 pt, digit ink height of a
+ * superscript run against a plain run of the same size): ratio 0.655 to 0.69, mean 0.667, independent of face and size; raise
+ * 0.30 of the nominal size at every size (baseline 30000). An explicit smaller sz on top is reduced again (0.7 x sz drew at about
+ * 0.47 of the run), which is why the exporter does not write one. The preview composes the same glyph size and raise.
+ *
+ * The drawn marker glyph is this fraction of the nominal size (the marked run's size), snapped to the 0.01 pt grid.
+ */
+declare const CITATION_MARKER_SCALE: number;
+/** The raise as a fraction of the NOMINAL size (the marked run's size): DrawingML `baseline="30000"`. */
+declare const CITATION_MARKER_RAISE = 0.3;
+/** Caption text size as a fraction of the body size, before the readable floor. */
+declare const CAPTION_FONT_RATIO = 0.6;
+/** A caption band takes at most this fraction of its block region. */
+declare const CAPTION_MAX_RATIO = 0.35;
+/** A footnote area takes at most this fraction of the span between heading top and footer band. */
+declare const FOOTNOTE_MAX_RATIO = 0.35;
+/** Payload fields whose blocks may carry a caption. */
+declare const CAPTIONABLE_FIELDS: readonly string[];
+/** Flatten a string or TextRun[] to its plain text. */
+declare function annotationText(value: unknown): string;
+/** Normalize a Caption value to its text, position and alignment. */
+declare function captionSettings(value: unknown): CaptionSettings | undefined;
+/** A run that cites or carries a footnote, with its dotted OPF path (`slides.0.blocks.1.text.2`). */
+interface AnnotatedRun {
+    path: string;
+    run: RichTextRun;
+    cite: string[];
+    footnote?: RichText;
+}
+/**
+ * Visit every rich-text run of a slide that can carry a citation (text, bullets and list item runs),
+ * in reading order: promoted regions (sorted keys), then blocks (recursively), then the root payload.
+ * `basePath` is the slide's dotted path (`slides.3`).
+ */
+declare function walkCitationRuns(slide: unknown, basePath: string, visit: (entry: AnnotatedRun) => void): void;
+/** One numbered note: a cited reference (by id) or an inline footnote. */
+interface CitationNote {
+    number: number;
+    kind: 'reference' | 'footnote';
+    /** Reference id for `kind: 'reference'`. */
+    id?: string;
+    /** Note text: the reference text (its id when the references list does not resolve it) or the footnote. */
+    text: RichText;
+    /** `references.N` for a reference, the marked run's path for a footnote. */
+    sourcePath: string;
+    url?: string;
+    /** False when a cited id has no references entry. */
+    resolved: boolean;
+}
+/** A marked run on a slide and the numbers its marker shows. */
+interface CitationMarker {
+    path: string;
+    numbers: number[];
+    text: string;
+}
+interface SlideCitations {
+    /** Marker text by run path, in reading order. */
+    markers: Map<string, string>;
+    /** Every marked run on the slide, in reading order. */
+    marked: CitationMarker[];
+    /** The notes the slide's markers use, in number order (each number once). */
+    notes: CitationNote[];
+}
+interface DeckCitations {
+    /** Every note of the deck in number order. */
+    notes: CitationNote[];
+    /** Cited references in number order (inline footnotes excluded). */
+    references: CitationNote[];
+    /** Per slide index. Slides without markers are absent. */
+    slides: Map<number, SlideCitations>;
+    /** Reference ids no run cites, in references order. */
+    unused: string[];
+}
+/** Marker text for a set of numbers: `1`, or `1,2` for several ids. */
+declare const citationMarkerText: (numbers: readonly number[]) => string;
+/**
+ * Number every marker of a deck in reading order. Slides are read from `presentation.slides`; a
+ * hidden slide still takes part so numbers do not change when it is shown.
+ */
+declare function collectCitations(presentation: unknown): DeckCitations;
+/**
+ * Citations of one slide with the deck's numbering: the markers of `presentation.slides[0..slideIndex-1]`
+ * are counted first, then the runs of `slide` itself (which may be a paginated page or a copy of the
+ * document's slide). Without a presentation the slide's own markers start at 1 and reference texts
+ * cannot be resolved (`resolved: false`).
+ */
+declare function slideCitations(slide: unknown, slideIndex: number, presentation?: unknown): SlideCitations | undefined;
+/** Fits a string or TextRun[] into a box at a requested size (composeSlide supplies its placed fitter). */
+type AnnotationFitter = (value: RichText, box: LayoutBox, requestedSize: number, minFontSize: number, path: string, alignment: CaptionAlignment) => TextFit | RichTextFit;
+interface AnnotationLayoutOptions {
+    scale: number;
+    minFontSize: number;
+    fit: AnnotationFitter;
+    textStyle: (path: string) => TextStyle;
+}
+/** A composed caption band inside a block region. */
+interface ComposedCaption {
+    /** Dotted path of the caption field (`slides.0.blocks.1.caption`). */
+    path: string;
+    value: Caption;
+    text: RichText;
+    position: CaptionPosition;
+    alignment: CaptionAlignment;
+    /** The caption band. */
+    box: LayoutBox;
+    /** The media box after the band is reserved; `ComposedItem.box` equals it. */
+    mediaBox: LayoutBox;
+    fit: TextFit | RichTextFit;
+    textStyle: TextStyle;
+    fontSize: number;
+    overflow: boolean;
+    diagnostics: LayoutDiagnostic[];
+}
+/** Reserve a caption band in `box` (the payload box) and return the band and the media box. */
+declare function layoutCaption(value: unknown, box: LayoutBox, path: string, options: AnnotationLayoutOptions): ComposedCaption | undefined;
+/** One listed note in a slide's footnote area. */
+interface ComposedFootnoteEntry {
+    number: number;
+    kind: 'reference' | 'footnote';
+    id?: string;
+    /** `references.N` or the marked run's path. */
+    sourcePath: string;
+    /** The listed value: `<n> <text>` as a string, or runs starting with the number. */
+    value: RichText;
+    text: RichText;
+    box: LayoutBox;
+    fit: TextFit | RichTextFit;
+    textStyle: TextStyle;
+    url?: string;
+    overflow: boolean;
+}
+/** The footnote area of a slide: a rule, then the slide's notes in number order. */
+interface ComposedFootnotes {
+    algorithm: 'footnote-area-v1';
+    /** Dotted slide path (`slides.3`). */
+    path: string;
+    box: LayoutBox;
+    /** Thin rule along the top of the area. */
+    rule: {
+        x: number;
+        y: number;
+        width: number;
+        thickness: number;
+    };
+    entries: ComposedFootnoteEntry[];
+    /** Marked runs of the slide with their marker text. */
+    markers: CitationMarker[];
+    fontSize: number;
+    overflow: boolean;
+    diagnostics: LayoutDiagnostic[];
+}
+interface FootnoteLayoutOptions extends AnnotationLayoutOptions {
+    /** Left edge and width of the content area. */
+    x: number;
+    width: number;
+    /** The area's bottom edge (the top of the footer band gap). */
+    bottom: number;
+    /** Largest height the area may take. */
+    maxHeight: number;
+    /** Slide path for the area (`slides.3`). */
+    path: string;
+}
+/** List a slide's notes in a footnote area whose bottom sits at `options.bottom`. */
+declare function layoutFootnotes(citations: SlideCitations, options: FootnoteLayoutOptions): ComposedFootnotes;
+interface ReferencesSlideOptions {
+    title?: string;
+}
+/**
+ * An ordinary list slide of the deck's cited references in marker order (`n. text`, linked to the
+ * reference url when there is one). Inline footnotes are not listed. A deck that cites nothing gets
+ * a slide with the title only.
+ */
+declare function referencesSlide(presentation: unknown, options?: ReferencesSlideOptions): Record<string, unknown>;
+
+/** The chart constructs the engines draw. Every catalog chart type id resolves to one (see `chartOptionTarget`). */
+type ChartOptionKind = 'bar' | 'line' | 'area' | 'pie' | 'doughnut' | 'scatter' | 'radar' | 'treemap' | 'histogram' | 'pareto' | 'box' | 'waterfall' | 'funnel' | 'map';
+interface ChartOptionTarget {
+    kind: ChartOptionKind;
+    /** Stacked and 100% stacked columns, bars, lines and areas: their data labels have no outside-end position. */
+    stacked?: boolean;
+}
+type ChartLegendPosition = 'none' | 'top' | 'bottom' | 'left' | 'right';
+type ChartLabelContent = 'category' | 'value' | 'percent';
+type ChartLabelPosition = 'center' | 'inside-end' | 'inside-base' | 'outside-end' | 'above' | 'below' | 'left' | 'right';
+interface ChartOptionDiagnostic {
+    code: 'chart-option-adapted';
+    /** The option that was adapted: `axisTitles.category`, `axisTitles.value`, `legend`, `dataLabels`, `dataLabels.content`, `dataLabels.position` or `dataLabels.separator`. */
+    option: string;
+    reason: 'unsupported-type' | 'unsupported-content' | 'unsupported-position';
+    message: string;
+}
+interface ResolvedChartDataLabels {
+    /** Canonical order: category, value, percent. Never empty. */
+    content: ChartLabelContent[];
+    /** The concrete position, or null for a construct whose labels have no position choice (area, doughnut, radar, treemap). */
+    position: ChartLabelPosition | null;
+    separator: string;
+}
+interface ResolvedChartOptions {
+    /** True when the chart carries at least one option (after adaptation); false means every engine keeps today's output. */
+    active: boolean;
+    axisTitles: {
+        category?: string;
+        value?: string;
+    };
+    /** Undefined = no legend option: each engine keeps its default (a right legend on multi-series, pie and doughnut charts). */
+    legend?: ChartLegendPosition;
+    dataLabels?: ResolvedChartDataLabels;
+    /** True when `dataLabels: false` switches off the labels a construct draws by default (funnel values, treemap category names). */
+    dataLabelsOff?: boolean;
+    diagnostics: ChartOptionDiagnostic[];
+}
+interface ChartOptionSupport {
+    axisTitles: {
+        category: boolean;
+        value: boolean;
+    };
+    legend: boolean;
+    dataLabels: {
+        supported: boolean;
+        content: readonly ChartLabelContent[];
+        /** Empty when labels have no position choice. */
+        positions: readonly ChartLabelPosition[];
+        /** The position `auto` resolves to; null with no positions. */
+        defaultPosition: ChartLabelPosition | null;
+        /** True for the constructs that label their marks by default (funnel, treemap): `dataLabels: false` removes those labels. */
+        defaultOn: boolean;
+    };
+}
+/** What a chart construct can show. The table the docs, the validator, the preview and the exporter all follow. */
+declare function chartOptionSupport(target: ChartOptionTarget): ChartOptionSupport;
+/** The option target for a catalog chart type id (deprecated ids resolve to their replacement); undefined for an id outside the catalog. */
+declare function chartOptionTarget(typeId: unknown): ChartOptionTarget | undefined;
+declare const DEFAULT_CHART_LABEL_SEPARATOR = ", ";
+/**
+ * Normalise a chart's `axisTitles`, `legend` and `dataLabels` against what its type can show. `target` is undefined for a chart type
+ * outside the catalog: nothing is adapted then (the engines fall back to their legacy output for such charts anyway).
+ */
+declare function resolveChartOptions(chart: unknown, target?: ChartOptionTarget): ResolvedChartOptions;
+/** A General-format number as a label: at most twelve significant digits, no exponent unless the value needs one. */
+declare function formatChartLabelNumber(value: number): string;
+/** A share as PowerPoint's `0%` label. */
+declare function formatChartLabelPercent(share: number): string;
+/** The label text: the selected parts in the fixed order category, value, percent, joined by the separator. */
+declare function chartLabelText(parts: {
+    category?: string;
+    value?: string;
+    percent?: string;
+}, content: readonly ChartLabelContent[], separator?: 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" | "numbering-adapted";
+    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;
+}
+/** Role families. `accent` is present only when the scheme defines an accent role; the slide tag and quote body use it. */
+interface FontFamilies {
+    heading: string;
+    body: string;
+    code: string;
+    accent?: 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.
+ * `accent` is returned only when the scheme defines an `accent` role (a family string or Font object);
+ * the slide tag and the quote body use it in place of the body and heading families. */
+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;
+    /** Physical alignment this line was placed with. Present only in a right-to-left deck, where `left` and `right` are logical start and end. */
+    alignment?: PhysicalAlignment;
+}
+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;
+    /**
+     * Base direction of the paragraph each line belongs to, in line order. Present only when the fit was
+     * made for a right-to-left deck; every wrapped line shares its paragraph's direction (RR-05).
+     */
+    directions?: TextDirection[];
+}
+/** 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, directions?: readonly TextDirection[]): 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;
+    /**
+     * Picture bullet for `items`/`bullets` payloads when the effective `design.listBullet` is `image`
+     * and the deck's icon logo resolves. Every entry marker in `text.listEntries` carries the same value.
+     */
+    bulletImage?: ListBulletImage;
+    /**
+     * Caption band of an image, chart, table or video payload that carries `caption` (RR-34). `box` is
+     * the media box after the band is reserved; `caption.box` is the band inside the same region.
+     */
+    caption?: ComposedCaption;
+    /** 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;
+}
+/** Which logo variant family a consumer asks for: the full lockup, a square mark, or a stacked lockup. */
+type LogoSlot = 'lockup' | 'icon' | 'stacked';
+/** A logo asset chosen by resolveLogo, with its source value, OPF path, LogoSet variant key and the slot it serves. */
+interface ResolvedLogo {
+    source: unknown;
+    path: string;
+    variant: string;
+    slot: LogoSlot;
+}
+/**
+ * The deck logo drawn on a cover or section slide, at the top-left of the free area and above the
+ * centered heading group. Consumers fit the image inside `box` preserving its aspect ratio,
+ * anchored left and vertically centered; content slides never carry one.
+ */
+interface ComposedLogo {
+    box: LayoutBox;
+    slot: 'lockup';
+    path: string;
+    source: unknown;
+    variant: string;
+    anchor: 'left' | 'right';
+}
+/** Picture bullet source for list markers: the deck's icon logo and the OPF path it was read from. */
+interface ListBulletImage {
+    source: unknown;
+    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';
+    /** `chart-primary`: the root split a primary chart from a synthetic container of the other nodes (design.chartPrimary). */
+    reason: 'lowest-score' | 'configured-mode' | 'promoted-regions' | 'chart-primary';
+    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;
+    /** Deck logo on a cover or section slide; absent on content slides and when no logo resolves. */
+    logo?: ComposedLogo;
+    /**
+     * Footnote area of a slide whose runs cite references or carry footnotes (RR-34): directly above the
+     * footer band, the content area is shrunk by exactly its height. Absent on slides without markers.
+     */
+    footnotes?: ComposedFootnotes;
+    /** `rtl` when the slide was composed for a right-to-left deck (mirrored arrangement); absent for left-to-right decks. */
+    direction?: 'rtl';
+    explanation?: CompositionExplanation;
+}
+interface ComposeSlideOptions {
+    /** Context for inherited furniture, generated organization names, social profiles, logos, layout hints, references and marker numbering. */
+    presentation?: {
+        language?: unknown;
+        design?: {
+            header?: unknown;
+            footer?: unknown;
+            slideImage?: unknown;
+            imageFill?: unknown;
+            logo?: unknown;
+            contentDirection?: unknown;
+            chartPrimary?: unknown;
+            listBullet?: unknown;
+        };
+        organization?: unknown;
+        slides?: unknown;
+        catalogs?: unknown;
+        references?: unknown;
+    };
+    /**
+     * Whether the slide background is dark, by the host's own luminance test. Selects the light logo
+     * variants (cover logo, furniture `logo: true`, picture bullets). Core never inspects colors.
+     */
+    darkBackground?: boolean;
+    /**
+     * 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>;
+    /**
+     * Deck base direction (RR-05). Defaults to the direction of the presentation language's script. In a right-to-left deck
+     * composition mirrors the arrangement (the first column or `left` region is drawn at the right, slide images, logos and
+     * header/footer zones swap sides, tables run right to left), lists put their markers at the right, and every text fit
+     * reports each paragraph's direction. Alignment stays logical: `left` is the start edge.
+     */
+    direction?: TextDirection;
+    /** 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 ResolveLogoOptions {
+    /** Variant family to prefer; defaults to the full lockup. */
+    slot?: LogoSlot;
+    /** True on a dark background (host luminance test): light variants are preferred, dark ones come last. */
+    onDark?: boolean;
+    /** Index used in the `slides.N.design.logo` path of a slide-level logo; defaults to 0. */
+    slideIndex?: number;
+}
+/**
+ * Resolve the logo a slide should draw, the same way in every engine. Source precedence:
+ * `slides[i].design.logo`, then `design.logo`, then the primary organization's `logo` (`role: 'primary'`,
+ * else the first organization; `organization` may be an object or an array). Absence inherits; a source
+ * that yields no usable asset falls through to the next. A string or Asset object is the `default`
+ * variant. A LogoSet picks by slot and tone: `icon` tries iconLight/iconDark (tone), then icon, then the
+ * lockup chain; `stacked` tries stackedLight/stackedDark (tone), then stacked, then the lockup chain; the
+ * lockup chain prefers same-tone variants, then neutral ones, then the opposite tone. `path` is the OPF
+ * path of the chosen value (`design.logo`, `design.logo.light`, `organization.2.logo`,
+ * `slides.3.design.logo.icon`) and `variant` the LogoSet key or `default`. Returns null without a logo.
+ */
+declare function resolveLogo(presentation: unknown, slide: unknown, options?: ResolveLogoOptions): ResolvedLogo | null;
+interface FurniturePartBase {
+    kind: 'header' | 'footer';
+    zone: 'left' | 'center' | 'right';
+    field: 'text' | 'image' | 'logo' | '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, direction?: TextDirection): SourceTextFit;
+/**
+ * PowerPoint stores a run size (`sz`) in hundredths of a point, and composition pixels are CSS pixels (96 per
+ * inch, so a point is 4/3 px). Every composed font size is therefore a whole multiple of 0.01 pt, which is
+ * 1/75 px: the preview then measures, breaks and draws exactly the size the export writes (RR-16).
+ * The tolerance absorbs binary rounding noise (a size already on the grid must not drop a step).
+ */
+declare const FONT_SIZE_GRID_PER_PX = 75;
+/** Largest grid size not above `px`. Rounding down keeps a size that fit before snapping fitting. */
+declare function snapFontSizeDown(px: number): number;
+/** Smallest grid size not below `px`. Used for readability floors, so a floor is never undercut. */
+declare function snapFontSizeUp(px: number): number;
+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;
+    /** Deck direction; in a right-to-left deck every part fit reports its paragraphs' directions (RR-05). */
+    direction?: TextDirection;
+}
+/**
+ * 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 here: the trend stays its word, and metricTrendMark derives the arrow
+ * beside it from these accepted parts. 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;
+    /** Logical alignment: `left` is the start edge, which a right-to-left line draws at the right (see `fit.directions`). */
+    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;
+    /** RR-34: reference ids this run cites (a marker follows the run; the deck's `references` list resolves them). */
+    cite?: string | string[];
+    /** RR-34: an inline footnote for this run (a marker follows the run; the note is listed in the slide's footnote area). */
+    footnote?: string | (string | RichTextRun)[];
+}
+interface RichTextFragment {
+    /**
+     * Tabs are source-preserving layout controls with a fixed advance, not glyph text. A marker is the
+     * superscript citation/footnote number drawn after a run that cites or carries a footnote (RR-34): it
+     * has no source range (`start === end === run.text.length`), so run indexes and offsets never shift.
+     */
+    kind?: 'tab' | 'marker';
+    text: string;
+    runIndex: number;
+    start: number;
+    end: number;
+    x: number;
+    width: number;
+    fontSize: number;
+    baselineShift: number;
+    /** A marker only: the size the exporter writes (the marked run's size); `fontSize` is the glyph PowerPoint draws for it (2/3). */
+    nominalSize?: 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;
+    /** Deck direction. In a right-to-left deck every line reports its paragraph's direction in `directions`. */
+    direction?: TextDirection;
+    /**
+     * Marker text (`1`, `1,2`) for a run by its dotted path (`${style.path}.${runIndex}`), or undefined.
+     * composeSlide supplies the deck numbering from `slideCitations`; a marker fragment is emitted after the run.
+     */
+    citationMarker?: (runPath: string) => string | undefined;
+}
+/** 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;
+    start?: number;
+};
+interface ListEntryLayout {
+    index: number;
+    level: number;
+    textPath?: string;
+    descriptionPath?: string;
+    value: ListText;
+    descriptionValue?: ListText;
+    text: RichTextFit;
+    description?: RichTextFit;
+    textBox: LayoutBox;
+    descriptionBox?: LayoutBox;
+    /**
+     * `x` is the marker's left edge, or its right edge when `anchor` is `end` (a right-to-left entry, whose marker sits at the right and
+     * whose text box is the column to its left).
+     * The entry marker: the bullet glyph, or for a numbered list (`numbering`) the formatted number such as `iv.`.
+     * A numbered marker also carries `number` and its measured `width`; its `style` is the list style with the weight and
+     * slant of the entry's first run, as PowerPoint draws an auto-number in the first run's character formatting.
+     */
+    marker: {
+        text: string;
+        x: number;
+        y: number;
+        fontSize: number;
+        style: TextStyle;
+        indent: number;
+        number?: ListNumber;
+        width?: number;
+        anchor?: 'end';
+    };
+    /** Paragraph direction of this entry. Present only when the list was fitted for a right-to-left deck. */
+    direction?: TextDirection;
+    /** Picture bullet replacing the marker glyph; drawn in `bulletBox`. Marker geometry is unchanged. */
+    bulletImage?: ListBulletImage;
+    /**
+     * Where the picture bullet draws: a square of side `marker.fontSize * PICTURE_BULLET_SCALE` whose
+     * bottom sits on the marker baseline (`marker.y`) and whose left edge is `marker.x` (right edge when `marker.anchor` is `end`).
+     * Present with `bulletImage`.
+     */
+    bulletBox?: LayoutBox;
+}
+/**
+ * Side of a picture bullet as a fraction of the list font size. Desktop PowerPoint sizes an `a:buBlip` at
+ * `a:buSzPct 100000` (what opf-pptx writes) as a square about 0.65 times the run's font size, bottom on the
+ * text baseline and left at the bullet position, in every typeface: measured widths of 10, 15, 16, 20 and 31
+ * pixels at font sizes of 16, 24, 25, 32 and 48 pixels (0.625 to 0.646; heights run about a pixel more from
+ * anti-aliasing, so the true side is about 0.65). The export needs no size: PowerPoint sizes the bullet itself.
+ */
+declare const PICTURE_BULLET_SCALE = 0.65;
+interface ListFit extends TextFit {
+    listEntries: ListEntryLayout[];
+    height: number;
+}
+interface ListFitOptions extends RichTextOptions {
+    /**
+     * Number the entries instead of bulleting them (the payload's `numbering` field). The hanging indent becomes the larger of
+     * 1.1 em and the widest marker plus 0.3 em, so wide markers never touch their text; unnumbered lists are unchanged.
+     */
+    numbering?: NumberingInput;
+    /** Picture bullet for every entry (effective `design.listBullet: "image"` with a resolved icon logo). */
+    bulletImage?: ListBulletImage;
+}
+/** 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?: ListFitOptions): ListFit;
+interface TableLayoutOptions {
+    scale?: number;
+    minFontSize?: number;
+    fontFamily?: string;
+    textMeasurement?: TextMeasurement;
+    path?: string;
+    /**
+     * Deck direction. A right-to-left deck lays the columns out right to left: the first column is the rightmost
+     * and each cell's text reports its paragraph direction (RR-05).
+     */
+    direction?: TextDirection;
+}
+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;
+    /** Paragraph direction of the cell text; present only in a right-to-left deck. */
+    direction?: TextDirection;
+}
+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 { DEFAULT_FURNITURE_DATE_FORMAT as $, type AnnotatedRun as A, type CodeLayoutOptions as B, type ComposeSlideOptions as C, type CodeLineSegment as D, type CodeLineSource as E, type FontSchemeDiagnostic as F, type CodeTextFit as G, type CodeTextPart as H, type ComposedCaption as I, type ComposedFlow as J, type ComposedFootnoteEntry as K, type LayoutDiagnostic as L, type MetricLayout as M, type ComposedFootnotes as N, type ComposedGroup as O, type ComposedItem as P, type ComposedLogo as Q, type ComposedSlideImage as R, type Composition as S, type TextMeasurement as T, type CompositionCandidate as U, type CompositionDecision as V, type CompositionExplanation as W, type CompositionPenalties as X, type CompositionTrack as Y, DEFAULT_CHART_LABEL_SEPARATOR as Z, DEFAULT_FONT_SCHEME as _, type AnnotationFitter as a, type RichTextRun as a$, DEFAULT_SLIDE_NUMBER_FORMAT as a0, type DeckCitations as a1, FONT_SIZE_GRID_PER_PX as a2, FOOTNOTE_MAX_RATIO as a3, type FontFamilies as a4, type FootnoteLayoutOptions as a5, type FurnitureField as a6, type FurnitureImagePart as a7, type FurnitureLayout as a8, type FurniturePart as a9, type NumberingInput as aA, type NumberingStyleName as aB, type NumberingSuffix as aC, OPFCompositionError as aD, PICTURE_BULLET_SCALE as aE, type PhysicalAlignment as aF, type QuoteContent as aG, type QuoteLayout as aH, type QuoteLayoutDiagnostic as aI, type QuoteLayoutOptions as aJ, type QuoteTextPart as aK, type QuoteTextSource as aL, type Reference as aM, type ReferencesSlideOptions as aN, type ResolveColorRefOptions as aO, type ResolveColorRefRoles as aP, type ResolveLogoOptions as aQ, type ResolvedChartDataLabels as aR, type ResolvedChartOptions as aS, type ResolvedFontScheme as aT, type ResolvedLogo as aU, type ResolvedNumbering as aV, type RichText as aW, type RichTextFit as aX, type RichTextFragment as aY, type RichTextLine as aZ, type RichTextOptions as a_, type FurniturePartBase as aa, type FurnitureSocialLink as ab, type FurnitureTextExtras as ac, type FurnitureTextPart as ad, type LayoutBox as ae, type ListBulletImage as af, type ListEntryLayout as ag, type ListFit as ah, type ListFitOptions as ai, type ListNumber as aj, type ListText as ak, type ListValue as al, type LogoSlot as am, MAX_COMPOSITION_DEPTH as an, MAX_NUMBERING_LEVELS as ao, MAX_NUMBERING_VALUE as ap, MAX_ROMAN_VALUE as aq, type MeasureTextWidth as ar, type MetricContent as as, type MetricLayoutDiagnostic as at, type MetricLayoutOptions as au, type MetricTextPart as av, type MetricTextSource as aw, NUMBERING_STYLES as ax, NUMBERING_SUFFIXES as ay, type Numbering as az, type AnnotationLayoutOptions as b, sliceNumberedItems as b$, type SlideCitations as b0, type SlideComposition as b1, type SlideImageShape as b2, type SocialPlatformRecord as b3, type SocialProfile as b4, type TextDirection as b5, type TextFit as b6, type TextLineInk as b7, type TextPlacement as b8, type TextPlacementLine as b9, layoutCaption as bA, layoutCode as bB, layoutFootnotes as bC, layoutFurniture as bD, layoutMetric as bE, layoutQuote as bF, layoutTimeline as bG, listNumbers as bH, measureText as bI, measureTextOutline as bJ, normalizeHexColor as bK, numberingAtLevel as bL, numberingStyleDraws as bM, paragraphDirection as bN, paragraphDirectionAt as bO, physicalAlignment as bP, placeTextLines as bQ, referencesSlide as bR, resolveCanvasDimensions as bS, resolveChartOptions as bT, resolveColorRef as bU, resolveFontFamilies as bV, resolveFontSchemeReference as bW, resolveLogo as bX, resolveNumbering as bY, resolveSocialProfile as bZ, resolveTextStyle as b_, type TextStyle as ba, type TimelineContent as bb, type TimelineEvent as bc, type TimelineLayout as bd, type TimelineLayoutDiagnostic as be, type TimelineLayoutOptions as bf, type TimelineTextPart as bg, annotationText as bh, captionSettings as bi, chartColorForFill as bj, chartLabelText as bk, chartOptionSupport as bl, chartOptionTarget as bm, chartPaletteForFill as bn, citationMarkerText as bo, collectCitations as bp, colorContrast as bq, composeSlide as br, fitList as bs, fitRichText as bt, fitText as bu, formatChartLabelNumber as bv, formatChartLabelPercent as bw, formatFurnitureDate as bx, formatListNumber as by, formatSlideNumber as bz, CAPTIONABLE_FIELDS as c, slideCitations as c0, snapFontSizeDown as c1, snapFontSizeUp as c2, textColorForFill as c3, textWidthMeasurer as c4, walkCitationRuns as c5, wrapText as c6, type FontFaceSelection as c7, type ReadingBox as c8, type SourceTextFit as c9, type TableBorder as ca, type TableCellLayout as cb, type TableCellStyle as cc, type TableGrid as cd, type TableGridCell as ce, type TableGridIssue as cf, type TableLayout as cg, type TableLayoutOptions as ch, type TableRowLayout as ci, type TextLineSegment as cj, type TextLineSource as ck, layoutTable as cl, slideImageShape as cm, tableGrid as cn, tableRowBoundaries as co, visualReadingOrder as cp, CAPTION_FONT_RATIO as d, CAPTION_MAX_RATIO as e, CHART_SERIES_MIN_DIFFERENCE as f, CHART_SERIES_MIN_LIGHTNESS_STEP as g, CITATION_MARKER_RAISE as h, CITATION_MARKER_SCALE as i, type Caption as j, type CaptionAlignment as k, type CaptionObject as l, type CaptionPosition as m, type CaptionSettings as n, type ChartLabelContent as o, type ChartLabelPosition as p, type ChartLegendPosition as q, type ChartOptionDiagnostic as r, type ChartOptionKind as s, type ChartOptionSupport as t, type ChartOptionTarget as u, type CitationMarker as v, type CitationNote as w, type CodeContent as x, type CodeLayout as y, type CodeLayoutDiagnostic as z };