@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/types/modules/word/advanced/style-map.d.ts

@@ -0,0 +1,105 @@
+/**
+ * DOCX Module - Style Mapping DSL
+ *
+ * A domain-specific language for customizing how DOCX elements are
+ * mapped to HTML output during conversion. Inspired by mammoth.js's
+ * style mapping approach but designed for this project's architecture.
+ *
+ * The DSL allows users to define rules that control the HTML output
+ * for specific Word styles, without modifying the core renderer.
+ *
+ * Syntax examples:
+ * ```
+ * p[style-name='Heading 1'] => h1.custom-heading
+ * p[style-name='Quote'] => blockquote.pull-quote
+ * r[style-name='Emphasis'] => em.highlight
+ * p[style-name='Code'] => pre > code
+ * table[style-name='GridTable'] => table.data-table
+ * ```
+ */
+/** Target element type in the mapping rule. */
+export type MappingSourceType = "p" | "r" | "table" | "image" | "b" | "i" | "u" | "strike";
+/** A condition for matching source elements. */
+export interface MappingCondition {
+    /** Attribute to match on. */
+    readonly attribute: "style-name" | "style-id" | "outline-level" | "numbering-level" | "is-bold" | "is-italic";
+    /** Value to match (exact or regex). */
+    readonly value: string;
+    /** Use regex matching. */
+    readonly regex?: boolean;
+}
+/** Target HTML element specification. */
+export interface MappingTarget {
+    /** HTML tag name. */
+    readonly tagName: string;
+    /** CSS class(es) to add. */
+    readonly className?: string;
+    /** Additional HTML attributes. */
+    readonly attributes?: Readonly<Record<string, string>>;
+    /** Nested element (for `pre > code` style mappings). */
+    readonly child?: MappingTarget;
+    /** Whether to preserve separator. */
+    readonly separator?: string;
+    /** Whether this is a "fresh" mapping (wrap each paragraph separately). */
+    readonly fresh?: boolean;
+}
+/** A single style mapping rule. */
+export interface StyleMappingRule {
+    /** Source element type. */
+    readonly source: MappingSourceType;
+    /** Conditions that must all be satisfied. */
+    readonly conditions: readonly MappingCondition[];
+    /** Target HTML output. */
+    readonly target: MappingTarget;
+    /** Priority (higher = checked first). Default: 0. */
+    readonly priority?: number;
+}
+/** A compiled set of style mapping rules. */
+export interface StyleMap {
+    /** All rules, sorted by priority (highest first). */
+    readonly rules: readonly StyleMappingRule[];
+}
+/** Options for the style mapping parser. */
+export interface StyleMapOptions {
+    /** Base rules to include (before user rules). */
+    readonly base?: StyleMap;
+    /** Whether to include default mappings (Heading → h1-h6, etc.). */
+    readonly includeDefaults?: boolean;
+}
+/** Default style mappings (standard Word styles → semantic HTML). */
+export declare const DEFAULT_STYLE_MAP: StyleMap;
+/**
+ * Parse a style mapping DSL string into a StyleMap.
+ *
+ * @param dsl - The DSL string (one rule per line).
+ * @param options - Parser options.
+ * @returns A compiled StyleMap.
+ *
+ * @example
+ * ```ts
+ * const map = parseStyleMap(`
+ *   p[style-name='Heading 1'] => h1.title
+ *   p[style-name='Code Block'] => pre > code
+ *   r[style-name='Emphasis'] => em.custom-em
+ * `);
+ * ```
+ */
+export declare function parseStyleMap(dsl: string, options?: StyleMapOptions): StyleMap;
+/**
+ * Create a style map programmatically (without DSL parsing).
+ */
+export declare function createStyleMap(rules: readonly StyleMappingRule[]): StyleMap;
+/**
+ * Merge multiple style maps together.
+ * Later maps take precedence (higher priority) over earlier ones.
+ */
+export declare function mergeStyleMaps(...maps: readonly StyleMap[]): StyleMap;
+/**
+ * Match a source element against the style map and return the target.
+ *
+ * @param map - The style map to match against.
+ * @param source - Source element type.
+ * @param attributes - Attributes of the source element.
+ * @returns The matching target, or undefined if no match.
+ */
+export declare function matchStyleMap(map: StyleMap, source: MappingSourceType, attributes: Readonly<Record<string, string>>): MappingTarget | undefined;

