import type { VDTDocument, RenderWarning } from './vdt.js';
import { type SvgFontSyncProvider } from './svg/fonts.js';
import { type ExerciseData } from './exercises/digital.js';
export interface RenderHtmlOptions {
    /** Layout mode: single vertical column or many columns laid out horizontally. */
    mode?: 'single' | 'multi';
    /** Horizontal gap between pages/columns in multi mode. Default: 24 */
    columnGap?: number;
    /** Outer padding around the document. Default: 24 */
    padding?: number;
    /** Background color for each page (overrides config). */
    background?: string;
    /** Resolver from a resource `fileId` to a displayable image URL (object
     *  URL, data URI, …). Image payloads live out-of-band (IndexedDB in the
     *  sandbox), so the host supplies them. When omitted, or when it returns
     *  undefined for a fileId, bitmap/SVG resources render as a neutral
     *  placeholder box so layout stays stable. */
    resourceImageUrl?: ((fileId: string) => string | undefined) & {
        /** The default of {@link RenderHtmlOptions.singleInk} for this
         *  resolver's URLs: `false` on one whose SVG URLs are already recoloured
         *  for single ink (`bundleImageUrl` does), `true` on one that serves the
         *  raw markup. */
        singleInk?: boolean;
    };
    /** Whether `diagramStyle.singleInk` recolours SVG pictures here: each
     *  SVG `<img>` gets a CSS filter (an `feColorMatrix` on its page) that
     *  maps its pixels to tints of the document's ink — the mapping
     *  `applySingleInkToSvg` applies to the markup, and the PDF backend to
     *  SVG bytes. Bitmaps are never tinted, and neither is an SVG data URI
     *  whose markup `applySingleInkToSvg` marked. (A design image of a VDT built
     *  before design images carried `imageKind` is tinted when its URL is an
     *  SVG data URI or ends in `.svg`.) Every page then carries the filter
     *  definition. Defaults to the resolver's own `singleInk`, else false in
     *  postext 1.x: hosts written for 1.4 serve SVGs recoloured with
     *  `applySingleInkToSvg`, as the Sandbox does, and a picture tinted twice
     *  comes out lighter. Pass `true` when `resourceImageUrl` returns the raw
     *  markup. The next major release turns it on by default. */
    singleInk?: boolean;
    /** Resolver from a self-hosted video's `fileId` to a playable URL (an
     *  object URL, the file's address in a package…). When it is omitted or
     *  returns nothing, the video plays from its production address
     *  (`video.url`); with neither, the poster is shown. */
    resourceVideoUrl?: (fileId: string) => string | undefined;
    /** What a video resource is set as (#454): its player, or the printed
     *  poster with its play mark and QR code (linked to the video when
     *  `videoStyle.linkPoster`). `files` covers self-hosted videos, `streams`
     *  YouTube and Vimeo, `hls` a self-hosted video played from an HLS
     *  address (#476; default: as `files`). Each defaults to
     *  `videoStyle.html`. An HLS `<video>` carries `data-pt-hls`: Safari
     *  plays it natively, other browsers need the host to attach a player
     *  such as hls.js (see `attachHls` in the Sandbox). */
    videos?: {
        files?: 'player' | 'poster';
        streams?: 'player' | 'poster';
        hls?: 'player' | 'poster';
    };
    /** Told of what the render could not produce as asked: an image with no
     *  URL (no `resourceImageUrl`, or one that returns nothing for its
     *  `fileId`) is emitted as a placeholder and reported once per `fileId`
     *  and render call, as a `missingImage` warning. */
    onWarning?: (warning: RenderWarning) => void;
    /** Resources anchored elsewhere on the page that shows this document's
     *  HTML (`id="pt-res-<id>"`). A `:ref` links to its resource's anchor
     *  when this document places that resource or the id is listed here;
     *  otherwise it is set as plain text in its link colour, since nothing on
     *  the page would take the link. A host that joins several documents'
     *  HTML on one page — a book's chapters, each rendered on its own — lists
     *  the resources all of them place ({@link anchoredResourceIds}), so a
     *  reference to a figure an earlier chapter placed links to it. */
    refTargets?: Iterable<string>;
    /** Embed the document's fonts in the SVG pictures `resourceImageUrl`
     *  serves as `data:image/svg+xml` URIs (#630): the faces their text
     *  names, as `@font-face` data URIs, so an `<img>` sets the labels in
     *  them. `true` takes the faces held in memory by the registry
     *  (`registerFontBytes`, `loadBundleFonts`); an object names another
     *  provider, the size cap per SVG and families to leave out. Skipped
     *  under `diagramStyle.inlineFonts: false` and for a resource with
     *  `svg.inlineFonts: false`. A family with no face is reported as
     *  `svgFontUnavailable`, the cap as `svgFontsTooLarge`. Default off
     *  (object URLs cannot be read synchronously; `bundleImageUrl` inlines
     *  on its own). */
    inlineSvgFonts?: boolean | {
        fonts?: SvgFontSyncProvider;
        maxBytes?: number;
        withhold?: (family: string) => boolean;
        /** The open family set under the name of a family `withhold` names
         *  (#993): see `InlineSvgFontsOptions.standIn`. */
        standIn?: (family: string) => string | undefined;
    };
}
/**
 * The resources this document anchors in its HTML (`id="pt-res-<id>"`):
 * those whose embed (a first slice, for a split table) is on one of its
 * pages. A host that renders a book's chapters one by one onto a single page
 * passes the union over the chapters as `RenderHtmlOptions.refTargets`:
 *
 * ```ts
 * const docs = buildBundle(bundle);
 * const refTargets = new Set(docs.flatMap((d) => [...anchoredResourceIds(d)]));
 * const html = docs.map((d) => renderToHtml(d, { refTargets })).join('');
 * ```
 */
