@asterdoc/render 0.0.0-stage → 0.9.0

package/dist/pdf.d.ts

@@ -0,0 +1,620 @@
+import { BinaryContent, Form, Formatter, LayerFormat, AsterdocRenderer, RendererLayer, LocateHit } from '@asterdoc/types';
+export { LocateHit } from '@asterdoc/types';
+import { P as PdfFont } from './layer-bindings-CFXyN7SM.js';
+export { a as PdfBindingKeyError, b as PdfBindingPart, c as PdfBindingSyntaxError, d as PdfFontError, e as PdfFontMetrics, F as PdfFontProblem, p as parseBinding, f as pdfFontMetrics } from './layer-bindings-CFXyN7SM.js';
+
+/** Why a value could not be drawn in its PDF form field or overlay. */
+type PdfFieldFillReason = 'overflow' | 'comb-length' | 'missing-glyph' | 'unsupported-script';
+/** What a {@link PdfFieldFillError} reports beyond the field and the reason. */
+interface PdfFieldFillDetail {
+    /** For `overflow`, the minimum font size in points; for `comb-length`, the number of comb boxes. */
+    limit?: number;
+    /** For `missing-glyph`, the character no available font can draw. */
+    character?: string;
+    /** For `unsupported-script`, the script that needs glyph shaping. */
+    script?: string;
+}
+/**
+ * Thrown when a value cannot be drawn faithfully in a PDF form field or a text
+ * overlay, naming the field and why.
+ */
+declare class PdfFieldFillError extends Error {
+    /** Fully qualified name of the PDF form field, or the overlay that failed. */
+    readonly field: string;
+    readonly reason: PdfFieldFillReason;
+    readonly limit?: number;
+    readonly character?: string;
+    readonly script?: string;
+    constructor(field: string, reason: PdfFieldFillReason, detail: PdfFieldFillDetail, message: string);
+}
+/** Smallest size a value shrinks to before filling fails with an overflow error. */
+declare const MIN_FONT_SIZE = 6;
+
+/**
+ * Thrown by every entry point that parses or writes a PDF when the file is
+ * encrypted.
+ *
+ * An encrypted file stores its strings and streams enciphered under a key
+ * derived from the file itself. Field names read as ciphertext, values written
+ * in plaintext would not decrypt, and copied streams would be garbage, so an
+ * encrypted file is refused rather than read wrongly.
+ */
+declare class PdfEncryptedError extends Error {
+    readonly code: "encrypted_pdf";
+    constructor();
+}
+
+/** What kind of control an AcroForm field is, read from its `/FT` and `/Ff`. */
+type PdfFieldType = 'text' | 'checkbox' | 'dropdown' | 'radio' | 'button' | 'signature' | 'unknown';
+
+interface PdfFieldInfo {
+    name: string;
+    type: PdfFieldType;
+    value?: string | boolean | string[];
+    required?: boolean;
+    page?: number;
+    rect?: [number, number, number, number];
+    maxLen?: number | null;
+}
+interface InspectOptions {
+    includeButton?: boolean;
+    includeSignature?: boolean;
+}
+interface PdfPageInfo {
+    /** One-based page number. */
+    page: number;
+    /** Page width in PDF points. */
+    width: number;
+    /** Page height in PDF points. */
+    height: number;
+}
+interface PdfInfo {
+    pageCount: number;
+    pages: PdfPageInfo[];
+}
+/** Inspect page count and dimensions without loading a full PDF toolkit. */
+declare function inspectPdf(template: BinaryContent): Promise<PdfInfo>;
+/** List the AcroForm fields a PDF declares, walked as fill walks them. */
+declare function inspectAcroFormFields(template: BinaryContent, options?: InspectOptions): Promise<PdfFieldInfo[]>;
+
+/**
+ * Burn AcroForm widget appearances into their pages and remove the interactive
+ * form controls. A widget a viewer does not show (Hidden or NoView) is removed
+ * without being drawn. PDFs without an AcroForm are returned unchanged.
+ */
+declare function flattenPdf(template: BinaryContent): Promise<Uint8Array>;
+
+/**
+ * One PDF from several, page for page.
+ *
+ * A packet is a sequence of documents a reader sees as one file, and one file
+ * is what a hash and a signature map describe. Merging is how the sequence
+ * becomes that file.
+ *
+ * The merge writes a fresh document rather than appending an incremental
+ * update, because two sources number their objects from one and an incremental
+ * update has no way to hold both. Every object a kept page can reach is copied
+ * with a new number, every reference inside it is rewritten to that number, and
+ * a new catalog and page tree are written over the result. Stream bytes are
+ * copied exactly as they were stored, filters and all, so nothing is
+ * re-encoded and nothing is re-rendered.
+ *
+ * **What a merge drops.** Everything the old catalog held rather than the page:
+ *
+ * - the interactive form (`AcroForm`), so flatten a filled form before merging
+ *   it and its values arrive as page content;
+ * - the structure tree (`StructTreeRoot`) and the role map, which is the
+ *   document's accessibility tagging. A copied page keeps its `StructParents`
+ *   key, which then points at a tree that is no longer there. A reader ignores
+ *   a dangling `StructParents`; a screen reader gets untagged pages;
+ * - the name tree (`Names`) and `Dests`, so a named destination no longer
+ *   resolves and a link that used one goes nowhere;
+ * - optional content (`OCProperties`), so a page drawn with layers loses the
+ *   configuration that decides which are visible, and every layer paints;
+ * - `Lang`, `ViewerPreferences`, `Outlines`, `PageLabels`, `Metadata` and
+ *   `PageMode`.
+ *
+ * A packet is assembled from documents that are already final, and none of
+ * those survive a print either, which is what makes the trade acceptable here.
+ * A caller who needs any of them should say so rather than merge.
+ */
+
+/** Thrown when a source cannot be merged, naming which one and why. */
+declare class PdfMergeError extends Error {
+    /** Zero-based position of the offending source in the input. */
+    readonly source: number;
+    constructor(source: number, detail: string);
+}
+/**
+ * Concatenate PDFs into one document, keeping every page in the order given.
+ *
+ * A single source is returned unchanged, so merging a one-part packet costs
+ * nothing and produces the bytes the part already had.
+ *
+ * @throws {PdfEncryptedError} when a source is encrypted.
+ * @throws {PdfMergeError} naming the source, when it has no catalog, no pages,
+ * or cannot be read at all.
+ */
+declare function mergePdfs(sources: readonly BinaryContent[]): Promise<Uint8Array>;
+
+/**
+ * A PDF holding some of another's pages.
+ *
+ * Selection writes a fresh document, not an incremental update: an update
+ * keeps the original bytes, so every dropped page, its content and its fields
+ * would still be in the file. The new document holds the catalog, a new page
+ * tree over the kept pages, and every object those reach. Dropped pages, the
+ * widgets that sit only on them, and form fields left with no widget are not
+ * carried; a reference to one from what is kept is dropped from a list and
+ * becomes `null` anywhere else.
+ */
+
+/** Return a PDF containing the requested one-based pages in source order. */
+declare function selectPdfPages(template: BinaryContent, requestedPages: readonly number[]): Promise<Uint8Array>;
+
+interface PdfOverlayBase {
+    /** One-based page number. */
+    page: number;
+    /** Horizontal position in PDF points from the bottom-left corner. */
+    x: number;
+    /** Vertical position in PDF points from the bottom-left corner. */
+    y: number;
+}
+type PdfTextOverlay = PdfOverlayBase & {
+    fontSize?: number;
+    /**
+     * Fit text inside this width, shrinking no smaller than 6 points. Text that
+     * still does not fit fails with an overflow error.
+     */
+    width?: number;
+    /** Vertically center text inside this height. */
+    height?: number;
+    /** RGB components in the range 0–1. */
+    color?: [number, number, number];
+    /**
+     * A font for this overlay alone, tried before the render's other fonts, so
+     * one render can draw text in more than one font (a bold heading, say).
+     */
+    font?: PdfFont;
+} & ({
+    text: string | number | boolean;
+    field?: never;
+} | {
+    field: string;
+    text?: never;
+});
+type PdfImageOverlay = PdfOverlayBase & {
+    image: Uint8Array;
+    mediaType: 'image/png' | 'image/jpeg';
+    width: number;
+    height: number;
+    fit?: 'contain' | 'fill';
+};
+type PdfOverlay = PdfTextOverlay | PdfImageOverlay;
+
+interface RenderPdfOptions {
+    template: BinaryContent;
+    form?: Form;
+    data: Record<string, unknown>;
+    bindings?: Record<string, string>;
+    formatter?: Formatter;
+    overlays?: PdfOverlay[];
+    /**
+     * A font supplied at render time. It is tried first for every text value,
+     * ahead of the layer's declared font.
+     */
+    font?: PdfFont;
+    /** The font the artifact's PDF layer declares, tried after `font`. */
+    layerFont?: PdfFont;
+    /**
+     * The presentation the artifact's PDF layer declares, applied over
+     * `formatter`. `{ money: { currencyDisplay: 'none' } }` prints amounts
+     * without a symbol beside a template's pre-printed one.
+     */
+    format?: LayerFormat;
+}
+declare function renderPdf({ template, form, data, bindings, formatter, overlays, font, layerFont, format, }: RenderPdfOptions): Promise<BinaryContent>;
+
+/**
+ * PDF signature fields: the file structure a digital signature lives in.
+ *
+ * A signature is an incremental update (ISO 32000-1, 12.8). The update adds a
+ * signature dictionary, a signature field whose widget sits on the first page
+ * and whose `/V` is that dictionary, and an AcroForm entry with `/SigFlags 3`.
+ * The dictionary's `/ByteRange` covers the whole file except the `/Contents`
+ * hex string, which holds the signature container.
+ *
+ * This module writes and reads that structure only. Producing and checking the
+ * container (CMS, keys, certificates) is the caller's work: prepare the field,
+ * sign the bytes its byte range covers, then embed the container.
+ */
+/** What a new signature dictionary says about the signature. */
+interface PdfSignatureOptions {
+    /** Bytes reserved for the signature container. The embedded container may be shorter, never longer. */
+    contentsSize: number;
+    /** The signing time, written as `/M`. */
+    signingTime: Date;
+    /** The signer's name, in any script (`/Name`). */
+    name?: string;
+    /** Why the document was signed (`/Reason`). */
+    reason?: string;
+    /** Where it was signed (`/Location`). */
+    location?: string;
+    /** How to reach the signer (`/ContactInfo`). */
+    contactInfo?: string;
+}
+/** A PDF with a signature field whose container is still empty. */
+interface PreparedPdfSignature {
+    /** The PDF, with `/ByteRange` written and `/Contents` zero-filled. */
+    bytes: Uint8Array;
+    /** `[0, gapStart, gapEnd, length - gapEnd]`: the two ranges the signature covers. */
+    byteRange: [number, number, number, number];
+}
+/** The newest signature in a PDF, read from its signature dictionary. */
+interface PdfSignatureRecord {
+    /** The signature container, including any zero padding after it. */
+    contents: Uint8Array;
+    /** The ranges the signature covers, as the dictionary states them. */
+    byteRange: [number, number, number, number];
+    /** The bytes `byteRange` covers, concatenated. */
+    signedBytes: Uint8Array;
+    /**
+     * True when the byte range starts at the first byte, ends at the last byte,
+     * and leaves out exactly this dictionary's `/Contents` hex string. False when
+     * any other byte is unsigned, such as an update appended after signing.
+     */
+    coversWholeFile: boolean;
+    name?: string;
+    reason?: string;
+    location?: string;
+    contactInfo?: string;
+    signingTime?: Date;
+}
+/**
+ * `pdf` with a new, empty signature field added as an incremental update.
+ *
+ * The field is invisible (a zero-size widget on the first page). Its byte range
+ * is final; sign `signedBytes(prepared)` and pass the container to
+ * `embedPdfSignature`.
+ */
+declare function preparePdfSignature(pdf: Uint8Array, options: PdfSignatureOptions): Promise<PreparedPdfSignature>;
+/** The bytes a prepared signature covers: what the signature container signs. */
+declare function signedBytes(prepared: PreparedPdfSignature): Uint8Array;
+/** The prepared PDF with `container` written into its `/Contents`. */
+declare function embedPdfSignature(prepared: PreparedPdfSignature, container: Uint8Array): Uint8Array;
+/**
+ * The newest signature in `pdf`: the signature dictionary whose byte range
+ * reaches furthest into the file. Every value comes from that dictionary, so
+ * other objects (an annotation's `/Contents`, a field's `/Name`) never stand in
+ * for it. Returns `undefined` when the file holds no signature.
+ */
+declare function readPdfSignature(pdf: Uint8Array): Promise<PdfSignatureRecord | undefined>;
+
+interface PdfRendererOptions {
+    formatter?: Formatter;
+    /**
+     * A font supplied at render time, such as a licensed corporate font. It is
+     * tried before the font the layer declares.
+     */
+    font?: PdfFont;
+}
+type PdfLayer = RendererLayer & {
+    type: 'pdf';
+    content: Uint8Array;
+};
+declare function pdfRenderer(options?: PdfRendererOptions): AsterdocRenderer<PdfLayer, Uint8Array>;
+
+declare const FieldType: {
+    readonly SIGNATURE: 0;
+    readonly INITIALS: 1;
+};
+type FieldTypeValue = (typeof FieldType)[keyof typeof FieldType];
+declare function encode(signerIndex: number, fieldType: number): string;
+interface DecodedEncoding {
+    signerIndex: number;
+    fieldType: number;
+}
+interface DecodedEncodingWithPosition extends DecodedEncoding {
+    /** Character position in the scanned text where the encoding starts. */
+    position: number;
+}
+declare function decodeAll(text: string): DecodedEncodingWithPosition[];
+declare function stripEncoding(text: string): string;
+declare function containsEncoding(text: string): boolean;
+
+/** One text-showing run, in content-stream order. */
+interface TextRun {
+    /** Decoded Unicode text of the run. */
+    text: string;
+    /** Device-space x of the run start, in points. */
+    x: number;
+    /** Device-space y of the run start (bottom-origin), in points. */
+    y: number;
+    /** Advance width of the run in device space, in points. */
+    width: number;
+    /** Effective font height in device space, in points. */
+    height: number;
+}
+
+/** A signature or initials field located in the PDF. */
+interface ExtractedField {
+    signerIndex: number;
+    fieldType: 'signature' | 'initials';
+    /** 1-based page number. */
+    page: number;
+    /** Points from the left page edge. */
+    x: number;
+    /** Points from the top page edge. */
+    y: number;
+    width: number;
+    height: number;
+    /** Raw bottom-origin y from the PDF. */
+    rawY: number;
+    pageHeight: number;
+}
+/** A decoded marker whose field type code has no meaning to this reader. */
+interface UnknownMarker {
+    /** 1-based page number. */
+    page: number;
+    signerIndex: number;
+    /** The raw field type code (0-15). */
+    fieldType: number;
+}
+/**
+ * Thrown when a PDF carries markers whose field type is not signature or
+ * initials. Such a marker comes from a newer encoder or a damaged text layer;
+ * reading it as either known type could put a signer's mark in the wrong box.
+ */
+declare class UnknownMarkerError extends Error {
+    readonly markers: UnknownMarker[];
+    constructor(markers: UnknownMarker[]);
+}
+/**
+ * Extract signature/initials fields from a PDF produced by a converter.
+ *
+ * @throws {UnknownMarkerError} naming every marker whose field type is not
+ * signature or initials.
+ */
+declare function extractFieldsFromPdf(pdf: Uint8Array): Promise<ExtractedField[]>;
+/** Positioned, merged text runs for one page, with its geometry. */
+interface PageTextRuns {
+    /** [x0, y0, x1, y1] MediaBox in points. */
+    mediaBox: [number, number, number, number];
+    runs: TextRun[];
+}
+/**
+ * Merged text runs for every page, in document order. Low-level building
+ * block for verification and layout tooling; coordinates are raw PDF user
+ * space (bottom-origin y).
+ */
+declare function pageTextRuns(pdf: Uint8Array): Promise<PageTextRuns[]>;
+/** True when any page's text layer contains encoding characters. */
+declare function pdfContainsEncoding(pdf: Uint8Array): Promise<boolean>;
+
+/**
+ * A placement query against a converter-produced PDF.
+ *
+ * - `marker`: find the invisible encoding for a signer index + field type
+ *   that the render stage injected into the document.
+ * - `anchor`: find literal document text. Without `occurrence` the text must
+ *   appear exactly once; ambiguity is an error, not a guess.
+ */
+type LocateQuery = {
+    id: string;
+} & ({
+    kind: 'marker';
+    signerIndex: number;
+    fieldType: FieldTypeValue;
+} | {
+    kind: 'anchor';
+    text: string;
+    occurrence?: number;
+});
+
+/**
+ * Factory returning a locator object for core's `seal({ locate })` option.
+ * Kept as a factory so future variants (imported-PDF tier, hosted tier) share
+ * the calling convention.
+ */
+declare function locator(): {
+    locate: typeof locate;
+};
+/** Thrown when any query cannot be resolved deterministically. */
+declare class LocateError extends Error {
+    readonly failures: {
+        id: string;
+        reason: 'missing' | 'ambiguous';
+        matches?: number;
+    }[];
+    constructor(message: string, failures: {
+        id: string;
+        reason: 'missing' | 'ambiguous';
+        matches?: number;
+    }[]);
+}
+/**
+ * Resolve placement queries against a PDF. All queries succeed or the call
+ * throws a `LocateError` naming every failed id — partial results are never
+ * returned, so a seal pipeline cannot proceed on a silently incomplete map.
+ */
+declare function locate(pdf: Uint8Array, queries: LocateQuery[]): Promise<LocateHit[]>;
+
+/** Why a PDF could not be read as the artifact's filled form. */
+type PdfExtractionErrorCode = 'malformed_pdf' | 'no_form_fields' | 'not_matching' | 'no_pdf_layer' | 'layer_required' | 'layer_not_found' | 'not_pdf_layer' | 'unknown_bindings_source';
+/** Extraction refused the input. `code` says which failure case applies. */
+declare class PdfExtractionError extends Error {
+    readonly code: PdfExtractionErrorCode;
+    constructor(code: PdfExtractionErrorCode, message: string);
+}
+/** What happened to one artifact path the layer's bindings target. */
+type PdfExtractionStatus = 'recovered' | 'empty' | 'not_recoverable' | 'unparseable';
+/** One PDF field that carries a binding target, with the raw value read from it. */
+interface PdfExtractionSource {
+    /** Fully qualified AcroForm field name. */
+    field: string;
+    /** Raw PDF value: the text, the selected option, or a button state name. Absent when the field has none. */
+    value?: string;
+}
+/** One entry per artifact path the layer's bindings target. */
+interface PdfExtractionEntry {
+    /** The binding target, as written in the layer's bindings. */
+    path: string;
+    status: PdfExtractionStatus;
+    /** Every PDF field that carries this path. */
+    sources: PdfExtractionSource[];
+    /** Why the value is not recoverable or could not be parsed. */
+    reason?: string;
+}
+/** A PDF field that holds a value no binding covers. */
+interface PdfUnboundField {
+    field: string;
+    type: 'text' | 'checkbox' | 'radio' | 'dropdown';
+    value: string;
+}
+interface PdfExtractionReport {
+    entries: PdfExtractionEntry[];
+    unbound: PdfUnboundField[];
+}
+/** Partial artifact data in the fill payload shape. It holds only values recovered exactly. */
+interface PdfExtractedData {
+    fields: Record<string, unknown>;
+    parties?: Record<string, unknown>;
+    annexes?: Record<string, unknown>;
+}
+interface PdfExtraction {
+    data: PdfExtractedData;
+    report: PdfExtractionReport;
+}
+interface ExtractPdfDataOptions {
+    /** The filled PDF. It is read, never modified. */
+    pdf: BinaryContent;
+    /** The artifact whose layer produced the PDF. */
+    form: Form;
+    /** The PDF layer's bindings: AcroForm field name to artifact path. */
+    bindings: Record<string, string>;
+    /** The formatter the PDF was filled with. Defaults to the default formatter. */
+    formatter?: Formatter;
+    /**
+     * The presentation the PDF layer declares, applied over `formatter` as it
+     * was when filling. With `money.currencyDisplay: 'none'`, an amount is read
+     * in the currency its field declares.
+     */
+    format?: LayerFormat;
+}
+/**
+ * Read a filled PDF back into artifact data through the layer's bindings.
+ *
+ * Only exact reversals are returned: direct fields, split fields, checkbox and
+ * radio maps. A joined binding's raw text is reported as not recoverable, and
+ * text that does not parse into the field's type is reported with its raw
+ * value. Nothing is validated here; pass the data to the normal fill path.
+ *
+ * @throws {PdfEncryptedError} when the PDF is encrypted.
+ * @throws {PdfExtractionError} when the PDF or the layer choice cannot be read.
+ */
+declare function extractPdfData({ pdf, form, bindings, formatter: filledWith, format }: ExtractPdfDataOptions): Promise<PdfExtraction>;
+/** A PDF layer as the artifact declares it. */
+interface PdfLayerSpec {
+    mimeType?: string;
+    bindings?: Record<string, string>;
+    bindingsFrom?: string;
+    format?: LayerFormat;
+}
+/**
+ * Choose the PDF layer to read against: the named one, or the only PDF layer.
+ * Returns its key, resolved bindings, and declared format.
+ */
+declare function selectPdfExtractionLayer(layers: Record<string, PdfLayerSpec> | undefined, requested?: string): {
+    key: string;
+    bindings: Record<string, string>;
+    format?: LayerFormat;
+};
+
+/**
+ * Authoring check that the values an artifact can bind to a PDF form's text
+ * fields fit their boxes.
+ *
+ * Filling fails when a value cannot fit its box at {@link MIN_FONT_SIZE}, or
+ * has more characters than a comb field has boxes. This check finds those
+ * failures before any data exists: for each binding to an AcroForm text field
+ * it builds values the bound artifact field accepts and lays them out with the
+ * same code filling uses.
+ *
+ * A text, email, uuid, or uri field is checked at its length bound: `maxLength`
+ * characters, or the length its `pattern` bounds (a uuid without a pattern
+ * takes its 36-character canonical form). Two values of that length are laid out:
+ * - a typical value: each open position holds the next character of
+ *   {@link TYPICAL_TEXT}; a position the pattern constrains holds the allowed
+ *   character nearest the allowed characters' mean width. When it cannot fit,
+ *   ordinary answers fail to fill: an error.
+ * - the widest value: each position holds the widest character it may hold
+ *   (the widest Latin letter or digit when open, `W` in Helvetica). When only
+ *   this value cannot fit, unusual answers fail to fill: a warning.
+ *
+ * A split binding (`path:2`) takes the matching hyphen-separated part of the
+ * pattern, or the whole value's bound when the pattern does not fix the parts.
+ * Enum and multiselect fields write known option values, so they are checked
+ * exactly: the widest option value, or the widest `max` values (all of them
+ * without `max`) joined with ", ". A comma-joined binding joins each path's
+ * value with ", ". More characters than a comb field has boxes is an error.
+ *
+ * The font is the one filling would choose: the layer's declared font, then
+ * the form's own font for the field, then Helvetica. A font supplied only at
+ * render time is not known here.
+ */
+
+/**
+ * The text a typical value is made of: an English pangram with its word spaces,
+ * repeated. It holds every lowercase letter, one capital, and spaces at about
+ * the rate English prose has them, so its mean advance (456 units in Helvetica)
+ * sits just above that of letter-frequency-weighted English text (441).
+ */
+declare const TYPICAL_TEXT = "The quick brown fox jumps over the lazy dog ";
+/** Why a binding may not fit its PDF text field. */
+type PdfBindingFitReason = 'overflow' | 'comb-length' | 'unbounded';
+/** One binding whose values may not fit the PDF text field it fills. */
+interface PdfBindingFitIssue {
+    /** Fully qualified name of the PDF form field. */
+    field: string;
+    /** The binding as the layer declares it. */
+    binding: string;
+    /** The artifact paths the binding reads, such as `fields.amountSource`. */
+    paths: string[];
+    /**
+     * `error` when a typical value, an option value, or a value's length cannot
+     * be filled; `warning` when only the widest value overflows, or nothing
+     * bounds the value.
+     */
+    severity: 'error' | 'warning';
+    reason: PdfBindingFitReason;
+    /** Which value failed: a typical one, or the widest. Absent for `unbounded`. */
+    value?: 'typical' | 'widest';
+    /** For `overflow`, the minimum font size in points; for `comb-length`, the number of comb boxes. */
+    limit?: number;
+    /** Characters in the widest value checked. */
+    length?: number;
+    message: string;
+}
+/** Options for {@link checkPdfBindingFit}. */
+interface CheckPdfBindingFitOptions {
+    /** The PDF layer's bytes. */
+    template: Uint8Array;
+    form: Form;
+    /** The layer's bindings; without them, fields fill the PDF fields of the same name. */
+    bindings?: Record<string, string>;
+    /** The font the layer declares. */
+    layerFont?: PdfFont;
+}
+/**
+ * Check that every value the artifact accepts for a binding to a PDF text
+ * field can be filled: that it fits the box at the minimum font size, and
+ * that it has no more characters than a comb field has boxes. A text field
+ * with nothing bounding its length is a warning. A PDF without an AcroForm
+ * has nothing to check.
+ *
+ * @throws {PdfFontError} when the layer's font cannot be read.
+ * @throws {PdfBindingSyntaxError} when a binding cannot be parsed.
+ */
+declare function checkPdfBindingFit({ template, form, bindings, layerFont }: CheckPdfBindingFitOptions): Promise<PdfBindingFitIssue[]>;
+
+export { type CheckPdfBindingFitOptions, type DecodedEncoding, type DecodedEncodingWithPosition, type ExtractPdfDataOptions, type ExtractedField, FieldType, type FieldTypeValue, type InspectOptions, LocateError, type LocateQuery, MIN_FONT_SIZE, type PageTextRuns, type PdfBindingFitIssue, type PdfBindingFitReason, PdfEncryptedError, type PdfExtractedData, type PdfExtraction, type PdfExtractionEntry, PdfExtractionError, type PdfExtractionErrorCode, type PdfExtractionReport, type PdfExtractionSource, type PdfExtractionStatus, type PdfFieldFillDetail, PdfFieldFillError, type PdfFieldFillReason, type PdfFieldInfo, type PdfFieldType, PdfFont, type PdfImageOverlay, type PdfInfo, PdfMergeError, type PdfOverlay, type PdfPageInfo, type PdfRendererOptions, type PdfSignatureOptions, type PdfSignatureRecord, type PdfTextOverlay, type PdfUnboundField, type PreparedPdfSignature, type RenderPdfOptions, TYPICAL_TEXT, type TextRun, type UnknownMarker, UnknownMarkerError, checkPdfBindingFit, containsEncoding, decodeAll, embedPdfSignature, encode, extractFieldsFromPdf, extractPdfData, flattenPdf, inspectAcroFormFields, inspectPdf, locate, locator, mergePdfs, pageTextRuns, pdfContainsEncoding, pdfRenderer, preparePdfSignature, readPdfSignature, renderPdf, selectPdfExtractionLayer, selectPdfPages, signedBytes, stripEncoding };