package/dist/types/modules/word/advanced/validation.d.ts

@@ -0,0 +1,56 @@
+/**
+ * DOCX Module - Document Validation (Schema Validation)
+ *
+ * Provides structural validation of DocxDocument models against the
+ * OOXML WordprocessingML constraints. This validates the document model
+ * at a semantic level (not XML schema validation) to ensure the generated
+ * DOCX will be well-formed and compliant.
+ *
+ * Validation rules are based on:
+ * - ECMA-376 Part 1, Chapter 17 (WordprocessingML)
+ * - Practical interoperability constraints from Word/LibreOffice
+ */
+import type { DocxDocument } from "../types.js";
+/** Validation severity level. */
+export type ValidationSeverity = "error" | "warning" | "info";
+/** A single validation issue. */
+export interface ValidationIssue {
+    /** Severity of the issue. */
+    readonly severity: ValidationSeverity;
+    /** Human-readable description of the issue. */
+    readonly message: string;
+    /** Path to the problematic element (e.g. "body[3].rows[0].cells[1]"). */
+    readonly path: string;
+    /** Rule identifier for programmatic handling. */
+    readonly rule: string;
+}
+/** Validation result. */
+export interface ValidationResult {
+    /** Whether the document is valid (no errors). */
+    readonly valid: boolean;
+    /** All issues found. */
+    readonly issues: readonly ValidationIssue[];
+    /** Count of errors. */
+    readonly errorCount: number;
+    /** Count of warnings. */
+    readonly warningCount: number;
+}
+/** Validation options. */
+export interface ValidationOptions {
+    /** Maximum severity to report. Default: all levels. */
+    readonly maxSeverity?: ValidationSeverity;
+    /** Stop after this many errors. Default: unlimited. */
+    readonly maxErrors?: number;
+    /** Check for compatibility with specific Word version. */
+    readonly compatibilityMode?: "word2007" | "word2010" | "word2013" | "word2016" | "word2019";
+    /** Enable strict mode (treats warnings as errors). */
+    readonly strict?: boolean;
+}
+/**
+ * Validate a DocxDocument model for structural correctness and OOXML compliance.
+ *
+ * @param doc - The document model to validate.
+ * @param options - Validation options.
+ * @returns Validation result with all issues found.
+ */
+export declare function validateDocument(doc: DocxDocument, options?: ValidationOptions): ValidationResult;

package/dist/types/modules/word/advanced/vba-project.d.ts

