medical-form-printer 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3188 @@
+/**
+ * @fileoverview PrintSchema type definitions
+ * @module types/print-schema
+ * @description Defines complete type system for print layout configuration
+ * @modif 2024-04-07
+ */
+/** Page size */
+type PageSize = 'A4' | 'A5' | '16K';
+/** Page orientation */
+type PageOrientation = 'portrait' | 'landscape';
+/** Section type */
+type SectionType = 'info-grid' | 'table' | 'checkbox-grid' | 'signature-area' | 'notes' | 'free-text' | 'section-title' | 'medical-checkbox-row' | 'inline-row' | 'container';
+/** Cell data type */
+type CellType = 'text' | 'checkbox' | 'date' | 'number' | 'signature' | 'checkbox-inline' | 'compound' | 'textarea' | 'checkbox-text';
+/** Header configuration */
+interface PrintHeader {
+    /** Hospital name */
+    hospital: string;
+    /** Department name */
+    department?: string;
+    /** Form title */
+    title: string;
+    /** Whether to show logo */
+    showLogo?: boolean;
+    /** Logo URL */
+    logoUrl?: string;
+}
+/** Footer configuration */
+interface PrintFooter {
+    /** Whether to show page number */
+    showPageNumber?: boolean;
+    /** Notes text */
+    notes?: string;
+}
+/** Info grid cell */
+interface InfoGridCell {
+    /** Label text */
+    label: string;
+    /** Field name in formData */
+    field: string;
+    /** Cell span */
+    span?: number;
+    /** Data type */
+    type?: CellType;
+    /** Suffix (e.g., '℃', 'kg') */
+    suffix?: string;
+    /** Custom width */
+    width?: string;
+    /** checkbox-inline options (e.g., ['No', 'Yes']) */
+    inlineOptions?: string[];
+    /** compound template format (e.g., '{systolic}/{diastolic}mmHg') */
+    compoundFormat?: string;
+    /** compound field mapping (e.g., { systolic: 'bp_systolic', diastolic: 'bp_diastolic' }) */
+    compoundFields?: Record<string, string>;
+    /** textarea minimum height */
+    minHeight?: string;
+    /** checkbox-text checkbox field name */
+    checkboxField?: string;
+    /** checkbox-text text field name */
+    textField?: string;
+    /** checkbox-text display text */
+    text?: string;
+}
+/** Info grid row */
+interface InfoGridRow {
+    cells: InfoGridCell[];
+}
+/** Info grid configuration */
+interface InfoGridConfig {
+    /** Number of columns */
+    columns: number;
+    /** Row configuration */
+    rows: InfoGridRow[];
+}
+/** Table column configuration */
+interface TableColumn {
+    /** Column header */
+    header: string;
+    /** Field name in formData */
+    field: string;
+    /** Column width */
+    width?: string;
+    /** Data type */
+    type?: CellType;
+    /** Options (for select type) */
+    options?: string[];
+}
+/** Table configuration */
+interface TableConfig$1 {
+    /** Column configuration */
+    columns: TableColumn[];
+    /** Array field name in formData */
+    dataField: string;
+    /** Whether to show row numbers */
+    showRowNumber?: boolean;
+}
+/** Checkbox option */
+interface CheckboxOption {
+    /** Option value */
+    value: string;
+    /** Display label */
+    label: string;
+    /** Whether has additional input */
+    hasInput?: boolean;
+    /** Additional input field name */
+    inputField?: string;
+}
+/** Checkbox item (items mode) */
+interface CheckboxItem {
+    /** Item type: checkbox or text-input */
+    type?: 'checkbox' | 'text-input';
+    /** Option value (for checkbox type) */
+    value?: string;
+    /** Display label */
+    label: string;
+    /** Whether has additional input (for checkbox type) */
+    hasInput?: boolean;
+    /** Additional input field name */
+    inputField?: string;
+}
+/** Checkbox grid configuration */
+interface CheckboxGridConfig {
+    /** Field name in formData */
+    field: string;
+    /** Option list (options mode) */
+    options?: CheckboxOption[];
+    /** Item list (items mode, supports more types) */
+    items?: CheckboxItem[];
+    /** Number of columns */
+    columns?: number;
+    /** Layout mode */
+    layout?: 'grid' | 'flex';
+    /** Prefix label */
+    prefixLabel?: string;
+}
+/** Signature field configuration */
+interface SignatureField {
+    /** Label text */
+    label: string;
+    /** Field name in formData */
+    field: string;
+    /** Whether to show date */
+    showDate?: boolean;
+}
+/** Signature area configuration */
+interface SignatureConfig {
+    fields: SignatureField[];
+}
+/** Notes configuration */
+interface NotesConfig {
+    /** Static text content */
+    content: string;
+    /** Whether to show border */
+    showBorder?: boolean;
+}
+/** Free text configuration */
+interface FreeTextConfig {
+    /** Field name in formData */
+    field: string;
+    /** Minimum height */
+    minHeight?: string;
+}
+/** Section title configuration */
+interface SectionTitleConfig {
+    /** Title text */
+    text: string;
+    /** Alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Font size */
+    fontSize?: string;
+    /** Whether bold */
+    bold?: boolean;
+}
+/** Medical checkbox option configuration */
+interface MedicalCheckboxOption {
+    /** Option value */
+    value: string;
+    /** Display label */
+    label: string;
+}
+/** Extra input item configuration */
+interface ExtraInput {
+    /** Input label */
+    label?: string;
+    /** Field name in formData */
+    field: string;
+    /** Suffix text */
+    suffix?: string;
+}
+/** Medical checkbox row configuration */
+interface MedicalCheckboxRowConfig {
+    /** Prefix label (e.g., "Bowel movement:") */
+    prefixLabel?: string;
+    /** Field name in formData (for checkbox selection) */
+    field?: string;
+    /** Option list (□Yes/□No) */
+    options?: MedicalCheckboxOption[];
+    /** Input format template (e.g., "{input} times/day"), {input} will be replaced with input field */
+    inputFormat?: string;
+    /** Input field name (for inputFormat) */
+    inputField?: string;
+    /** Simple input label (e.g., "Disease name") */
+    inputLabel?: string;
+    /** Simple input field name (for inputLabel) */
+    inputLabelField?: string;
+    /** Extra input items list */
+    extraInputs?: ExtraInput[];
+}
+/** Inline row child element */
+interface InlineRowChild {
+    /** Section type */
+    type: SectionType;
+    /** Section configuration */
+    config: SectionConfig;
+}
+/** Inline row configuration */
+interface InlineRowConfig {
+    /** Child element list */
+    children: InlineRowChild[];
+    /** Column ratio configuration (e.g., [1, 2, 1] means 1:2:1) */
+    columns?: number[];
+    /** Gap */
+    gap?: string;
+}
+/** Container child element */
+interface ContainerChild {
+    /** Section type */
+    type: SectionType;
+    /** Section configuration */
+    config: SectionConfig;
+}
+/** Container configuration */
+interface ContainerConfig {
+    /** Child section list */
+    children: ContainerChild[];
+    /** Layout direction */
+    direction?: 'row' | 'column';
+    /** Border configuration */
+    border?: boolean | string;
+    /** Padding */
+    padding?: string;
+    /** Gap */
+    gap?: string;
+}
+/** Section configuration union type */
+type SectionConfig = InfoGridConfig | TableConfig$1 | CheckboxGridConfig | SignatureConfig | NotesConfig | FreeTextConfig | SectionTitleConfig | MedicalCheckboxRowConfig | InlineRowConfig | ContainerConfig;
+/** Print section */
+interface PrintSection {
+    /** Section type */
+    type: SectionType;
+    /** Section title */
+    title?: string;
+    /** Section configuration */
+    config: SectionConfig;
+}
+/** Print layout configuration */
+interface PrintSchema {
+    /** Page size */
+    pageSize: PageSize;
+    /** Page orientation */
+    orientation: PageOrientation;
+    /** Header configuration */
+    header: PrintHeader;
+    /** Section list */
+    sections: PrintSection[];
+    /** Footer configuration */
+    footer?: PrintFooter;
+}
+/** Form data type */
+type FormData = Record<string, unknown>;
+
+/**
+ * @fileoverview Theme type definitions
+ * @module types/theme
+ */
+/** Font configuration */
+interface FontConfig {
+    /** Body font */
+    body: string;
+    /** Heading font */
+    heading: string;
+    /** Monospace font */
+    mono: string;
+}
+/** Color configuration */
+interface ColorConfig {
+    /** Primary color */
+    primary: string;
+    /** Border color */
+    border: string;
+    /** Background color */
+    background: string;
+    /** Label background color */
+    labelBackground: string;
+    /** Text color */
+    text: string;
+    /** Secondary text color */
+    textSecondary: string;
+}
+/** Spacing configuration */
+interface SpacingConfig {
+    /** Page margin */
+    pageMargin: string;
+    /** Section gap */
+    sectionGap: string;
+    /** Cell padding */
+    cellPadding: string;
+    /** Header bottom margin */
+    headerMarginBottom: string;
+    /** Department name top margin */
+    departmentMarginTop: string;
+    /** Form title top margin */
+    titleMarginTop: string;
+    /** Signature area gap */
+    signatureGap: string;
+    /** Signature area top margin */
+    signatureMarginTop: string;
+    /** Signature line minimum width */
+    signatureLineWidth: string;
+    /** Free text minimum height */
+    freeTextMinHeight: string;
+    /** Footer top margin */
+    footerMarginTop: string;
+    /** Extra small spacing (2mm) */
+    xs: string;
+    /** Small spacing (3mm) */
+    sm: string;
+}
+/** Font size configuration */
+interface FontSizeConfig {
+    /** Hospital name */
+    hospitalName: string;
+    /** Form title */
+    formTitle: string;
+    /** Section title */
+    sectionTitle: string;
+    /** Body text */
+    body: string;
+    /** Small text */
+    small: string;
+}
+/** Theme configuration */
+interface Theme {
+    /** Fonts */
+    fonts: FontConfig;
+    /** Colors */
+    colors: ColorConfig;
+    /** Spacing */
+    spacing: SpacingConfig;
+    /** Font sizes */
+    fontSize: FontSizeConfig;
+    /** Border width */
+    borderWidth: string;
+}
+/**
+ * Size multipliers configuration (for base unit system)
+ * All values are multipliers relative to the base unit
+ */
+interface SizeMultipliers {
+    /** Font size multipliers */
+    fontSize: {
+        /** Body font size multiplier */
+        body: number;
+        /** Small font size multiplier */
+        small: number;
+        /** Section title multiplier */
+        sectionTitle: number;
+        /** Hospital name multiplier */
+        hospitalName: number;
+        /** Form title multiplier */
+        formTitle: number;
+    };
+    /** Line height multiplier (relative to font size) */
+    lineHeight: number;
+    /** Spacing multipliers */
+    spacing: {
+        /** Page margin multiplier */
+        pageMargin: number;
+        /** Section gap multiplier */
+        sectionGap: number;
+        /** Cell horizontal padding multiplier */
+        cellPaddingX: number;
+        /** Cell vertical padding multiplier */
+        cellPaddingY: number;
+        /** Header bottom margin multiplier */
+        headerMarginBottom: number;
+        /** Department name top margin multiplier */
+        departmentMarginTop: number;
+        /** Form title top margin multiplier */
+        titleMarginTop: number;
+        /** Signature area gap multiplier */
+        signatureGap: number;
+        /** Signature area top margin multiplier */
+        signatureMarginTop: number;
+        /** Signature line minimum width multiplier */
+        signatureLineWidth: number;
+        /** Free text minimum height multiplier */
+        freeTextMinHeight: number;
+        /** Footer top margin multiplier */
+        footerMarginTop: number;
+        /** Extra small spacing multiplier */
+        xs: number;
+        /** Small spacing multiplier */
+        sm: number;
+    };
+    /** Border width multiplier */
+    borderWidth: number;
+}
+/**
+ * Scaled theme configuration
+ * Contains base unit and multiplier configuration for generating final Theme
+ */
+interface ScaledThemeConfig {
+    /** Base unit value (millimeters) */
+    baseUnit: number;
+    /** Size multiplier configuration */
+    multipliers: SizeMultipliers;
+    /** Font configuration */
+    fonts: FontConfig;
+    /** Color configuration */
+    colors: ColorConfig;
+}
+
+/** Date format options */
+interface DateFormatOptions {
+    /** Date format */
+    dateFormat?: string;
+    /** Time format */
+    timeFormat?: string;
+    /** DateTime format */
+    dateTimeFormat?: string;
+}
+/** Render options */
+interface RenderOptions {
+    /** Theme configuration */
+    theme?: Partial<Theme>;
+    /** Locale */
+    locale?: string;
+    /** Date format options */
+    dateFormat?: DateFormatOptions;
+    /** Empty value placeholder */
+    emptyPlaceholder?: string;
+    /** Custom formatters */
+    formatters?: Record<string, (value: unknown) => string>;
+    /** CSS class name prefix (for isolation mode) */
+    classPrefix?: string;
+}
+/** PDF generation options */
+interface PdfOptions extends RenderOptions {
+    /** Watermark text */
+    watermark?: string;
+    /** Watermark opacity (0-1) */
+    watermarkOpacity?: number;
+    /** Whether to generate PDF/A format */
+    pdfA?: boolean;
+}
+/** PDF merge options */
+interface MergeOptions {
+    /** Whether to generate table of contents */
+    tableOfContents?: boolean;
+    /** Section divider titles */
+    sectionDividers?: boolean;
+}
+/** Merge document item */
+interface MergeDocumentItem {
+    /** Print configuration */
+    schema: PrintSchema;
+    /** Form data */
+    data: FormData;
+    /** Document title (for table of contents) */
+    title?: string;
+}
+
+/**
+ * @fileoverview Watermark rendering utility functions
+ * @module utils/watermark
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ *
+ * @description
+ * Provides unified watermark rendering functionality, ensuring all renderers use consistent watermark implementation.
+ * Supports opacity settings and boundary checking.
+ *
+ * @usedBy
+ * - ../renderer/isolated-html-renderer.ts - Isolated mode renderer
+ * - ../pagination/paginated-renderer.ts - Paginated renderer
+ * - ../renderer/templates/index.ts - Template renderer base class
+ */
+/**
+ * Watermark configuration options
+ */
+interface WatermarkOptions {
+    /** Watermark text */
+    text?: string;
+    /** Opacity (0-1), values outside range will be clamped */
+    opacity?: number;
+    /** CSS class name, defaults to 'watermark' */
+    className?: string;
+}
+/**
+ * Clamp a value within specified range
+ * @param value - Input value
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ */
+declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Safely handle opacity value
+ * @param opacity - Original opacity value
+ * @returns Processed opacity value (0-1 range), undefined means no setting
+ */
+declare function normalizeOpacity(opacity?: number): number | undefined;
+/**
+ * Render watermark HTML
+ *
+ * @param options - Watermark configuration options
+ * @returns Watermark HTML string, returns empty string when no watermark
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * renderWatermarkHtml({ text: 'Internal Use Only' })
+ * // => '<div class="watermark">Internal Use Only</div>'
+ *
+ * // With opacity
+ * renderWatermarkHtml({ text: 'Draft', opacity: 0.5 })
+ * // => '<div class="watermark" style="opacity: 0.5">Draft</div>'
+ *
+ * // Custom class name (for namespacing)
+ * renderWatermarkHtml({ text: 'Draft', className: 'mpr-watermark' })
+ * // => '<div class="mpr-watermark">Draft</div>'
+ *
+ * // Opacity boundary handling
+ * renderWatermarkHtml({ text: 'Test', opacity: 1.5 })
+ * // => '<div class="watermark" style="opacity: 1">Test</div>'
+ * ```
+ */
+declare function renderWatermarkHtml(options: WatermarkOptions): string;
+/**
+ * Extract watermark configuration from render options
+ * Used for compatibility with existing RenderOptions interface
+ *
+ * @param options - Options object containing watermark configuration
+ * @returns Watermark configuration options
+ */
+declare function extractWatermarkOptions(options?: {
+    watermark?: string;
+    watermarkOpacity?: number;
+}, className?: string): WatermarkOptions;
+
+/**
+ * @fileoverview Type-safe HTML builder
+ * @module utils/html-builder
+ * @description Provides chainable API for building HTML elements with unified HTML escaping
+ *
+ * @example
+ * // Basic usage
+ * const html = h('div').class('container').child('Hello').build()
+ * // => '<div class="container">Hello</div>'
+ *
+ * // Nested elements
+ * const html = h('table').child(
+ *   h('tr').child(
+ *     h('td').text('Cell 1'),
+ *     h('td').text('Cell 2')
+ *   )
+ * ).build()
+ */
+/** HTML attribute value type */
+type AttributeValue$1 = string | number | boolean | undefined | null;
+/** Child element type */
+type ChildElement$1 = string | HtmlBuilder | undefined | null | false;
+/**
+ * Escape HTML special characters
+ * @param str - String to escape
+ * @returns Escaped string
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Escape HTML attribute value
+ * @param value - Attribute value
+ * @returns Escaped string
+ */
+declare function escapeAttr(value: string): string;
+/**
+ * HTML builder class
+ * Provides chainable API for building HTML elements
+ */
+declare class HtmlBuilder {
+    private tagName;
+    private attributes;
+    private classNames;
+    private styles;
+    private children;
+    private rawContent;
+    constructor(tag: string);
+    /**
+     * Set attribute
+     * @param name - Attribute name
+     * @param value - Attribute value (undefined/null/false will skip the attribute)
+     */
+    attr(name: string, value: AttributeValue$1): this;
+    /**
+     * Set multiple attributes
+     * @param attrs - Attributes object
+     */
+    attrs(attrs: Record<string, AttributeValue$1>): this;
+    /**
+     * Add CSS class names
+     * @param names - Class names (supports multiple arguments or space-separated)
+     */
+    class(...names: (string | undefined | null | false)[]): this;
+    /**
+     * Set ID
+     * @param id - Element ID
+     */
+    id(id: string): this;
+    /**
+     * Set single style
+     * @param property - CSS property name
+     * @param value - CSS property value
+     */
+    style(property: string, value: string | undefined | null): this;
+    /**
+     * Set multiple styles
+     * @param styles - Styles object
+     */
+    css(styles: Record<string, string | undefined | null>): this;
+    /**
+     * Add child elements (auto-escapes text)
+     * @param children - Child elements
+     */
+    child(...children: ChildElement$1[]): this;
+    /**
+     * Add text content (auto-escaped)
+     * @param text - Text content
+     */
+    text(text: string | number | undefined | null): this;
+    /**
+     * Add raw HTML (not escaped)
+     * @param html - Raw HTML string
+     */
+    raw(html: string): this;
+    /**
+     * Conditional rendering
+     * @param condition - Condition
+     * @param builder - Builder function to execute when condition is true
+     */
+    when(condition: boolean, builder: (b: this) => void): this;
+    /**
+     * Build HTML string
+     * @returns HTML string
+     */
+    build(): string;
+    /**
+     * Convert to string (equivalent to build)
+     */
+    toString(): string;
+}
+/**
+ * Create HTML element builder
+ * @param tag - Tag name
+ * @returns HtmlBuilder instance
+ *
+ * @example
+ * h('div').class('container').text('Hello').build()
+ */
+declare function h(tag: string): HtmlBuilder;
+/**
+ * Create document fragment (container for multiple elements)
+ * @param children - Child elements
+ * @returns HTML string
+ */
+declare function fragment(...children: ChildElement$1[]): string;
+/**
+ * Conditional rendering
+ * @param condition - Condition
+ * @param content - Content when condition is true
+ * @param fallback - Content when condition is false (optional)
+ */
+declare function when(condition: boolean, content: ChildElement$1 | (() => ChildElement$1), fallback?: ChildElement$1 | (() => ChildElement$1)): string;
+/**
+ * List rendering
+ * @param items - Data array
+ * @param renderer - Render function
+ * @returns HTML string
+ */
+declare function each<T>(items: T[] | undefined | null, renderer: (item: T, index: number) => ChildElement$1): string;
+
+/**
+ * @fileoverview HTML Rendering Core
+ * @module renderer/html-renderer
+ */
+
+/**
+ * Render PrintSchema and FormData to a complete HTML document
+ *
+ * This is the main rendering function that generates a complete HTML document
+ * with embedded CSS styles, ready for printing or PDF generation.
+ *
+ * @param schema - Print layout configuration defining page size, header, sections, and footer
+ * @param data - Form data object containing field values
+ * @param options - Optional render configuration
+ * @param options.theme - Custom theme configuration for fonts, colors, and spacing
+ * @param options.watermark - Watermark text to display on the page
+ * @param options.watermarkOpacity - Watermark opacity (0-1)
+ * @returns Complete HTML document string including DOCTYPE, head, and body
+ *
+ * @example
+ * ```typescript
+ * import { renderToHtml } from 'medical-form-printer'
+ *
+ * const html = renderToHtml(printSchema, formData, {
+ *   watermark: 'Internal Use Only',
+ *   watermarkOpacity: 0.1,
+ *   theme: {
+ *     colors: { primary: '#1a1a1a' }
+ *   }
+ * })
+ *
+ * // Display in iframe or use for PDF generation
+ * document.getElementById('preview').innerHTML = html
+ * ```
+ */
+declare function renderToHtml(schema: PrintSchema, data: FormData, options?: RenderOptions & {
+    watermark?: string;
+    watermarkOpacity?: number;
+}): string;
+
+/**
+ * @fileoverview Isolated Mode HTML Renderer
+ * @module renderer/isolated-html-renderer
+ * @version 1.1.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-03
+ *
+ * @description
+ * Generates HTML output with CSS isolation, ensuring:
+ * 1. All class names have mpr- prefix
+ * 2. Styles are completely isolated from external influence
+ * 3. Font is forced to use Source Han Serif SC
+ *
+ * @dependencies
+ * - ../types/print-schema - Print configuration types
+ * - ../types/options - Render options types
+ * - ../styles - Style system
+ * - ./section-renderers - Section renderers
+ * - ../utils - Utility functions
+ *
+ * @usedBy
+ * - ../index.ts - Library main entry
+ */
+
+/**
+ * Isolated render options
+ */
+interface IsolatedRenderOptions extends RenderOptions {
+    /** Watermark text */
+    watermark?: string;
+    /** Watermark opacity (0-1), values outside range will be clamped */
+    watermarkOpacity?: number;
+}
+/**
+ * Render PrintSchema and FormData to isolated HTML string
+ *
+ * @param schema - Print layout configuration
+ * @param data - Form data
+ * @param options - Render options (font configuration will be ignored)
+ * @returns Complete isolated HTML document
+ *
+ * @description
+ * Generated HTML has the following characteristics:
+ * 1. All content wrapped in .mpr-root isolation container
+ * 2. CSS embedded in <style> tag within isolation container
+ * 3. All class names have mpr- prefix
+ * 4. Font forced to use embedded Source Han Serif SC
+ *
+ * @example
+ * ```typescript
+ * const html = renderToIsolatedHtml(schema, data)
+ * // Output HTML styles are completely isolated, safe to embed in any page
+ * ```
+ */
+declare function renderToIsolatedHtml(schema: PrintSchema, data: FormData, options?: IsolatedRenderOptions): string;
+/**
+ * Render isolated HTML fragment (without DOCTYPE and html/head/body tags)
+ * Suitable for embedding into existing pages
+ *
+ * @param schema - Print layout configuration
+ * @param data - Form data
+ * @param options - Render options
+ * @returns Isolated HTML fragment
+ */
+declare function renderToIsolatedFragment(schema: PrintSchema, data: FormData, options?: IsolatedRenderOptions): string;
+
+/**
+ * @fileoverview Section renderer registry
+ * @module renderer/section-renderers
+ * @modified 2024-04-06
+ */
+
+/**
+ * Section renderer function type
+ *
+ * A function that takes section configuration, form data, and optional render options,
+ * and returns an HTML string representing the rendered section.
+ *
+ * @param config - The section configuration object
+ * @param data - The form data containing field values
+ * @param options - Optional render options (theme, locale, formatters, etc.)
+ * @returns HTML string for the rendered section
+ */
+type SectionRenderer = (config: SectionConfig, data: FormData, options?: RenderOptions) => string;
+/**
+ * Register a custom section renderer for a new section type
+ *
+ * @param type - The section type identifier (e.g., 'custom-chart', 'vital-signs')
+ * @param renderer - The renderer function that generates HTML for this section type
+ * @returns void
+ *
+ * @example
+ * ```typescript
+ * registerSectionRenderer('vital-signs-chart', (config, data, options) => {
+ *   const values = data[config.dataField] || []
+ *   return `<div class="vital-signs-chart">...</div>`
+ * })
+ * ```
+ */
+declare function registerSectionRenderer(type: string, renderer: SectionRenderer): void;
+/**
+ * Get a registered section renderer by type
+ *
+ * @param type - The section type identifier
+ * @returns The renderer function if found, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const renderer = getSectionRenderer('info-grid')
+ * if (renderer) {
+ *   const html = renderer(config, data, options)
+ * }
+ * ```
+ */
+declare function getSectionRenderer(type: string): SectionRenderer | undefined;
+
+/**
+ * @fileoverview Default Strategy Context
+ * @module renderer/strategies/default-context
+ */
+
+/**
+ * Create default strategy context
+ * Contains render strategies for all built-in section types
+ * @returns Configured strategy context
+ */
+declare function createDefaultStrategyContext(): StrategyContext;
+
+/**
+ * @fileoverview Section render strategy module
+ * @module renderer/strategies
+ *
+ * @description
+ * Implements section rendering using Strategy pattern.
+ * Each section type has an independent strategy class, unified dispatch through StrategyContext.
+ */
+
+/**
+ * Section render strategy interface
+ * All section renderers must implement this interface
+ */
+interface SectionRenderStrategy {
+    /** Section type supported by this strategy */
+    readonly type: string;
+    /**
+     * Render section
+     * @param config - Section configuration
+     * @param data - Form data
+     * @param options - Render options
+     * @returns HTML string
+     */
+    render(config: SectionConfig, data: FormData, options?: RenderOptions): string;
+}
+/**
+ * Strategy context
+ * Manages all section render strategies, selects appropriate strategy based on section type
+ */
+declare class StrategyContext {
+    private strategies;
+    /**
+     * Register render strategy
+     * @param strategy - Render strategy instance
+     */
+    register(strategy: SectionRenderStrategy): void;
+    /**
+     * Batch register render strategies
+     * @param strategies - Array of render strategy instances
+     */
+    registerAll(strategies: SectionRenderStrategy[]): void;
+    /**
+     * Get render strategy
+     * @param type - Section type
+     * @returns Render strategy instance, undefined if not found
+     */
+    getStrategy(type: string): SectionRenderStrategy | undefined;
+    /**
+     * Check if type is supported
+     * @param type - Section type
+     * @returns Whether supported
+     */
+    hasStrategy(type: string): boolean;
+    /**
+     * Render section
+     * @param type - Section type
+     * @param config - Section configuration
+     * @param data - Form data
+     * @param options - Render options
+     * @returns HTML string
+     */
+    render(type: string, config: SectionConfig, data: FormData, options?: RenderOptions): string;
+    /**
+     * Get all registered strategy types
+     * @returns Array of strategy types
+     */
+    getRegisteredTypes(): string[];
+}
+
+/**
+ * @fileoverview Section Renderer Factory
+ * @module renderer/factory/section-renderer-factory
+ *
+ * @description
+ * Uses Factory pattern to create section renderer instances.
+ * Supports registering custom renderers for decoupling and extensibility.
+ */
+
+/** Renderer creator function type */
+type RendererCreator = () => SectionRenderStrategy;
+/**
+ * Section Renderer Factory
+ * Responsible for creating and managing section renderer instances
+ */
+declare class SectionRendererFactory {
+    private creators;
+    private instances;
+    private useCache;
+    /**
+     * Create factory instance
+     * @param useCache - Whether to cache renderer instances (default true)
+     */
+    constructor(useCache?: boolean);
+    /**
+     * Register built-in renderers
+     */
+    private registerBuiltInRenderers;
+    /**
+     * Register renderer creator function
+     * @param type - Section type
+     * @param creator - Creator function
+     */
+    register(type: string, creator: RendererCreator): void;
+    /**
+     * Register custom renderer instance
+     * @param renderer - Renderer instance
+     */
+    registerInstance(renderer: SectionRenderStrategy): void;
+    /**
+     * Create renderer instance
+     * @param type - Section type
+     * @returns Renderer instance, or undefined if type doesn't exist
+     */
+    create(type: string): SectionRenderStrategy | undefined;
+    /**
+     * Check if specified type is supported
+     * @param type - Section type
+     * @returns Whether supported
+     */
+    hasRenderer(type: string): boolean;
+    /**
+     * Get all registered types
+     * @returns Type array
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Render section
+     * @param type - Section type
+     * @param config - Section configuration
+     * @param data - Form data
+     * @param options - Render options
+     * @returns HTML string
+     */
+    render(type: string, config: SectionConfig, data: FormData, options?: RenderOptions): string;
+    /**
+     * Clear cached instances
+     */
+    clearCache(): void;
+}
+/**
+ * Get default factory instance (singleton)
+ * @returns Default factory instance
+ */
+declare function getDefaultSectionRendererFactory(): SectionRendererFactory;
+
+/**
+ * @fileoverview Formatter Factory
+ * @module renderer/factory/formatter-factory
+ *
+ * @description
+ * Uses Factory pattern to create data formatter instances.
+ * Supports registering custom formatters for decoupling and extensibility.
+ */
+/** Formatter function type */
+type Formatter<T = unknown> = (value: T, options?: Record<string, unknown>) => string;
+/** Formatter configuration */
+interface FormatterConfig {
+    /** Date format */
+    dateFormat?: string;
+    /** Empty value placeholder */
+    emptyPlaceholder?: string;
+    /** Number precision */
+    numberPrecision?: number;
+    /** Boolean true value display */
+    booleanTrueSymbol?: string;
+    /** Boolean false value display */
+    booleanFalseSymbol?: string;
+}
+/**
+ * Formatter Factory
+ * Responsible for creating and managing data formatters
+ */
+declare class FormatterFactory {
+    private formatters;
+    private config;
+    /**
+     * Create factory instance
+     * @param config - Formatter configuration
+     */
+    constructor(config?: FormatterConfig);
+    /**
+     * Register built-in formatters
+     */
+    private registerBuiltInFormatters;
+    /**
+     * Register formatter
+     * @param type - Formatter type
+     * @param formatter - Formatter function
+     */
+    register(type: string, formatter: Formatter): void;
+    /**
+     * Get formatter
+     * @param type - Formatter type
+     * @returns Formatter function, or undefined if not found
+     */
+    get(type: string): Formatter | undefined;
+    /**
+     * Check if formatter of specified type exists
+     * @param type - Formatter type
+     * @returns Whether exists
+     */
+    has(type: string): boolean;
+    /**
+     * Format value
+     * @param value - Value to format
+     * @param type - Formatter type
+     * @returns Formatted string
+     */
+    format(value: unknown, type?: string): string;
+    /**
+     * Get all registered formatter types
+     * @returns Type array
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Update configuration
+     * @param config - New configuration
+     */
+    updateConfig(config: Partial<FormatterConfig>): void;
+    /**
+     * Get current configuration
+     * @returns Current configuration
+     */
+    getConfig(): FormatterConfig;
+}
+/**
+ * Get default factory instance (singleton)
+ * @returns Default factory instance
+ */
+declare function getDefaultFormatterFactory(): FormatterFactory;
+
+/**
+ * @fileoverview HTML Element Builder
+ * @module renderer/builders/html-element-builder
+ *
+ * @description
+ * Uses Builder pattern to chain-build HTML elements.
+ * Supports fluent API: builder.tag('div').class('foo').child(...).build()
+ */
+/** Attribute value type */
+type AttributeValue = string | number | boolean | undefined | null;
+/** Child element type */
+type ChildElement = string | HtmlElementBuilder | undefined | null | false;
+/**
+ * HTML Element Builder
+ * Provides fluent API for building HTML elements
+ */
+declare class HtmlElementBuilder {
+    private tagName;
+    private attributes;
+    private classNames;
+    private styles;
+    private children;
+    private rawContent;
+    /**
+     * Create builder instance
+     * @param tag - Tag name
+     */
+    constructor(tag: string);
+    /**
+     * Create new builder instance
+     * @param tag - Tag name
+     * @returns New builder instance
+     */
+    static tag(tag: string): HtmlElementBuilder;
+    /**
+     * Set attribute
+     * @param name - Attribute name
+     * @param value - Attribute value
+     */
+    attr(name: string, value: AttributeValue): this;
+    /**
+     * Set multiple attributes
+     * @param attrs - Attributes object
+     */
+    attrs(attrs: Record<string, AttributeValue>): this;
+    /**
+     * Add CSS class names
+     * @param names - Class names
+     */
+    class(...names: (string | undefined | null | false)[]): this;
+    /**
+     * Set ID
+     * @param id - Element ID
+     */
+    id(id: string): this;
+    /**
+     * Set single style
+     * @param property - CSS property name
+     * @param value - CSS property value
+     */
+    style(property: string, value: string | undefined | null): this;
+    /**
+     * Set multiple styles
+     * @param styles - Styles object
+     */
+    css(styles: Record<string, string | undefined | null>): this;
+    /**
+     * Add child elements
+     * @param children - Child elements
+     */
+    child(...children: ChildElement[]): this;
+    /**
+     * Add text content (auto-escaped)
+     * @param text - Text content
+     */
+    text(text: string | number | undefined | null): this;
+    /**
+     * Add raw HTML (not escaped)
+     * @param html - Raw HTML string
+     */
+    raw(html: string): this;
+    /**
+     * Conditional rendering
+     * @param condition - Condition
+     * @param builder - Builder function to execute when condition is true
+     */
+    when(condition: boolean, builder: (b: this) => void): this;
+    /**
+     * Build HTML string
+     * @returns HTML string
+     */
+    build(): string;
+    /**
+     * Convert to string
+     */
+    toString(): string;
+}
+declare const div: () => HtmlElementBuilder;
+declare const span: () => HtmlElementBuilder;
+declare const table: () => HtmlElementBuilder;
+declare const thead: () => HtmlElementBuilder;
+declare const tbody: () => HtmlElementBuilder;
+declare const tr: () => HtmlElementBuilder;
+declare const th: () => HtmlElementBuilder;
+declare const td: () => HtmlElementBuilder;
+declare const p: () => HtmlElementBuilder;
+declare const header: () => HtmlElementBuilder;
+declare const footer: () => HtmlElementBuilder;
+declare const main: () => HtmlElementBuilder;
+declare const h1: () => HtmlElementBuilder;
+
+/**
+ * @fileoverview Page Builder
+ * @module renderer/builders/page-builder
+ *
+ * @description
+ * Uses Builder pattern to construct complete print page structure.
+ * Supports header, content, footer, watermark and other components.
+ */
+/** Page configuration */
+interface PageConfig {
+    /** Page size */
+    pageSize: string;
+    /** Page orientation */
+    orientation: string;
+    /** Language */
+    lang?: string;
+}
+/** Header configuration */
+interface HeaderConfig {
+    /** Hospital name */
+    hospital: string;
+    /** Department name */
+    department?: string;
+    /** Form title */
+    title: string;
+    /** Whether to show logo */
+    showLogo?: boolean;
+    /** Logo URL */
+    logoUrl?: string;
+}
+/** Footer configuration */
+interface FooterConfig {
+    /** Notes */
+    notes?: string;
+    /** Whether to show page number */
+    showPageNumber?: boolean;
+    /** Page number format */
+    pageNumberFormat?: string;
+}
+/**
+ * Page Builder
+ * Constructs complete print page structure
+ */
+declare class PageBuilder {
+    private config;
+    private css;
+    private headerConfig;
+    private footerConfig;
+    private sections;
+    private watermarkText;
+    private watermarkOpacity;
+    /**
+     * Create page builder
+     * @param config - Page configuration
+     */
+    constructor(config: PageConfig);
+    /**
+     * Set CSS styles
+     * @param css - CSS string
+     */
+    setCSS(css: string): this;
+    /**
+     * Set header
+     * @param config - Header configuration
+     */
+    setHeader(config: HeaderConfig): this;
+    /**
+     * Set footer
+     * @param config - Footer configuration
+     */
+    setFooter(config: FooterConfig | null): this;
+    /**
+     * Add section content
+     * @param html - Section HTML
+     */
+    addSection(html: string): this;
+    /**
+     * Add multiple section contents
+     * @param htmls - Section HTML array
+     */
+    addSections(htmls: string[]): this;
+    /**
+     * Set watermark
+     * @param text - Watermark text
+     * @param opacity - Opacity
+     */
+    setWatermark(text: string, opacity?: number): this;
+    /**
+     * Build header HTML
+     */
+    private buildHeader;
+    /**
+     * Build footer HTML
+     */
+    private buildFooter;
+    /**
+     * Build watermark HTML
+     */
+    private buildWatermark;
+    /**
+     * Build page class names
+     */
+    private buildPageClasses;
+    /**
+     * Build complete page HTML
+     * @returns Complete HTML document string
+     */
+    build(): string;
+}
+
+/**
+ * @fileoverview Table Builder
+ * @module renderer/builders/table-builder
+ *
+ * @description
+ * Uses Builder pattern to construct HTML table structure.
+ * Supports header, body, row numbers, column widths and other configurations.
+ */
+/** Column configuration */
+interface ColumnConfig {
+    /** Column header */
+    header: string;
+    /** Data field */
+    field: string;
+    /** Column width */
+    width?: string;
+    /** Alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Formatter function */
+    formatter?: (value: unknown, row: Record<string, unknown>, index: number) => string;
+}
+/** Table configuration */
+interface TableConfig {
+    /** Whether to show row numbers */
+    showRowNumber?: boolean;
+    /** Row number column header */
+    rowNumberHeader?: string;
+    /** Table class name */
+    className?: string;
+    /** Whether to show borders */
+    bordered?: boolean;
+}
+/**
+ * Table Builder
+ * Constructs HTML table structure
+ */
+declare class TableBuilder {
+    private columns;
+    private rows;
+    private config;
+    private headerRows;
+    private footerRows;
+    /**
+     * Create table builder
+     * @param config - Table configuration
+     */
+    constructor(config?: TableConfig);
+    /**
+     * Set configuration
+     * @param config - Table configuration
+     */
+    setConfig(config: TableConfig): this;
+    /**
+     * Add column
+     * @param column - Column configuration
+     */
+    addColumn(column: ColumnConfig): this;
+    /**
+     * Add multiple columns
+     * @param columns - Column configuration array
+     */
+    addColumns(columns: ColumnConfig[]): this;
+    /**
+     * Set data rows
+     * @param rows - Data row array
+     */
+    setRows(rows: Record<string, unknown>[]): this;
+    /**
+     * Add data row
+     * @param row - Data row
+     */
+    addRow(row: Record<string, unknown>): this;
+    /**
+     * Add custom header row
+     * @param cells - Cell content array
+     */
+    addHeaderRow(cells: string[]): this;
+    /**
+     * Add custom footer row
+     * @param cells - Cell content array
+     */
+    addFooterRow(cells: string[]): this;
+    /**
+     * Build header HTML
+     */
+    private buildHeader;
+    /**
+     * Build body HTML
+     */
+    private buildBody;
+    /**
+     * Build footer HTML
+     */
+    private buildFooter;
+    /**
+     * Build table HTML
+     * @returns Table HTML string
+     */
+    build(): string;
+    /**
+     * Build table element only (without wrapper div)
+     * @returns Table HTML string
+     */
+    buildTable(): string;
+}
+
+/**
+ * @fileoverview Composite pattern - Section nesting
+ * @module renderer/composite
+ *
+ * @description
+ * Uses Composite pattern to uniformly handle single sections and nested sections.
+ * SectionComponent interface defines unified render method,
+ * LeafSection handles leaf nodes, ContainerSection handles container nodes.
+ */
+
+/**
+ * Section component interface (Composite pattern's Component)
+ * Defines unified render method, both leaf and container nodes implement this interface
+ */
+interface SectionComponent {
+    /** Render component */
+    render(data: FormData, options?: RenderOptions): string;
+    /** Get component type */
+    getType(): SectionType;
+    /** Whether this is a container node */
+    isContainer(): boolean;
+}
+/**
+ * Leaf section (Composite pattern's Leaf)
+ * Handles section types without child nodes: info-grid, table, checkbox-grid, etc.
+ */
+declare class LeafSection implements SectionComponent {
+    private type;
+    private config;
+    constructor(type: SectionType, config: SectionConfig);
+    render(data: FormData, options?: RenderOptions): string;
+    getType(): SectionType;
+    isContainer(): boolean;
+    getConfig(): SectionConfig;
+}
+/**
+ * Container section (Composite pattern's Composite)
+ * Handles section types with child nodes: container, inline-row
+ */
+declare class ContainerSection implements SectionComponent {
+    private type;
+    private config;
+    private children;
+    constructor(type: SectionType, config: ContainerConfig | InlineRowConfig);
+    render(data: FormData, options?: RenderOptions): string;
+    getType(): SectionType;
+    isContainer(): boolean;
+    getConfig(): ContainerConfig | InlineRowConfig;
+    getChildren(): SectionComponent[];
+    addChild(child: SectionComponent): void;
+    removeChild(child: SectionComponent): void;
+    /**
+     * Recursively render all child nodes
+     * @param data - Form data
+     * @param options - Render options
+     * @returns Array of child node HTML strings
+     */
+    renderChildren(data: FormData, options?: RenderOptions): string[];
+}
+/**
+ * Create section component from PrintSection
+ * @param section - Print section configuration
+ * @returns Section component instance
+ */
+declare function createSectionComponent(section: PrintSection): SectionComponent;
+/**
+ * Section tree traverser
+ * Provides depth-first traversal capability for section tree
+ */
+declare class SectionTreeTraverser {
+    /**
+     * Depth-first traversal
+     * @param root - Root component
+     * @param visitor - Visitor function
+     */
+    traverse(root: SectionComponent, visitor: (component: SectionComponent, depth: number) => void): void;
+    private traverseInternal;
+    /**
+     * Collect all leaf nodes
+     * @param root - Root component
+     * @returns Array of leaf nodes
+     */
+    collectLeaves(root: SectionComponent): LeafSection[];
+    /**
+     * Calculate tree depth
+     * @param root - Root component
+     * @returns Maximum depth of tree
+     */
+    getDepth(root: SectionComponent): number;
+}
+/**
+ * Create section component tree from PrintSection array
+ * @param sections - Print section configuration array
+ * @returns Section component array
+ */
+declare function createSectionTree(sections: PrintSection[]): SectionComponent[];
+/**
+ * Render section component tree
+ * @param components - Section component array
+ * @param data - Form data
+ * @param options - Render options
+ * @returns HTML string
+ */
+declare function renderSectionTree(components: SectionComponent[], data: FormData, options?: RenderOptions): string;
+
+/**
+ * @fileoverview Template Method Pattern - Page Rendering Flow
+ * @module renderer/templates
+ * @version 1.2.0
+ * @author Kiro
+ * @modified 2026-01-03
+ *
+ * @description
+ * Uses Template Method pattern to define the skeleton flow for page rendering.
+ * AbstractPageRenderer defines rendering steps: renderHeader → renderBody → renderFooter
+ * Subclasses implement specific steps: SinglePageRenderer, PaginatedPageRenderer
+ *
+ * v1.2.0 optimizations:
+ * - Enhanced type safety, introduced PaginatedPageContext to eliminate non-null assertions
+ * - Extracted page number formatting as configurable option
+ * - Extracted common footer rendering logic
+ * - Added formatPageNumber utility function
+ *
+ * v1.1.0 optimizations:
+ * - Extracted common header rendering logic to base class
+ * - Extracted CSS class name constants
+ * - Improved type safety (watermark options type guard)
+ * - Reduced duplicate code in subclasses
+ */
+
+/**
+ * Page render context (base)
+ * Contains all data needed during rendering
+ */
+interface PageRenderContext {
+    schema: PrintSchema;
+    data: FormData;
+    options?: RenderOptions | PdfOptions;
+    pageNumber?: number;
+    totalPages?: number;
+}
+/**
+ * Paginated render context (type-safe)
+ * pageNumber and totalPages are required, eliminating non-null assertions
+ */
+interface PaginatedPageContext extends PageRenderContext {
+    pageNumber: number;
+    totalPages: number;
+}
+/**
+ * Abstract page renderer (Template Method pattern's AbstractClass)
+ * Defines page rendering skeleton, subclasses implement specific steps
+ */
+declare abstract class AbstractPageRenderer {
+    /**
+     * Render page (Template Method)
+     * Defines rendering flow: renderHeader → renderBody → renderFooter
+     * @param context - Render context
+     * @returns HTML string
+     */
+    render(context: PageRenderContext): string;
+    /**
+     * Render page start tag
+     * @param _context - Render context (reserved for subclass override)
+     */
+    protected renderPageStart(_context: PageRenderContext): string;
+    /**
+     * Render page end tag
+     * @param _context - Render context (reserved for subclass override)
+     */
+    protected renderPageEnd(_context: PageRenderContext): string;
+    /**
+     * Render header (abstract method, subclass must implement)
+     * @param context - Render context
+     */
+    protected abstract renderHeader(context: PageRenderContext): string;
+    /**
+     * Render body content (abstract method, subclass must implement)
+     * @param context - Render context
+     */
+    protected abstract renderBody(context: PageRenderContext): string;
+    /**
+     * Render footer (abstract method, subclass must implement)
+     * @param context - Render context
+     */
+    protected abstract renderFooter(context: PageRenderContext): string;
+    /**
+     * Render watermark (hook method, subclass can optionally override)
+     * Uses type guard for type safety
+     * @param context - Render context
+     */
+    protected renderWatermark(context: PageRenderContext): string;
+    /**
+     * Render section list
+     * @param sections - Section configuration array
+     * @param data - Form data
+     * @param options - Render options
+     */
+    protected renderSections(sections: PrintSection[], data: FormData, options?: RenderOptions): string;
+    /**
+     * Render header content (common logic for subclass reuse)
+     * @param schema - Print configuration
+     * @param titleSuffix - Title suffix (e.g., "(continued)" for continuation pages)
+     * @returns Header content HTML array
+     */
+    protected renderHeaderContent(schema: PrintSchema, titleSuffix?: string): string[];
+    /**
+     * Render body content wrapper (common logic for subclass reuse)
+     * @param context - Render context
+     * @param sections - Sections to render
+     * @returns Body HTML
+     */
+    protected renderBodyWrapper(context: PageRenderContext, sections: PrintSection[]): string;
+}
+/**
+ * Single page renderer
+ * Renders all content to a single page
+ */
+declare class SinglePageRenderer extends AbstractPageRenderer {
+    protected renderHeader(context: PageRenderContext): string;
+    protected renderBody(context: PageRenderContext): string;
+    protected renderFooter(context: PageRenderContext): string;
+}
+/**
+ * Paginated renderer options
+ */
+interface PaginatedRenderOptions {
+    showHeaderOnEachPage?: boolean;
+    showFooterOnEachPage?: boolean;
+    showPageNumber?: boolean;
+}
+/**
+ * Paginated renderer
+ * Supports multi-page rendering with independent header/footer per page
+ */
+declare class PaginatedPageRenderer extends AbstractPageRenderer {
+    private pages;
+    private options;
+    /**
+     * Set paginated content
+     * @param pages - Array of section configurations per page
+     */
+    setPages(pages: PrintSection[][]): void;
+    /**
+     * Set pagination options
+     */
+    setOptions(options: PaginatedRenderOptions): void;
+    /**
+     * Render all pages
+     * @param context - Render context
+     * @returns HTML string
+     */
+    renderAll(context: PageRenderContext): string;
+    /**
+     * Render single page
+     * Uses PaginatedPageContext to ensure pageNumber/totalPages type safety
+     */
+    private renderPage;
+    protected renderHeader(context: PaginatedPageContext): string;
+    protected renderBody(context: PageRenderContext): string;
+    protected renderFooter(context: PaginatedPageContext): string;
+    /**
+     * Render page number only
+     */
+    private renderPageNumberOnly;
+}
+/**
+ * Create single page renderer
+ */
+declare function createSinglePageRenderer(): SinglePageRenderer;
+/**
+ * Create paginated renderer
+ */
+declare function createPaginatedPageRenderer(): PaginatedPageRenderer;
+
+/**
+ * @fileoverview Visitor pattern - Data formatting
+ * @module renderer/visitors
+ *
+ * @modified 2023.12.15
+ *
+ * @description
+ * Uses Visitor pattern to separate data traversal and operation logic.
+ * FormDataVisitor interface defines visit methods,
+ * Different Visitors implement different operations: formatting, validation, measurement, etc.
+ */
+
+/**
+ * Field information
+ */
+interface FieldInfo {
+    /** Field name */
+    name: string;
+    /** Field value */
+    value: unknown;
+    /** Field type */
+    type?: string;
+    /** Field label */
+    label?: string;
+    /** Parent section */
+    section?: PrintSection;
+}
+/**
+ * Form data visitor interface (Visitor pattern's Visitor)
+ * Defines methods for visiting different data types
+ */
+interface FormDataVisitor<T = void> {
+    /** Visit string field */
+    visitString(field: FieldInfo): T;
+    /** Visit number field */
+    visitNumber(field: FieldInfo): T;
+    /** Visit boolean field */
+    visitBoolean(field: FieldInfo): T;
+    /** Visit date field */
+    visitDate(field: FieldInfo): T;
+    /** Visit array field */
+    visitArray(field: FieldInfo): T;
+    /** Visit object field */
+    visitObject(field: FieldInfo): T;
+    /** Visit null field */
+    visitNull(field: FieldInfo): T;
+    /** Get result */
+    getResult(): T;
+}
+/**
+ * Format visitor
+ * Formats data into display strings
+ */
+declare class FormatVisitor implements FormDataVisitor<string> {
+    private results;
+    private dateFormat;
+    private booleanSymbols;
+    constructor(options?: {
+        dateFormat?: string;
+        booleanSymbols?: {
+            true: string;
+            false: string;
+        };
+    });
+    visitString(field: FieldInfo): string;
+    visitNumber(field: FieldInfo): string;
+    visitBoolean(field: FieldInfo): string;
+    visitDate(field: FieldInfo): string;
+    visitArray(field: FieldInfo): string;
+    visitObject(field: FieldInfo): string;
+    visitNull(field: FieldInfo): string;
+    getResult(): string;
+    getFormattedData(): Map<string, string>;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+/**
+ * Validation visitor
+ * Validates data integrity
+ */
+declare class ValidationVisitor implements FormDataVisitor<ValidationResult> {
+    private errors;
+    private requiredFields;
+    constructor(requiredFields?: string[]);
+    private checkRequired;
+    visitString(field: FieldInfo): ValidationResult;
+    visitNumber(field: FieldInfo): ValidationResult;
+    visitBoolean(field: FieldInfo): ValidationResult;
+    visitDate(field: FieldInfo): ValidationResult;
+    visitArray(field: FieldInfo): ValidationResult;
+    visitObject(field: FieldInfo): ValidationResult;
+    visitNull(field: FieldInfo): ValidationResult;
+    getResult(): ValidationResult;
+    reset(): void;
+}
+/**
+ * Measurement result
+ */
+interface MeasureResult {
+    /** Field name */
+    field: string;
+    /** Estimated character count */
+    charCount: number;
+    /** Estimated line count */
+    lineCount: number;
+    /** Estimated height (mm) */
+    estimatedHeight: number;
+}
+/**
+ * Measurement visitor
+ * Measures content height (for pagination calculation)
+ */
+declare class MeasureVisitor implements FormDataVisitor<MeasureResult[]> {
+    private results;
+    private lineHeight;
+    private charsPerLine;
+    constructor(options?: {
+        lineHeight?: number;
+        charsPerLine?: number;
+    });
+    private measure;
+    visitString(field: FieldInfo): MeasureResult[];
+    visitNumber(field: FieldInfo): MeasureResult[];
+    visitBoolean(field: FieldInfo): MeasureResult[];
+    visitDate(field: FieldInfo): MeasureResult[];
+    visitArray(field: FieldInfo): MeasureResult[];
+    visitObject(field: FieldInfo): MeasureResult[];
+    visitNull(field: FieldInfo): MeasureResult[];
+    getResult(): MeasureResult[];
+    getTotalHeight(): number;
+    reset(): void;
+}
+/**
+ * Data traverser
+ * Traverses form data and applies visitor
+ */
+declare class FormDataTraverser {
+    /**
+     * Traverse form data
+     * @param data - Form data
+     * @param visitor - Visitor
+     * @param sections - Section configuration (optional, for field type info)
+     */
+    traverse<T>(data: FormData, visitor: FormDataVisitor<T>, sections?: PrintSection[]): void;
+    /**
+     * Visit single field
+     */
+    private visitField;
+    /**
+     * Extract field types from section configuration
+     */
+    private extractFieldTypes;
+}
+/**
+ * Create format visitor
+ */
+declare function createFormatVisitor(options?: {
+    dateFormat?: string;
+    booleanSymbols?: {
+        true: string;
+        false: string;
+    };
+}): FormatVisitor;
+/**
+ * Create validation visitor
+ */
+declare function createValidationVisitor(requiredFields?: string[]): ValidationVisitor;
+/**
+ * Create measurement visitor
+ */
+declare function createMeasureVisitor(options?: {
+    lineHeight?: number;
+    charsPerLine?: number;
+}): MeasureVisitor;
+/**
+ * Create data traverser
+ */
+declare function createFormDataTraverser(): FormDataTraverser;
+
+/**
+ * @fileoverview Font CSS generator
+ * @module fonts/font-css
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ *
+ * @description
+ * Generates @font-face CSS declarations using embedded Base64 font data.
+ * Enforces Source Han Serif SC font and disables font synthesis.
+ *
+ * @dependencies
+ * - ./font-data - Base64 encoded font data
+ */
+/** Font family name (immutable) */
+declare const FONT_FAMILY = "Source Han Serif SC";
+/** Font weight */
+declare const FONT_WEIGHT = 400;
+/** Font style */
+declare const FONT_STYLE = "normal";
+/**
+ * Get font Data URL
+ * @returns woff2 format data URL
+ */
+declare function getFontDataUrl(): string;
+/**
+ * Get complete font CSS (includes @font-face and override rules)
+ * @returns Complete font CSS string
+ */
+declare function getFontCss(): string;
+
+/**
+ * @fileoverview Font loading state management
+ * @module fonts/font-loader
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ *
+ * @description
+ * Provides font loading state checking and waiting functionality.
+ * Uses FontFace API in browser environment, returns success directly in Node.js environment.
+ *
+ * @dependencies
+ * - ./font-css - Font configuration constants
+ * - ./font-data - Base64 encoded font data
+ */
+/** Font load options */
+interface FontLoadOptions {
+    /** Timeout in milliseconds, default 5000 */
+    timeout?: number;
+}
+/** Font load error */
+declare class FontLoadError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Check if font is loaded (synchronous)
+ *
+ * @returns Font loading status
+ * - In Node.js environment, always returns true (font is embedded, no loading needed)
+ * - In browser environment, returns actual loading status
+ */
+declare function isFontLoaded(): boolean;
+/**
+ * Wait for fonts to load
+ *
+ * @param options - Load options
+ * @returns Promise that resolves when font is loaded
+ * @throws {FontLoadError} Rejects on timeout or load failure
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await waitForFonts({ timeout: 3000 })
+ *   console.log('Font loaded successfully')
+ * } catch (error) {
+ *   if (error instanceof FontLoadError) {
+ *     console.error('Font loading failed:', error.message)
+ *   }
+ * }
+ * ```
+ */
+declare function waitForFonts(options?: FontLoadOptions): Promise<void>;
+
+/**
+ * @fileoverview Default Theme Configuration
+ * @module styles/default-theme
+ *
+ * @description
+ * Defines default theme configuration using base unit system for scalable sizes.
+ * All size values are multiples of the base unit, allowing overall scaling by modifying the base unit.
+ */
+
+/** Default font configuration */
+declare const defaultFonts: FontConfig;
+/** Default color configuration */
+declare const defaultColors: ColorConfig;
+/** Default size multiplier configuration */
+declare const defaultMultipliers: SizeMultipliers;
+/** Default scaled theme configuration */
+declare const defaultScaledConfig: ScaledThemeConfig;
+/**
+ * Generate complete theme from base unit and multiplier configuration
+ * @param config - Scaled theme configuration
+ * @returns Complete theme object
+ */
+declare function createScaledTheme(config?: ScaledThemeConfig): Theme;
+/**
+ * Quickly create scaled theme from base unit value
+ * @param baseUnit - Base unit value (millimeters), default is 1
+ * @returns Complete theme object
+ */
+declare function createThemeWithBaseUnit(baseUnit?: number): Theme;
+/** Default theme - Standard medical form style (base unit = 1mm) */
+declare const defaultTheme: Theme;
+
+/**
+ * @fileoverview CSS Style Generator
+ * @module styles/css-generator
+ * @version 2.0.0
+ * @author Kiro
+ * @created 2026-01-02
+ * @modified 2026-01-03
+ *
+ * @description
+ * Generates complete CSS style strings based on theme configuration.
+ * Supports base unit system, all size values are obtained from theme configuration.
+ * Supports CSS isolation mode to ensure styles are not affected by external styles.
+ *
+ * v2.0.0 Refactoring:
+ * - Use configuration-driven approach to eliminate duplicate code
+ * - Unify generation logic for normal and isolated modes
+ * - Extract common utility functions
+ *
+ * @dependencies
+ * - ../types/theme - Theme type definitions
+ * - ./default-theme - Default theme configuration
+ * - ./page-sizes - Page size constants
+ * - ./isolation - CSS isolation module
+ * - ../fonts - Font module
+ *
+ * @usedBy
+ * - ../renderer/index.ts - Renderer main entry
+ * - ../pagination/paginated-renderer.ts - Paginated renderer
+ */
+
+/** Deep partial type */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Deep merge theme configuration
+ *
+ * Merges a partial custom theme with the default theme, supporting
+ * deep nested property overrides.
+ *
+ * @param customTheme - Custom theme configuration (deep partial)
+ * @returns Merged complete theme
+ *
+ * @example
+ * ```typescript
+ * import { mergeTheme, defaultTheme } from 'medical-form-printer'
+ *
+ * const customTheme = mergeTheme(defaultTheme, {
+ *   colors: {
+ *     primary: '#1a1a1a',
+ *     border: '#333333'
+ *   },
+ *   fontSize: {
+ *     body: '11pt'
+ *   }
+ * })
+ * ```
+ */
+declare function mergeTheme(customTheme?: DeepPartial<Theme>): Theme;
+/**
+ * Generate CSS style string (normal mode)
+ *
+ * @param theme - Theme configuration
+ * @returns Complete CSS style string
+ *
+ * @description
+ * Generated CSS includes:
+ * - Base styles (reset, page layout)
+ * - Header and footer styles
+ * - Section type styles (info-grid, table, checkbox-grid, etc.)
+ * - Print media queries
+ * - Watermark styles
+ *
+ * All size values are obtained from theme configuration, supporting overall scaling through base unit system.
+ *
+ * @example
+ * ```typescript
+ * import { generateCss, defaultTheme, mergeTheme } from 'medical-form-printer'
+ *
+ * // Use default theme
+ * const css = generateCss(defaultTheme)
+ *
+ * // Use custom theme
+ * const customTheme = mergeTheme(defaultTheme, {
+ *   colors: { primary: '#1a1a1a' }
+ * })
+ * const customCss = generateCss(customTheme)
+ * ```
+ */
+declare function generateCss(theme: Theme): string;
+/**
+ * Generate complete isolated CSS with embedded fonts and namespaced classes
+ *
+ * @param customTheme - Custom theme configuration (font configuration will be ignored)
+ * @returns Complete CSS including font, isolation and component styles
+ *
+ * @description
+ * Generated CSS includes:
+ * 1. @font-face declaration (embedded Base64 font)
+ * 2. Font force override rules
+ * 3. CSS isolation container styles
+ * 4. All component styles (with mpr- prefix)
+ * 5. Print media queries
+ *
+ * Note: The fonts property in the passed theme configuration will be ignored,
+ * always uses embedded Source Han Serif SC.
+ *
+ * @example
+ * ```typescript
+ * import { generateIsolatedCss, ISOLATION_ROOT_CLASS } from 'medical-form-printer'
+ *
+ * const css = generateIsolatedCss()
+ *
+ * // Use in HTML
+ * const html = `
+ *   <style>${css}</style>
+ *   <div class="${ISOLATION_ROOT_CLASS}">
+ *     <!-- Rendered content -->
+ *   </div>
+ * `
+ * ```
+ */
+declare function generateIsolatedCss(customTheme?: DeepPartial<Theme>): string;
+
+/**
+ * @fileoverview Base Unit System
+ * @module styles/base-unit
+ * @modifys 2021-06-01
+ *
+ * @description
+ * Defines base unit constants and unit conversion functions for print rendering.
+ * All size values are multiples of BASE_UNIT, allowing overall scaling by modifying BASE_UNIT.
+ *
+ * Design Principles:
+ * - Default base unit is 1mm
+ * - All sizes are defined through a multiplier system to maintain proportional relationships
+ * - Supports mm, pt, px unit output
+ */
+/** Supported unit types */
+type Unit = 'mm' | 'pt' | 'px';
+/** Default base unit value (millimeters) */
+declare const DEFAULT_BASE_UNIT = 1;
+/**
+ * Unit conversion constants
+ * - 1mm ≈ 2.835pt (72pt / 25.4mm)
+ * - 1mm ≈ 3.78px (96px / 25.4mm at 96dpi)
+ */
+declare const UNIT_CONVERSIONS: {
+    /** Millimeters to points conversion factor */
+    readonly MM_TO_PT: number;
+    /** Millimeters to pixels conversion factor (96dpi) */
+    readonly MM_TO_PX: number;
+    /** Points to millimeters conversion factor */
+    readonly PT_TO_MM: number;
+    /** Pixels to millimeters conversion factor (96dpi) */
+    readonly PX_TO_MM: number;
+};
+/**
+ * Size multiplier configuration
+ * Defines multipliers for various sizes relative to the base unit
+ */
+declare const SIZE_MULTIPLIERS: {
+    /** Font size multipliers */
+    readonly fontSize: {
+        /** Body font size - 3.5mm ≈ 10pt */
+        readonly body: 3.5;
+        /** Small font size - 3mm ≈ 8.5pt */
+        readonly small: 3;
+        /** Section title - 4.2mm ≈ 12pt */
+        readonly sectionTitle: 4.2;
+        /** Hospital name - 5mm ≈ 14pt */
+        readonly hospitalName: 5;
+        /** Form title - 5.6mm ≈ 16pt */
+        readonly formTitle: 5.6;
+    };
+    /** Line height multiplier (relative to font size) */
+    readonly lineHeight: 1.5;
+    /** Spacing multipliers */
+    readonly spacing: {
+        /** Page margin - Using 8mm 10mm consistent with Vue component, using 10mm as base */
+        readonly pageMargin: 10;
+        /** Section gap - 5mm */
+        readonly sectionGap: 5;
+        /** Cell horizontal padding - 3mm */
+        readonly cellPaddingX: 3;
+        /** Cell vertical padding - 2mm */
+        readonly cellPaddingY: 2;
+        /** Header bottom margin - 10mm */
+        readonly headerMarginBottom: 10;
+        /** Department name top margin - 2mm */
+        readonly departmentMarginTop: 2;
+        /** Form title top margin - 5mm */
+        readonly titleMarginTop: 5;
+        /** Signature area gap - 20mm */
+        readonly signatureGap: 20;
+        /** Signature area top margin - 10mm */
+        readonly signatureMarginTop: 10;
+        /** Signature line minimum width - 30mm */
+        readonly signatureLineWidth: 30;
+        /** Free text minimum height - 20mm */
+        readonly freeTextMinHeight: 20;
+        /** Footer top margin - 10mm */
+        readonly footerMarginTop: 10;
+        /** Extra small spacing - 2mm */
+        readonly xs: 2;
+        /** Small spacing - 3mm */
+        readonly sm: 3;
+    };
+    /** Border width multiplier - 0.35mm ≈ 1px */
+    readonly borderWidth: 0.35;
+};
+/**
+ * Convert millimeter value to specified unit
+ * @param mm - Millimeter value
+ * @param unit - Target unit
+ * @returns Converted numeric value
+ */
+declare function convertFromMm(mm: number, unit: Unit): number;
+/**
+ * Convert value from specified unit to millimeters
+ * @param value - Numeric value
+ * @param unit - Source unit
+ * @returns Millimeter value
+ */
+declare function convertToMm(value: number, unit: Unit): number;
+/**
+ * Calculate scaled value
+ * @param multiplier - Multiplier
+ * @param baseUnit - Base unit value (millimeters)
+ * @returns Scaled millimeter value
+ */
+declare function scaleValue(multiplier: number, baseUnit?: number): number;
+/**
+ * Format size value as CSS string
+ * @param mm - Millimeter value
+ * @param unit - Output unit
+ * @param precision - Decimal precision
+ * @returns CSS size string (e.g., "10mm", "28.35pt")
+ */
+declare function formatSize(mm: number, unit?: Unit, precision?: number): string;
+/**
+ * Format padding value as CSS string
+ * @param vertical - Vertical padding (millimeters)
+ * @param horizontal - Horizontal padding (millimeters)
+ * @param unit - Output unit
+ * @returns CSS padding string (e.g., "2mm 3mm")
+ */
+declare function formatPadding(vertical: number, horizontal: number, unit?: Unit): string;
+
+/**
+ * @fileoverview Inline style mapping
+ * @module styles/inline-styles
+ *
+ * @description
+ * Defines inline styles that can be directly injected into HTML element style attributes.
+ * Used to generate self-contained HTML that doesn't depend on external CSS files.
+ */
+
+/** Style object type */
+type StyleObject = Record<string, string | number>;
+/** Inline style map type */
+interface InlineStyleMap {
+    printPage: StyleObject;
+    printPageLandscape: StyleObject;
+    printPageA5: StyleObject;
+    printPageA5Landscape: StyleObject;
+    printPage16K: StyleObject;
+    printPage16KLandscape: StyleObject;
+    printHeader: StyleObject;
+    hospitalName: StyleObject;
+    departmentName: StyleObject;
+    formTitle: StyleObject;
+    printSection: StyleObject;
+    sectionTitle: StyleObject;
+    infoGridTable: StyleObject;
+    infoGridTd: StyleObject;
+    infoGridLabelCell: StyleObject;
+    infoGridValueCell: StyleObject;
+    dataTableTable: StyleObject;
+    dataTableTh: StyleObject;
+    dataTableTd: StyleObject;
+    checkboxGrid: StyleObject;
+    checkboxGridFlex: StyleObject;
+    checkboxItem: StyleObject;
+    checkboxSymbol: StyleObject;
+    signatureArea: StyleObject;
+    signatureItem: StyleObject;
+    signatureLine: StyleObject;
+    notesSection: StyleObject;
+    notesSectionBordered: StyleObject;
+    freeText: StyleObject;
+    printFooter: StyleObject;
+    watermark: StyleObject;
+}
+/**
+ * Convert style object to CSS string
+ * @param styles - Style object
+ * @returns CSS string (for style attribute)
+ */
+declare function styleToString(styles: StyleObject): string;
+/**
+ * Merge multiple style objects
+ * @param styles - Array of style objects
+ * @returns Merged style object
+ */
+declare function mergeStyles(...styles: (StyleObject | undefined | null)[]): StyleObject;
+/**
+ * Generate inline style map based on theme
+ * @param theme - Theme configuration
+ * @returns Inline style map
+ */
+declare function createInlineStyles(theme?: Theme): InlineStyleMap;
+/**
+ * Get inline styles for page size
+ * @param pageSize - Page size ('A4' | 'A5' | '16K')
+ * @param orientation - Page orientation ('portrait' | 'landscape')
+ * @param styles - Inline style map
+ * @returns Merged page styles
+ */
+declare function getPageStyles(pageSize: string, orientation: string, styles: InlineStyleMap): StyleObject;
+/** Default inline style map (using default theme) */
+declare const defaultInlineStyles: InlineStyleMap;
+
+/**
+ * @fileoverview CSS Isolation Module
+ * @module styles/isolation
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ *
+ * @description
+ * Provides CSS namespace and isolation container style generation.
+ * Ensures component styles are completely isolated from external styles, preventing style pollution.
+ *
+ * @usedBy
+ * - ./css-generator.ts - CSS generator
+ * - ../renderer/html-renderer.ts - HTML renderer
+ */
+/** CSS namespace prefix */
+declare const CSS_NAMESPACE = "mpr";
+/** Isolation container root class name */
+declare const ISOLATION_ROOT_CLASS = "mpr-root";
+/**
+ * Add namespace prefix to class name
+ * @param className - Original class name
+ * @returns Class name with prefix
+ *
+ * @example
+ * ```typescript
+ * namespaceClass('print-page') // 'mpr-print-page'
+ * namespaceClass('header')     // 'mpr-header'
+ * ```
+ */
+declare function namespaceClass(className: string): string;
+/**
+ * Batch convert class names
+ * @param classNames - Original class name array
+ * @returns Class name array with prefix
+ *
+ * @example
+ * ```typescript
+ * namespaceClasses(['print-page', 'header', 'footer'])
+ * // ['mpr-print-page', 'mpr-header', 'mpr-footer']
+ * ```
+ */
+declare function namespaceClasses(classNames: string[]): string[];
+/**
+ * Get namespaced class name
+ * @param className - Original class name
+ * @returns Namespaced class name, adds prefix if not in mapping table
+ */
+declare function getNamespacedClass(className: string): string;
+
+/**
+ * @fileoverview Data formatters for converting values to display strings
+ * @module formatters
+ * @modified 2023-03-02
+ */
+
+/**
+ * Format a date value to a string
+ *
+ * @param value - The date value (Date object, string, or number)
+ * @param format - The format string (default: 'YYYY-MM-DD')
+ * @returns Formatted date string, or empty string if value is falsy
+ *
+ * @example
+ * ```typescript
+ * formatDate('2024-01-15')                    // '2024-01-15'
+ * formatDate(new Date(), 'YYYY/MM/DD')        // '2024/01/15'
+ * formatDate('2024-01-15', 'MM/DD/YYYY')      // '01/15/2024'
+ * ```
+ */
+declare function formatDate(value: unknown, format?: string): string;
+/**
+ * Format a boolean value to a checkbox symbol
+ *
+ * Uses ☑ (U+2611) for checked and □ (U+25A1) for unchecked,
+ * consistent with Vue component rendering.
+ *
+ * @param value - The boolean value (truthy/falsy)
+ * @returns '☑' for truthy values, '□' for falsy values
+ *
+ * @example
+ * ```typescript
+ * formatBoolean(true)   // '☑'
+ * formatBoolean(false)  // '□'
+ * formatBoolean(1)      // '☑'
+ * formatBoolean(null)   // '□'
+ * ```
+ */
+declare function formatBoolean(value: unknown): string;
+/**
+ * Format a number value to a string with optional precision
+ *
+ * @param value - The number value
+ * @param precision - Number of decimal places (optional)
+ * @returns Formatted number string, or empty string if value is empty/invalid
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1234.567)        // '1234.567'
+ * formatNumber(1234.567, 2)     // '1234.57'
+ * formatNumber('invalid')       // 'invalid'
+ * formatNumber(null)            // ''
+ * ```
+ */
+declare function formatNumber(value: unknown, precision?: number): string;
+/**
+ * Format a value based on its type
+ *
+ * Generic formatter that handles different data types and supports
+ * custom formatters for specialized formatting needs.
+ *
+ * @param value - The value to format
+ * @param type - The data type ('text', 'checkbox', 'date', 'datetime', 'number')
+ * @param options - Formatting options
+ * @param options.dateFormat - Date format configuration
+ * @param options.emptyPlaceholder - Placeholder for empty values (default: '')
+ * @param options.customFormatters - Custom formatter functions by type
+ * @returns Formatted string
+ *
+ * @example
+ * ```typescript
+ * formatValue('Hello', 'text')                    // 'Hello'
+ * formatValue(true, 'checkbox')                   // '☑'
+ * formatValue('2024-01-15', 'date')               // '2024-01-15'
+ * formatValue(null, 'text', { emptyPlaceholder: '-' })  // '-'
+ * ```
+ */
+declare function formatValue(value: unknown, type?: string, options?: {
+    dateFormat?: DateFormatOptions;
+    emptyPlaceholder?: string;
+    customFormatters?: Record<string, (value: unknown) => string>;
+}): string;
+/**
+ * Check if a value is checked/selected for a given option
+ *
+ * Handles both array values (multiple selection) and single values.
+ *
+ * @param values - The value(s) to check (array or single value)
+ * @param optionValue - The option value to check against
+ * @returns true if the option is selected, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isChecked(['a', 'b', 'c'], 'b')  // true
+ * isChecked(['a', 'b', 'c'], 'd')  // false
+ * isChecked('yes', 'yes')          // true
+ * isChecked('no', 'yes')           // false
+ * ```
+ */
+declare function isChecked(values: unknown, optionValue: string): boolean;
+
+/** @deprecated Use PAGINATION_DEFAULTS.DPI instead */
+declare const DEFAULT_DPI: 96;
+/** @deprecated Use PAGINATION_DEFAULTS.MM_PER_INCH instead */
+declare const MM_PER_INCH: 25.4;
+/**
+ * Measurable content item type enum
+ * @requirements 9.1 - Identify different types of content items
+ */
+declare const MEASURABLE_ITEM_TYPES: {
+    readonly HEADER: "header";
+    readonly SECTION: "section";
+    readonly TABLE_HEADER: "table-header";
+    readonly TABLE_ROW: "table-row";
+    readonly SIGNATURE: "signature";
+    readonly FOOTER: "footer";
+};
+/**
+ * Measurable content item type
+ * @requirements 9.1 - Identify different types of content items
+ */
+type MeasurableItemType = (typeof MEASURABLE_ITEM_TYPES)[keyof typeof MEASURABLE_ITEM_TYPES];
+/**
+ * Page dimension configuration
+ * @requirements 9.5 - Support configurable page sizes
+ */
+interface PageDimensions {
+    /** Page width (mm) */
+    width: number;
+    /** Page height (mm) */
+    height: number;
+    /** Top margin (mm) */
+    marginTop: number;
+    /** Bottom margin (mm) */
+    marginBottom: number;
+    /** Left margin (mm) */
+    marginLeft: number;
+    /** Right margin (mm) */
+    marginRight: number;
+}
+/**
+ * Measurable content item
+ * @requirements 9.7 - Support pre-measuring content height
+ */
+interface MeasurableItem {
+    /** Unique identifier */
+    id: string;
+    /** Content type */
+    type: MeasurableItemType;
+    /** Measured height (px) */
+    height: number;
+    /** Parent table ID (only for table-header and table-row) */
+    tableId?: string;
+    /** Original data index */
+    dataIndex?: number;
+}
+/**
+ * Single page content
+ * @requirements 9.1 - Pagination result contains page content list
+ */
+interface PageContent {
+    /** Page number (starting from 1) */
+    pageNumber: number;
+    /** Whether this is a continuation page */
+    isContinuation: boolean;
+    /** List of content item IDs on this page */
+    items: string[];
+    /** List of table header IDs to repeat */
+    repeatedHeaders: string[];
+}
+/**
+ * Pagination result
+ * @requirements 9.1 - Return paginated page list
+ */
+interface PageBreakResult {
+    /** Page list */
+    pages: PageContent[];
+    /** Total page count */
+    totalPages: number;
+}
+/**
+ * Overflow field configuration
+ * Specifies which fields need pagination handling when content is too long
+ * @requirements 9.7 - Support overflow field pagination
+ */
+interface OverflowFieldConfig {
+    /** Field name */
+    fieldName: string;
+    /** Maximum characters to show on first page, default 60 */
+    maxFirstLineChars?: number;
+}
+/**
+ * Overflow configuration
+ * Configures pagination behavior when field content overflows
+ */
+interface OverflowConfig {
+    /** Which fields should overflow to next page */
+    fields?: string[];
+    /** Maximum characters to show on first page, default 60 */
+    firstLineChars?: number;
+}
+/**
+ * Display configuration
+ * Configures elements to display on each page
+ */
+interface DisplayConfig {
+    /** Whether to show header on each page */
+    headerOnEachPage?: boolean;
+    /** Whether to show footer on each page */
+    footerOnEachPage?: boolean;
+    /** Whether to show signature area at bottom of each page */
+    signatureOnEachPage?: boolean;
+    /** Whether to repeat table headers on continuation pages */
+    repeatTableHeaders?: boolean;
+}
+/**
+ * Page header configuration
+ * Configures header display on each page
+ */
+interface PageHeaderConfig {
+    /** Whether to show header on each page */
+    showOnEachPage: boolean;
+    /** Continuation page title suffix, e.g., "(continued)" */
+    continuationSuffix?: string;
+}
+/**
+ * Page footer configuration
+ * Configures footer display on each page
+ */
+interface PageFooterConfig {
+    /** Whether to show footer on each page */
+    showOnEachPage: boolean;
+    /** Page number format, e.g., "Page {current} of {total}" */
+    pageNumberFormat?: string;
+}
+/**
+ * Smart pagination configuration
+ * Enables measurement-based smart pagination
+ */
+interface SmartPaginationConfig {
+    /** Whether to enable smart pagination */
+    enabled: boolean;
+    /** Minimum table row height estimate (mm), for estimation, default 8 */
+    minRowHeight?: number;
+}
+/**
+ * Pagination configuration
+ * @requirements 9.1, 9.5 - Support configurable pagination rules
+ */
+interface PaginationConfig {
+    /** Whether to enable pagination */
+    enabled: boolean;
+    /** Pagination mode: auto | manual (specify break points) */
+    mode?: 'auto' | 'manual';
+    /** In manual mode, page break after these section indices (0-based) */
+    pageBreaks?: number[];
+    /** Overflow configuration */
+    overflow?: OverflowConfig;
+    /** Display configuration */
+    display?: DisplayConfig;
+    /** Smart pagination configuration */
+    smartPagination?: SmartPaginationConfig;
+    /** Header configuration */
+    headerConfig?: PageHeaderConfig;
+    /** Footer configuration */
+    footerConfig?: PageFooterConfig;
+    /** @deprecated Use overflow.fields instead */
+    overflowFields?: string[];
+    /** @deprecated Use overflow.firstLineChars instead */
+    overflowFirstLineChars?: number;
+    /** @deprecated Use display.headerOnEachPage instead */
+    showHeaderOnEachPage?: boolean;
+    /** @deprecated Use display.footerOnEachPage instead */
+    showFooterOnEachPage?: boolean;
+    /** @deprecated Use display.signatureOnEachPage instead */
+    showSignatureOnEachPage?: boolean;
+    /** @deprecated Use display.repeatTableHeaders instead */
+    repeatTableHeaders?: boolean;
+}
+/**
+ * Page break calculation options
+ * Parameters for calculatePageBreaks function
+ * @requirements 9.1 - Pagination calculation parameters
+ */
+interface PageBreakOptions {
+    /** Available page height (px) */
+    pageHeight: number;
+    /** Header height (px), default 0 */
+    headerHeight?: number;
+    /** Footer height (px), default 0 */
+    footerHeight?: number;
+    /** Whether to repeat table headers, default true */
+    repeatTableHeaders?: boolean;
+}
+/**
+ * Page size preset name
+ */
+type PageSizePreset = '16K' | 'A4' | 'A5';
+
+/**
+ * @fileoverview Page dimension configuration and unit conversion
+ * @module pagination/page-dimensions
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-03
+ *
+ * @description
+ * Provides page size presets and unit conversion functions:
+ * - 16K (Sixteen-mo): 185mm × 260mm - Common format for medical forms
+ * - A4: 210mm × 297mm
+ * - A5: 148mm × 210mm
+ * - mm to px unit conversion
+ * - Usable height/width calculation
+ *
+ * @requirements
+ * - 3.1: Support A4, A5, 16K page sizes
+ * - 3.6: Use 16K as default page size
+ * - 9.5: Support configurable page sizes
+ *
+ * @dependencies
+ * - ./types.ts - Type definitions and constants
+ *
+ * @usedBy
+ * - ./index.ts - Module entry
+ * - ./page-break-calculator.ts - Pagination algorithm
+ * - ../renderer/paginated-renderer.ts - Paginated renderer
+ */
+
+/**
+ * 16K (Sixteen-mo) paper configuration
+ * Size: 185mm × 260mm
+ * Common format for medical forms
+ * @requirements 3.6 - Use 16K as default page size
+ */
+declare const PAGE_16K: PageDimensions;
+/**
+ * A4 paper configuration
+ * Size: 210mm × 297mm
+ * @requirements 3.1 - Support A4 page size
+ */
+declare const PAGE_A4: PageDimensions;
+/**
+ * A5 paper configuration
+ * Size: 148mm × 210mm
+ * @requirements 3.1 - Support A5 page size
+ */
+declare const PAGE_A5: PageDimensions;
+/**
+ * Page size preset mapping
+ */
+declare const PAGE_PRESETS: Record<PageSizePreset, PageDimensions>;
+/**
+ * Convert millimeters to pixels
+ * @param mm - Millimeter value
+ * @param dpi - DPI, default 96
+ * @returns Pixel value
+ *
+ * @example
+ * mmToPx(185) // => 699.21...
+ * mmToPx(260) // => 982.68...
+ */
+declare function mmToPx(mm: number, dpi?: number): number;
+/**
+ * Convert pixels to millimeters
+ * @param px - Pixel value
+ * @param dpi - DPI, default 96
+ * @returns Millimeter value
+ *
+ * @example
+ * pxToMm(699.21) // => 185
+ */
+declare function pxToMm(px: number, dpi?: number): number;
+/**
+ * Convert millimeters to points (pt)
+ * 1pt = 1/72 inch
+ * @param mm - Millimeter value
+ * @returns Point value
+ */
+declare function mmToPt(mm: number): number;
+/**
+ * Convert points (pt) to millimeters
+ * @param pt - Point value
+ * @returns Millimeter value
+ */
+declare function ptToMm(pt: number): number;
+/**
+ * Calculate usable content height (pixels)
+ * @requirements 9.5 - Support configurable page sizes
+ *
+ * @param dimensions - Page size configuration
+ * @param dpi - DPI, default 96
+ * @returns Usable content height (pixels)
+ */
+declare function calculateUsableHeight(dimensions?: PageDimensions, dpi?: number): number;
+/**
+ * Calculate usable content width (pixels)
+ * @requirements 9.5 - Support configurable page sizes
+ *
+ * @param dimensions - Page size configuration
+ * @param dpi - DPI, default 96
+ * @returns Usable content width (pixels)
+ */
+declare function calculateUsableWidth(dimensions?: PageDimensions, dpi?: number): number;
+/**
+ * Calculate usable content height (millimeters)
+ * @param dimensions - Page size configuration
+ * @returns Usable content height (millimeters)
+ */
+declare function calculateUsableHeightMm(dimensions?: PageDimensions): number;
+/**
+ * Calculate usable content width (millimeters)
+ * @param dimensions - Page size configuration
+ * @returns Usable content width (millimeters)
+ */
+declare function calculateUsableWidthMm(dimensions?: PageDimensions): number;
+/**
+ * Get preset configuration by page size name
+ * @param pageSize - Page size name ('16K' | 'A4' | 'A5')
+ * @returns Page size configuration
+ */
+declare function getPageDimensions(pageSize?: PageSizePreset): PageDimensions;
+/**
+ * Create custom page size configuration
+ * @param width - Page width (mm)
+ * @param height - Page height (mm)
+ * @param margins - Margin configuration
+ * @returns Page size configuration
+ */
+declare function createPageDimensions(width: number, height: number, margins?: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}): PageDimensions;
+
+/**
+ * @fileoverview Page break algorithm core
+ * @module pagination/page-break-calculator
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-03
+ *
+ * @description
+ * Provides core algorithms for intelligent pagination, including:
+ * - Page break point calculation
+ * - Table row non-splitting guarantee
+ * - Continuation page header repetition
+ * - Reserved header height calculation
+ *
+ * @requirements
+ * - 9.1: Calculate page breaks based on measured content height
+ * - 9.2: Ensure table rows are not split
+ * - 9.3: Automatically repeat headers on continuation pages
+ * - 9.4: Mark continuation pages with isContinuation
+ * - 9.6: Reserved header height calculation
+ *
+ * @dependencies
+ * - ./types.ts - Type definitions
+ *
+ * @usedBy
+ * - ./index.ts - Module entry
+ * - ../renderer/paginated-renderer.ts - Paginated renderer (to be implemented)
+ */
+
+/**
+ * Find the header item for a specific table
+ * @requirements 9.3, 9.6 - Identify headers for repetition
+ *
+ * @param items - All content items
+ * @param tableId - Table ID
+ * @returns Header item, or undefined if not found
+ */
+declare function findTableHeader(items: MeasurableItem[], tableId: string): MeasurableItem | undefined;
+/**
+ * Build a map from table ID to header
+ * @requirements 9.3 - Fast header lookup
+ *
+ * @param items - All content items
+ * @returns Map from table ID to header item
+ */
+declare function buildTableHeaderMap(items: MeasurableItem[]): Map<string, MeasurableItem>;
+/**
+ * Calculate page break points
+ * @requirements 9.1, 9.2, 9.3, 9.4, 9.6
+ *
+ * Core algorithm:
+ * 1. Iterate through all content items, accumulating height
+ * 2. When accumulated height exceeds available page height, create new page
+ * 3. Ensure table rows are not split (move entire row to next page)
+ * 4. Continuation pages need to repeat corresponding table headers (Requirements 9.3)
+ * 5. Reserve header height during calculation (Requirements 9.6)
+ *
+ * @param items - All measurable content items
+ * @param options - Page break calculation options
+ * @returns Page break result
+ */
+declare function calculatePageBreaks(items: MeasurableItem[], options: PageBreakOptions): PageBreakResult;
+/**
+ * Simplified page break calculation (using default options)
+ * @param items - All measurable content items
+ * @param pageHeight - Available page height (px)
+ * @param headerHeight - Header height (px), default 0
+ * @param footerHeight - Footer height (px), default 0
+ * @returns Page break result
+ */
+declare function calculatePageBreaksSimple(items: MeasurableItem[], pageHeight: number, headerHeight?: number, footerHeight?: number): PageBreakResult;
+/**
+ * Validate completeness of page break result
+ * @requirements 9.1 - Ensure all items are assigned to pages
+ *
+ * @param items - Original content items
+ * @param result - Page break result
+ * @returns Whether all items are assigned
+ */
+declare function validatePageBreakResult(items: MeasurableItem[], result: PageBreakResult): boolean;
+/**
+ * Get actual content height of a page
+ * @param page - Page content
+ * @param items - All content items
+ * @returns Page content height (px)
+ */
+declare function getPageContentHeight(page: PageContent, items: MeasurableItem[]): number;
+
+/**
+ * @fileoverview Overflow field pagination handling
+ * @module pagination/overflow-handler
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-03
+ *
+ * @description
+ * Handles pagination logic for long text fields (e.g., textarea):
+ * - First page displays truncated content
+ * - Continuation pages display remaining content
+ * - Supports configuring truncation character count per field
+ *
+ * Reference frontend implementation: PrintModeForm.vue lines 130-175
+ *
+ * @requirements
+ * - 9.1: Calculate page breaks based on measured content height
+ * - 9.7: Support overflow field pagination
+ *
+ * @dependencies
+ * - ./types.ts - Type definitions
+ *
+ * @usedBy
+ * - ./index.ts - Module entry
+ * - ../renderer/paginated-renderer.ts - Paginated renderer (to be implemented)
+ */
+
+/**
+ * Overflow field processing result
+ */
+interface OverflowFieldResult {
+    /** Field name */
+    fieldName: string;
+    /** First page display content */
+    firstLine: string;
+    /** Continuation page display content */
+    rest: string;
+    /** Whether there is overflow content */
+    hasOverflow: boolean;
+}
+/**
+ * Get first page display content for overflow field
+ * @requirements 9.7 - Support overflow field pagination
+ *
+ * @param value - Field value
+ * @param maxChars - Maximum characters to display on first page
+ * @returns Content to display on first page
+ *
+ * @example
+ * getOverflowFirstLine('This is a very long text...', 60)
+ */
+declare function getOverflowFirstLine(value: unknown, maxChars?: number): string;
+/**
+ * Get continuation page display content for overflow field
+ * @requirements 9.7 - Support overflow field pagination
+ *
+ * @param value - Field value
+ * @param maxChars - Maximum characters to display on first page
+ * @returns Content to display on continuation pages
+ */
+declare function getOverflowRest(value: unknown, maxChars?: number): string;
+/**
+ * Check if field has overflow content
+ * @requirements 9.7 - Support overflow field pagination
+ *
+ * @param value - Field value
+ * @param maxChars - Maximum characters to display on first page
+ * @returns Whether there is overflow content to display on continuation pages
+ */
+declare function hasOverflowContent(value: unknown, maxChars?: number): boolean;
+/**
+ * Create overflow field configuration
+ * @param fieldName - Field name
+ * @param maxFirstLineChars - Maximum characters to display on first page
+ * @returns Overflow field configuration
+ */
+declare function createOverflowFieldConfig(fieldName: string, maxFirstLineChars?: number): OverflowFieldConfig;
+/**
+ * Create overflow field configuration list from field name array
+ * @param fieldNames - Array of field names
+ * @param defaultMaxChars - Default maximum characters
+ * @returns Overflow field configuration list
+ */
+declare function createOverflowFieldConfigs(fieldNames: string[], defaultMaxChars?: number): OverflowFieldConfig[];
+/**
+ * Get overflow configuration for a field
+ * @param configs - Overflow field configuration list
+ * @param fieldName - Field name
+ * @returns Overflow field configuration, or undefined if not found
+ */
+declare function getOverflowFieldConfig(configs: OverflowFieldConfig[], fieldName: string): OverflowFieldConfig | undefined;
+/**
+ * Check if field is configured as overflow field
+ * @param configs - Overflow field configuration list
+ * @param fieldName - Field name
+ * @returns Whether it is an overflow field
+ */
+declare function isOverflowField(configs: OverflowFieldConfig[], fieldName: string): boolean;
+/**
+ * Batch process overflow fields
+ * @param data - Form data
+ * @param configs - Overflow field configuration list
+ * @returns Overflow field processing result list
+ */
+declare function processOverflowFields(data: Record<string, unknown>, configs: OverflowFieldConfig[]): OverflowFieldResult[];
+/**
+ * Check if any overflow content needs continuation pages
+ * @param data - Form data
+ * @param configs - Overflow field configuration list
+ * @returns Whether continuation pages are needed
+ */
+declare function hasAnyOverflowContent(data: Record<string, unknown>, configs: OverflowFieldConfig[]): boolean;
+
+/**
+ * @fileoverview Paginated renderer
+ * @module pagination/paginated-renderer
+ * @version 1.1.0
+ * @author Kiro
+ * @created 2026-01-02
+ * @modified 2026-01-03
+ *
+ * @description
+ * Renders pagination results to multi-page HTML, each page independent and printable.
+ * Supports:
+ * - Independent .print-page element for each page
+ * - Header rendering on each page (continuation pages add "(continued)" marker)
+ * - Footer rendering on each page (page number display)
+ * - Automatic table header insertion on continuation pages
+ * - CSS pagination rules
+ *
+ * @requirements
+ * - 11.1: Render each page as independent .print-page element
+ * - 11.2: Automatically insert table headers on continuation pages
+ * - 11.3: Display page numbers ("Page X of Y")
+ * - 11.4: Add "(continued)" marker to continuation page titles
+ * - 11.5: Support CSS page-break rules
+ * - 11.6: Maintain consistent styles across pages
+ *
+ * @dependencies
+ * - ./types.ts - Type definitions
+ * - ./page-break-calculator.ts - Pagination algorithm
+ * - ../renderer/section-renderers - Section renderers
+ * - ../styles - Style system
+ * - ../utils/html-builder.ts - HTML builder
+ *
+ * @usedBy
+ * - ../index.ts - Library main entry
+ * - international-postpartum-frontend - Frontend print module
+ */
+
+/**
+ * Paginated render configuration
+ */
+interface PaginatedRenderConfig {
+    /** Whether to show header on each page */
+    showHeaderOnEachPage?: boolean;
+    /** Whether to show footer on each page */
+    showFooterOnEachPage?: boolean;
+    /** Whether to show signature area on each page */
+    showSignatureOnEachPage?: boolean;
+    /** Continuation page title suffix, default "(continued)" */
+    continuationSuffix?: string;
+    /** Page number format, default "Page {current} of {total}" */
+    pageNumberFormat?: string;
+    /** Page dimensions configuration */
+    pageDimensions?: PageDimensions;
+    /**
+     * Whether to enable isolation mode
+     * When enabled:
+     * - All class names have mpr- prefix
+     * - Styles are fully isolated, unaffected by external styles
+     * - Fonts forced to use embedded Source Han Serif SC
+     * @default false
+     */
+    isolated?: boolean;
+}
+/**
+ * Paginated render context
+ */
+interface PaginatedRenderContext {
+    /** Print layout configuration */
+    schema: PrintSchema;
+    /** Form data */
+    data: FormData;
+    /** Render options */
+    options?: RenderOptions;
+    /** Pagination result */
+    pageBreakResult: PageBreakResult;
+    /** All measurable content items */
+    measuredItems: MeasurableItem[];
+    /** Paginated render configuration */
+    config?: PaginatedRenderConfig;
+}
+/**
+ * Default paginated render configuration
+ */
+declare const DEFAULT_PAGINATED_RENDER_CONFIG: Required<PaginatedRenderConfig>;
+/**
+ * Render paginated HTML
+ * @requirements 11.1, 11.2, 11.3, 11.4, 11.5, 11.6
+ * @requirements 3.1, 4.2 - CSS isolation and font embedding (isolation mode)
+ *
+ * @param context - Paginated render context
+ * @returns Complete paginated HTML string
+ *
+ * @example
+ * // Normal mode
+ * const html = renderPaginatedHtml({
+ *   schema: printSchema,
+ *   data: formData,
+ *   pageBreakResult: calculatePageBreaks(items, options),
+ *   measuredItems: items,
+ *   config: { showHeaderOnEachPage: true }
+ * })
+ *
+ * @example
+ * // Isolation mode - all class names have mpr- prefix, styles fully isolated
+ * const html = renderPaginatedHtml({
+ *   schema: printSchema,
+ *   data: formData,
+ *   pageBreakResult: calculatePageBreaks(items, options),
+ *   measuredItems: items,
+ *   config: { isolated: true }
+ * })
+ */
+declare function renderPaginatedHtml(context: PaginatedRenderContext): string;
+/**
+ * Generate pagination-related CSS rules
+ * @requirements 11.5, 11.6 - CSS page-break rules
+ * @param isolated - Whether to enable isolation mode (class names have mpr- prefix)
+ */
+declare function generatePaginationCss(isolated?: boolean): string;
+/**
+ * Simplified paginated render function
+ * For scenarios where pagination result is already available
+ */
+declare function renderPaginatedHtmlSimple(schema: PrintSchema, data: FormData, pageBreakResult: PageBreakResult, measuredItems: MeasurableItem[], options?: RenderOptions, config?: PaginatedRenderConfig): string;
+/**
+ * Create PaginatedRenderConfig from PaginationConfig
+ */
+declare function createRenderConfigFromPaginationConfig(paginationConfig?: PaginationConfig): PaginatedRenderConfig;
+
+/**
+ * @fileoverview Pagination module entry point
+ * @module pagination
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-03
+ *
+ * @description
+ * Exports all pagination-related types and functions:
+ * - Type definitions
+ * - Page size configuration
+ * - Pagination algorithm
+ * - Overflow field handling
+ *
+ * @requirements
+ * - 9.1: Calculate page breaks based on measured content height
+ *
+ * @usedBy
+ * - ../index.ts - Library main entry
+ * - international-postpartum-frontend - Frontend print module
+ */
+
+/**
+ * Print pagination utility function collection
+ * Provides Vue Composable-like API style
+ *
+ * @param dimensions - Page size configuration, default 16K
+ * @returns Pagination utility functions
+ *
+ * @example
+ * const { calculateBreaks, usableHeight } = usePrintPagination()
+ * const result = calculateBreaks(measuredItems, usableHeight)
+ */
+declare function usePrintPagination(dimensions?: PageDimensions): {
+    /** Page size configuration */
+    dimensions: PageDimensions;
+    /** Usable content height (px) */
+    usableHeight: number;
+    /** Usable content width (px) */
+    usableWidth: number;
+    /** Calculate pagination */
+    calculateBreaks: (items: MeasurableItem[], headerHeight?: number, footerHeight?: number) => PageBreakResult;
+    /** mm to px */
+    mmToPx: typeof mmToPx;
+    /** px to mm */
+    pxToMm: typeof pxToMm;
+};
+
+export { AbstractPageRenderer, CSS_NAMESPACE, type CellType, type CheckboxGridConfig, type CheckboxOption, type ColorConfig, type ColumnConfig, ContainerSection, DEFAULT_BASE_UNIT, DEFAULT_DPI, DEFAULT_PAGINATED_RENDER_CONFIG, type DateFormatOptions, FONT_FAMILY, FONT_STYLE, FONT_WEIGHT, type FieldInfo, type FontConfig, FontLoadError, type FontLoadOptions, type FontSizeConfig, type FooterConfig, type FormData, FormDataTraverser, type FormDataVisitor, FormatVisitor, type Formatter, type FormatterConfig, FormatterFactory, type FreeTextConfig, type HeaderConfig, HtmlBuilder, HtmlElementBuilder, ISOLATION_ROOT_CLASS, type InfoGridCell, type InfoGridConfig, type InfoGridRow, type InlineStyleMap, type IsolatedRenderOptions, LeafSection, MM_PER_INCH, type MeasurableItem, type MeasurableItemType, type MeasureResult, MeasureVisitor, type MergeDocumentItem, type MergeOptions, type NotesConfig, type OverflowFieldConfig, type OverflowFieldResult, PAGE_16K, PAGE_A4, PAGE_A5, PAGE_PRESETS, type PageBreakOptions, type PageBreakResult, PageBuilder, type PageConfig, type PageContent, type PageDimensions, type PageFooterConfig, type PageHeaderConfig, type PageOrientation, type PageRenderContext, type PageSize, PaginatedPageRenderer, type PaginatedRenderConfig, type PaginatedRenderContext, type PaginationConfig, type PdfOptions, type PrintFooter, type PrintHeader, type PrintSchema, type PrintSection, type RenderOptions, type RendererCreator, SIZE_MULTIPLIERS, type ScaledThemeConfig, type SectionComponent, type SectionConfig, type SectionRenderStrategy, type SectionRenderer, SectionRendererFactory, SectionTreeTraverser, type SectionType, type SignatureConfig, type SignatureField, SinglePageRenderer, type SizeMultipliers, type SmartPaginationConfig, type SpacingConfig, StrategyContext, type StyleObject, TableBuilder, type TableColumn, type TableConfig$1 as TableConfig, type Theme, UNIT_CONVERSIONS, type Unit, type ValidationResult, ValidationVisitor, type WatermarkOptions, buildTableHeaderMap, calculatePageBreaks, calculatePageBreaksSimple, calculateUsableHeight, calculateUsableHeightMm, calculateUsableWidth, calculateUsableWidthMm, clamp, convertFromMm, convertToMm, createDefaultStrategyContext, createFormDataTraverser, createFormatVisitor, createInlineStyles, createMeasureVisitor, createOverflowFieldConfig, createOverflowFieldConfigs, createPageDimensions, createPaginatedPageRenderer, createRenderConfigFromPaginationConfig, createScaledTheme, createSectionComponent, createSectionTree, createSinglePageRenderer, createThemeWithBaseUnit, createValidationVisitor, defaultColors, defaultFonts, defaultInlineStyles, defaultMultipliers, defaultScaledConfig, defaultTheme, div, each, escapeAttr, escapeHtml, extractWatermarkOptions, findTableHeader, footer, formatBoolean, formatDate, formatNumber, formatPadding, formatSize, formatValue, fragment, generateCss, generateIsolatedCss, generatePaginationCss, getDefaultFormatterFactory, getDefaultSectionRendererFactory, getFontCss, getFontDataUrl, getNamespacedClass, getOverflowFieldConfig, getOverflowFirstLine, getOverflowRest, getPageContentHeight, getPageDimensions, getPageStyles, getSectionRenderer, h, h1, hasAnyOverflowContent, hasOverflowContent, header, isChecked, isFontLoaded, isOverflowField, main, mergeStyles, mergeTheme, mmToPt, mmToPx, namespaceClass, namespaceClasses, normalizeOpacity, p, processOverflowFields, ptToMm, pxToMm, registerSectionRenderer, renderPaginatedHtml, renderPaginatedHtmlSimple, renderSectionTree, renderToHtml, renderToIsolatedFragment, renderToIsolatedHtml, renderWatermarkHtml, scaleValue, span, styleToString, table, tbody, td, th, thead, tr, usePrintPagination, validatePageBreakResult, waitForFonts, when };