export declare function anchoredResourceIds(doc: VDTDocument): Set<string>;
export interface HtmlRenderIndexPage {
    index: number;
    width: number;
    height: number;
    innerHtml: string;
    blocks: Array<{
        id: string;
        html: string;
    }>;
    /** Non-block markup (opener band, header, footer); see `PageRenderResult`. */
    decorationHtml: string;
    /** A comic page's markup (`page.comic`): its panels and lettering, laid
     *  over the page box; part of `innerHtml` (and of `decorationHtml`). */
    comicHtml?: string;
}
export interface HtmlRenderIndex {
    html: string;
    mode: 'single' | 'multi';
    pages: HtmlRenderIndexPage[];
    /** The document's exercises for the exercise script (#1230), as `html`
     *  writes them in its `<script class="pt-exercises">`: a host that
     *  patches the pages instead of setting `html` hands them to
     *  `attachExercises` itself. Absent when it has none. */
    exercises?: ExerciseData;
}
/**
 * CSS declarations (a `prop:value;` list) that reset the inherited text
 * properties to the values the engine measured with. Every line of the
 * output is positioned at the widths the canvas measured, so a host that
 * sets `letter-spacing`, `word-spacing`, `text-transform`, a `font-variant`
 * or a `line-height` on an ancestor would otherwise widen or change the
 * glyph runs and make lines overprint. The `.pt-doc` root carries them
 * before its own layout declarations; a host that mounts the pages'
 * `innerHtml` in containers of its own sets them on its root. The root of
 * a right-to-left document (`ResolvedConfig.direction`) sets
 * `direction:rtl` in their place, and `dir="rtl"`: such a host does the
 * same (#379).
 */
export declare const HTML_TEXT_RESET: string;
/**
 * Like renderToHtml, but also returns a per-page / per-block breakdown that
 * callers can use to diff against a previous render and patch only the DOM
 * subtrees whose HTML actually changed.
 */
export declare function renderToHtmlIndexed(doc: VDTDocument, options?: RenderHtmlOptions): HtmlRenderIndex;
export declare function renderToHtml(doc: VDTDocument, options?: RenderHtmlOptions): string;
//# sourceMappingURL=html-backend.d.ts.map