@@ -0,0 +1,91 @@
+/**
+ * DOCX Module - VBA Project (docm) Round-trip Support
+ *
+ * Provides support for preserving VBA macros during document read/write.
+ * The VBA project binary lives on `DocxDocument.vbaProject` — that's what
+ * `readDocx` populates and `packageDocx` writes back. This module exposes
+ * convenience helpers around that field plus best-effort metadata
+ * extraction.
+ *
+ * Note: This module does NOT execute or compile VBA code. It only
+ * preserves the binary VBA project for round-trip fidelity.
+ */
+import type { DocxDocument, OpaquePart } from "../types.js";
+/** VBA project metadata extracted from the document. */
+export interface VbaProjectInfo {
+    /** Whether a VBA project is present. */
+    readonly hasVba: boolean;
+    /** Path of the vbaProject.bin in the archive. */
+    readonly projectPath?: string;
+    /** Content type of the VBA project part. */
+    readonly contentType?: string;
+    /** Module names detected (best-effort extraction). */
+    readonly moduleNames?: readonly string[];
+    /** Size in bytes of the VBA project binary. */
+    readonly sizeBytes?: number;
+}
+/** Content types for macro-enabled documents. */
+export declare const DOCM_CONTENT_TYPES: {
+    /** Content type for .docm main document part. */
+    readonly document: "application/vnd.ms-word.document.macroEnabled.main+xml";
+    /** Content type for vbaProject.bin. */
+    readonly vbaProject: "application/vnd.ms-office.vbaProject";
+    /** Content type for vbaData.xml. */
+    readonly vbaData: "application/vnd.ms-word.vbaData+xml";
+};
+/** VBA-related relationship type. */
+export declare const VBA_REL_TYPE = "http://schemas.microsoft.com/office/2006/relationships/vbaProject";
+/**
+ * Check if a document contains a VBA project (is macro-enabled).
+ *
+ * @param doc - The parsed document.
+ * @returns true if VBA macros are present.
+ */
+export declare function hasVbaProject(doc: DocxDocument): boolean;
+/**
+ * Extract VBA project metadata from a document.
+ *
+ * @param doc - The parsed document.
+ * @returns VBA project info, or info with hasVba=false if not present.
+ */
+export declare function getVbaProjectInfo(doc: DocxDocument): VbaProjectInfo;
+/**
+ * Get the raw VBA project binary data.
+ *
+ * @param doc - The parsed document.
+ * @returns The vbaProject.bin bytes, or undefined if not present.
+ */
+export declare function getVbaProjectData(doc: DocxDocument): Uint8Array | undefined;
+/**
+ * Add a VBA project to a document (making it a .docm).
+ *
+ * The VBA project binary should be a valid OLE2 compound document
+ * containing the VBA modules. The first 8 bytes of an OLE2 file are the
+ * fixed signature `D0 CF 11 E0 A1 B1 1A E1`; we sanity-check that here so
+ * obviously-wrong inputs (e.g. a plain text file) fail eagerly instead of
+ * producing a .docm that Word silently rejects.
+ *
+ * The data is stored in the canonical `DocxDocument.vbaProject` field —
+ * `packageDocx` writes that field directly to `word/vbaProject.bin` and
+ * registers the relationship + content type. Any pre-existing copies in
+ * `opaqueParts` are removed so we don't emit two conflicting parts.
+ *
+ * @param doc - The document to add VBA to.
+ * @param vbaProjectBin - The vbaProject.bin binary data (OLE2 compound).
+ * @returns A new document with the VBA project embedded.
+ */
+export declare function addVbaProject(doc: DocxDocument, vbaProjectBin: Uint8Array): DocxDocument;
+/**
+ * Remove VBA project from a document (converting .docm to .docx behavior).
+ *
+ * @param doc - The macro-enabled document.
+ * @returns A new document without VBA parts.
+ */
+export declare function removeVbaProject(doc: DocxDocument): DocxDocument;
+/**
+ * List all VBA-related parts in the document. Includes the canonical
+ * `vbaProject` field (synthesised as an OpaquePart for ergonomics) plus
+ * any auxiliary VBA parts (e.g. `vbaData.xml`) that survive in
+ * `opaqueParts`.
+ */
+export declare function listVbaParts(doc: DocxDocument): readonly OpaquePart[];

package/dist/types/modules/word/bridge/excel-bridge.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Excel-to-Word Bridge
+ *
+ * Converts an Excel Workbook into a DocxDocument model.
+ * This is the ONLY file in the Word module that imports from @excel.
+ *
+ * @example
+ * ```typescript
+ * import { Workbook } from "excelts";
+ * import { excelToDocx } from "excelts/word/excel";
+ *
+ * const wb = new Workbook();
+ * await wb.xlsx.load(buffer);
+ * const doc = excelToDocx(wb);
+ * ```
+ */
+import type { AddChartExOptions, ChartExModel, ChartExType } from "../../excel/chart/chart-ex-types.js";
+import type { ChartModel } from "../../excel/chart/types.js";
+import type { Workbook } from "../../excel/workbook.browser.js";
+import type { Chart, DocxDocument } from "../types.js";
+/** Options for Excel → DOCX conversion. */
+export interface ExcelToDocxOptions {
+    /** Which sheets to include (by name or 0-based index). Default: all visible sheets. */
+    readonly sheets?: readonly (string | number)[];
+    /** Include sheet name as heading before each table. Default: true. */
+    readonly includeSheetHeadings?: boolean;
+    /** Heading level for sheet names (1-6). Default: 2. */
+    readonly sheetHeadingLevel?: number;
+    /** Include a title page with workbook metadata. Default: false. */
+    readonly includeTitlePage?: boolean;
+    /** Maximum columns to include per sheet (avoids excessively wide tables). Default: 50. */
+    readonly maxColumns?: number;
+    /** Maximum rows per sheet to include. Default: 10000. */
+    readonly maxRows?: number;
+    /** Preserve cell formatting (bold, italic, colors, etc.). Default: true. */
+    readonly preserveFormatting?: boolean;
+    /** Include cell borders in table. Default: true. */
+    readonly includeBorders?: boolean;
+}
+/**
+ * Convert an Excel Workbook to a DocxDocument model.
+ *
+ * Creates a Word document with tables representing each worksheet's data.
+ * Preserves cell formatting (fonts, colors, alignment) as run/paragraph properties.
+ *
+ * @param workbook - The Excel Workbook to convert.
+ * @param options - Conversion options.
+ * @returns A DocxDocument model ready for packaging, PDF conversion, or Markdown output.
+ */
+export declare function excelToDocx(workbook: Workbook, options?: ExcelToDocxOptions): DocxDocument;
+export type { AddChartExOptions, ChartExModel, ChartExType, ChartModel };
+/** Options for creating a ChartEx in a Word document. */
+export interface WordChartExOptions {
+    /** ChartEx type (sunburst, treemap, waterfall, funnel, histogram, pareto, boxWhisker, regionMap). */
+    readonly type: ChartExType;
+    /** Series data (with literal categories/values for Word context). */
+    readonly series: readonly {
+        readonly name: string;
+        readonly categories?: readonly string[];
+        readonly values: readonly number[];
+    }[];
+    /** Chart title. */
+    readonly title?: string | null;
+    /** Show legend. Default: true. */
+    readonly showLegend?: boolean;
+    /** Legend position. */
+    readonly legendPosition?: "b" | "l" | "r" | "t" | "tr";
+}
+/**
+ * Build a ChartEx XML part for embedding in a Word document.
+ *
+ * This bridges the Excel ChartEx renderer into the Word module,
+ * generating a complete `cx:chartSpace` XML string from high-level options.
+ *
+ * @param options - Chart configuration.
+ * @returns The complete ChartEx XML string for the chart part.
+ */
+export declare function buildWordChartExXml(options: WordChartExOptions): string;
+/**
+ * Render a Word Chart to SVG string for HTML embedding.
+ *
+ * Bridges Word's Chart definition to Excel's chart renderer by constructing
+ * a ChartModel with literal (inline) data and delegating to renderChartSvg.
+ *
+ * @param chart - The Word Chart definition.
+ * @returns SVG markup string.
+ */
+export declare function renderWordChartSvg(chart: Chart): string;
+/**
+ * Generate an embedded xlsx for chart data.
+ * Uses the full Excel xlsx writer for maximum compatibility.
+ *
+ * The resulting xlsx contains a single Sheet1 with:
+ * - Row 1: header (empty cell A1, then series names in B1, C1, ...)
+ * - Row 2+: category in column A, values in subsequent columns
+ *
+ * @param series - Chart data series
+ * @returns xlsx file as Uint8Array
+ */
+export declare function generateChartEmbeddedXlsx(series: readonly {
+    name: string;
+    categories: readonly string[];
+    values: readonly number[];
+}[]): Promise<Uint8Array>;
+/**
+ * Convert a Word Chart definition to an Excel ChartModel.
+ * This is the single source of truth for Word→Excel chart mapping.
+ *
+ * Used by:
+ * - `renderWordChartSvg` (SVG rendering for HTML embedding)
+ * - `createWordChartPdfRenderer` in `@pdf/excel-bridge` (PDF vector rendering)
+ *
+ * @param chart - The Word Chart definition.
+ * @returns A fully constructed ChartModel suitable for Excel's chart renderer.
+ */
+export declare function wordChartToChartModel(chart: Chart): ChartModel;
+/**
+ * Extract tables from a Word document and convert them to Excel worksheet data.
+ * Each table becomes a 2D array of cell values.
+ *
+ * @param doc - The DOCX document model.
+ * @returns Array of table data objects, each with a name and 2D data array.
+ */
+export declare function extractTablesToExcel(doc: DocxDocument): {
+    name: string;
+    data: (string | number | null)[][];
+}[];

package/dist/types/modules/word/builder/document-handle.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Document Handle & Namespace for building DOCX documents.
+ *
+ * Provides the Document namespace with free functions for constructing
+ * documents via an opaque DocumentHandle.
+ */
+import type { DocxDocument, BodyContent, Paragraph, ParagraphProperties, ParagraphChild, RunProperties, Table, SectionProperties, StyleDef, DocDefaults, HeaderFooterContent, ImageMediaType, CoreProperties, AppProperties, DocumentSettings, FontDef, TableWidth, Emu, Twips, DocumentBackground, CustomPropertyValue, TableOfContents, MathContent, FloatingImage, Watermark } from "../types.js";
+declare const _documentBrand: unique symbol;
+/**
+ * Opaque handle representing a document being built.
+ * Created via `Document.create()`, passed to `Document.*` functions.
+ */
+export type DocumentHandle = {
+    readonly [_documentBrand]: true;
+};
+/**
+ * Namespace of free functions for building DOCX documents.
+ *
+ * Replaces the former `DocumentBuilder` class with tree-shakeable free functions.
+ * Each function operates on an opaque `DocumentHandle`.
+ *
+ * @example
+ * ```ts
+ * import { Document, toBuffer } from "excelts/word";
+ *
+ * const doc = Document.create();
+ * Document.addHeading(doc, "Hello World", 1);
+ * Document.addParagraph(doc, "This is a paragraph.");
+ * Document.addTable(doc, [["Name", "Age"], ["Alice", "30"]]);
+ * const bytes = await toBuffer(Document.build(doc));
+ * ```
+ */
+export declare const Document: {
+    /** Create a new document handle. */
+    create(): DocumentHandle;
+    /** Add raw body content. */
+    addContent(doc: DocumentHandle, content: BodyContent): void;
+    /** Insert body content at a specific index. */
+    insertContentAt(doc: DocumentHandle, index: number, content: BodyContent): void;
+    /** Remove body content at a specific index. Returns the removed item. */
+    removeContent(doc: DocumentHandle, index: number): BodyContent | undefined;
+    /** Get the number of body content items. */
+    getContentCount(doc: DocumentHandle): number;
+    /** Get body content at a specific index. */
+    getContent(doc: DocumentHandle, index: number): BodyContent | undefined;
+    /** Add a paragraph with runs. */
+    addParagraphElement(doc: DocumentHandle, para: Paragraph): void;
+    /** Add a simple text paragraph. */
+    addParagraph(doc: DocumentHandle, content: string, properties?: ParagraphProperties & {
+        run?: RunProperties;
+    }): void;
+    /** Add a heading. Accepts plain text or an array of ParagraphChild for mixed formatting. */
+    addHeading(doc: DocumentHandle, content: string | ParagraphChild[], level?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9): void;
+    /** Add a page break. */
+    addPageBreak(doc: DocumentHandle): void;
+    /** Add a table from a 2D array. */
+    addTable(doc: DocumentHandle, data: string[][], options?: {
+        headerRow?: boolean;
+        borders?: boolean;
+        width?: TableWidth;
+        columnWidths?: Twips[];
+    }): void;
+    /** Add a table element. */
+    addTableElement(doc: DocumentHandle, tbl: Table): void;
+    /** Add an inline image. Returns the image relationship ID and drawing ID. */
+    addImage(doc: DocumentHandle, data: Uint8Array, mediaType: ImageMediaType, width: Emu, height: Emu, options?: {
+        altText?: string;
+        name?: string;
+    }): {
+        rId: string;
+        drawingId: number;
+    };
+    /** Add a floating image. Returns the image relationship ID. */
+    addFloatingImage(doc: DocumentHandle, data: Uint8Array, mediaType: ImageMediaType, width: Emu, height: Emu, options?: {
+        altText?: string;
+        name?: string;
+        horizontalPosition?: FloatingImage["horizontalPosition"];
+        verticalPosition?: FloatingImage["verticalPosition"];
+        wrap?: FloatingImage["wrap"];
+        behindDoc?: boolean;
+        lockAnchor?: boolean;
+        layoutInCell?: boolean;
+        allowOverlap?: boolean;
+        distT?: Emu;
+        distB?: Emu;
+        distL?: Emu;
+        distR?: Emu;
+        rotation?: number;
+        flipHorizontal?: boolean;
+        flipVertical?: boolean;
+    }): string;
+    /** Add a custom font definition. */
+    addFont(doc: DocumentHandle, font: FontDef): void;
+    /** Set a text watermark on the document. */
+    setWatermark(doc: DocumentHandle, watermark: Watermark): void;
+    /** Add a footnote. Returns the footnote ID. */
+    addFootnote(doc: DocumentHandle, content: string | Paragraph[]): number;
+    /** Add an endnote. Returns the endnote ID. */
+    addEndnote(doc: DocumentHandle, content: string | Paragraph[]): number;
+    /** Add a comment. Returns the comment ID. */
+    addComment(doc: DocumentHandle, author: string, content: string | Paragraph[], options?: {
+        date?: string;
+        initials?: string;
+    }): number;
+    /** Add a Table of Contents. */
+    addTableOfContents(doc: DocumentHandle, options?: Partial<Omit<TableOfContents, "type">>): void;
+    /** Add a math equation block. */
+    addMath(doc: DocumentHandle, content: MathContent[]): void;
+    /** Add a text box. */
+    addTextBox(doc: DocumentHandle, content: string | Paragraph[], options?: {
+        width?: Twips;
+        height?: Twips;
+        stroke?: boolean;
+        fill?: boolean;
+    }): void;
+    /**
+     * Add a bullet list. Items can be plain strings or arrays of ParagraphChild for rich formatting.
+     */
+    addBulletList(doc: DocumentHandle, items: (string | ParagraphChild[])[], level?: number): void;
+    /** Add a numbered list. Items can be plain strings or arrays of ParagraphChild for rich formatting. */
+    addNumberedList(doc: DocumentHandle, items: (string | ParagraphChild[])[], level?: number): void;
+    /** Set section properties (page size, margins, etc.). */
+    setSectionProperties(doc: DocumentHandle, props: SectionProperties): void;
+    /** Set document defaults. */
+    setDocDefaults(doc: DocumentHandle, defaults: DocDefaults): void;
+    /** Add a style definition. */
+    addStyle(doc: DocumentHandle, style: StyleDef): void;
+    /** Set default styles (Normal, Heading1-6, Hyperlink, etc.). */
+    useDefaultStyles(doc: DocumentHandle): void;
+    /** Set a header for the given type. */
+    setHeader(doc: DocumentHandle, type: string, content: HeaderFooterContent): void;
+    /** Set a footer for the given type. */
+    setFooter(doc: DocumentHandle, type: string, content: HeaderFooterContent): void;
+    /** Set document settings. */
+    setSettings(doc: DocumentHandle, settings: DocumentSettings): void;
+    /** Set core properties (metadata). */
+    setCoreProperties(doc: DocumentHandle, props: CoreProperties): void;
+    /** Set application properties. */
+    setAppProperties(doc: DocumentHandle, props: AppProperties): void;
+    /** Set document background. */
+    setBackground(doc: DocumentHandle, background: DocumentBackground): void;
+    /** Add a custom document property. */
+    addCustomProperty(doc: DocumentHandle, name: string, value: CustomPropertyValue): void;
+    /** Add a section break with properties. */
+    addSectionBreak(doc: DocumentHandle, props: SectionProperties): void;
+    /** Get next available bookmark ID. */
+    nextBookmarkId(doc: DocumentHandle): number;
+    /** Build the DocxDocument model from the handle. */
+    build(doc: DocumentHandle): DocxDocument;
+};
+export {};

package/dist/types/modules/word/builder/paragraph-builders.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Paragraph-level builder functions for DOCX documents.
+ *
+ * Includes paragraph, textParagraph, heading, hyperlink, bookmarks,
+ * comment markers, and track-change run wrappers.
+ */
+import type { Paragraph, ParagraphProperties, ParagraphChild, Run, RunProperties, CommentRangeStart, CommentRangeEnd, CommentReference, InsertedRun, DeletedRun, MovedFromRun, MovedToRun, MoveRangeMarker, RevisionInfo } from "../types.js";
+/** Create a paragraph. */
+export declare function paragraph(children: ParagraphChild[], properties?: ParagraphProperties): Paragraph;
+/** Create a simple text paragraph. */
+export declare function textParagraph(content: string, properties?: ParagraphProperties & {
+    run?: RunProperties;
+}): Paragraph;
+/** Create a heading paragraph. Accepts plain text or an array of runs for mixed formatting. */
+export declare function heading(content: string | ParagraphChild[], level: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9): Paragraph;
+/** Create a hyperlink. */
+export declare function hyperlink(linkText: string, options: {
+    rId?: string;
+    url?: string;
+    anchor?: string;
+    tooltip?: string;
+    /** Document location bookmark / fragment id (`w:docLocation`). */
+    docLocation?: string;
+    /** Target frame name for web views (`w:tgtFrame`). */
+    tgtFrame?: string;
+    /** Whether the hyperlink has been visited (`w:history`). */
+    history?: boolean;
+    properties?: RunProperties;
+}): ParagraphChild;
+/** Create a bookmark start. */
+export declare function bookmarkStart(id: number, name: string): ParagraphChild;
+/** Create a bookmark end. */
+export declare function bookmarkEnd(id: number): ParagraphChild;
+/** Create a comment range start marker. */
+export declare function commentRangeStart(id: number): CommentRangeStart;
+/** Create a comment range end marker. */
+export declare function commentRangeEnd(id: number): CommentRangeEnd;
+/** Create a comment reference (inside paragraph children). */
+export declare function commentReference(id: number): CommentReference;
+/** Create an inserted run (track changes). */
+export declare function insertedRun(run: Run, revision: RevisionInfo): InsertedRun;
+/** Create a deleted run (track changes). */
+export declare function deletedRun(run: Run, revision: RevisionInfo): DeletedRun;
+/** Create a moved-from run (track changes — source of a move). */
+export declare function movedFromRun(run: Run, revision: RevisionInfo): MovedFromRun;
+/** Create a moved-to run (track changes — destination of a move). */
+export declare function movedToRun(run: Run, revision: RevisionInfo): MovedToRun;
+/** Create a move range start marker. */
+export declare function moveFromRangeStart(id: number, author: string, options?: {
+    date?: string;
+    name?: string;
+}): MoveRangeMarker;
+/** Create a move range end marker. */
+export declare function moveFromRangeEnd(id: number): MoveRangeMarker;
+/** Create a move-to range start marker. */
+export declare function moveToRangeStart(id: number, author: string, options?: {
+    date?: string;
+    name?: string;
+}): MoveRangeMarker;
+/** Create a move-to range end marker. */
+export declare function moveToRangeEnd(id: number): MoveRangeMarker;