medical-form-printer 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -97,6 +97,66 @@ interface TableColumn {
     /** Options (for select type) */
     options?: string[];
 }
+/**
+ * Header cell configuration for multi-row table headers
+ *
+ * @since next
+ * @description
+ * Defines a single cell in a table header row, supporting colspan and rowspan
+ * for creating complex nested header structures.
+ *
+ * @example
+ * ```typescript
+ * const cell: HeaderCell = {
+ *   text: 'Blood Pressure (mmHg)',
+ *   colspan: 2,  // Spans 2 columns
+ *   rowspan: 1   // Default, spans 1 row
+ * }
+ * ```
+ */
+interface HeaderCell {
+    /** Header cell text content */
+    text: string;
+    /**
+     * Number of columns this cell spans (default: 1)
+     * @default 1
+     */
+    colspan?: number;
+    /**
+     * Number of rows this cell spans (default: 1)
+     * @default 1
+     */
+    rowspan?: number;
+    /** Cell width (e.g., '100px', '20%') */
+    width?: string;
+    /**
+     * Associated data column field name (used for bottom-level header cells)
+     * Links this header cell to a specific data column for alignment
+     */
+    field?: string;
+}
+/**
+ * Header row configuration for multi-row table headers
+ *
+ * @since next
+ * @description
+ * Defines a single row in a multi-row table header structure.
+ * Each row contains an array of header cells.
+ *
+ * @example
+ * ```typescript
+ * const row: HeaderRow = {
+ *   cells: [
+ *     { text: 'Date', rowspan: 2 },
+ *     { text: 'Blood Pressure', colspan: 2 }
+ *   ]
+ * }
+ * ```
+ */
+interface HeaderRow {
+    /** Array of header cells in this row */
+    cells: HeaderCell[];
+}
 /** Table configuration */
 interface TableConfig$1 {
     /** Column configuration */
@@ -105,6 +165,27 @@ interface TableConfig$1 {
     dataField: string;
     /** Whether to show row numbers */
     showRowNumber?: boolean;
+    /**
+     * Multi-row header configuration (optional)
+     *
+     * @since next
+     * @description
+     * When provided, enables complex multi-row header structures with
+     * colspan and rowspan support. Takes priority over generating
+     * headers from the columns configuration.
+     *
+     * When not provided, a single-row header is generated from the
+     * columns configuration for backward compatibility.
+     *
+     * @example
+     * ```typescript
+     * headerRows: [
+     *   { cells: [{ text: 'Date', rowspan: 2 }, { text: 'Blood Pressure', colspan: 2 }] },
+     *   { cells: [{ text: 'Systolic' }, { text: 'Diastolic' }] }
+     * ]
+     * ```
+     */
+    headerRows?: HeaderRow[];
 }
 /** Checkbox option */
 interface CheckboxOption {
@@ -275,6 +356,8 @@ interface PrintSchema {
     pageSize: PageSize;
     /** Page orientation */
     orientation: PageOrientation;
+    /** Base unit for scaling (default: 1, e.g., 0.95 = 5% smaller, 1.1 = 10% larger) */
+    baseUnit?: number;
     /** Header configuration */
     header: PrintHeader;
     /** Section list */
@@ -708,6 +791,32 @@ declare function each<T>(items: T[] | undefined | null, renderer: (item: T, inde
 /**
  * @fileoverview HTML Rendering Core
  * @module renderer/html-renderer
+ * @version 2.1.0
+ * @author Kiro
+ * @created 2024-04-07
+ * @modified 2026-01-04
+ *
+ * @description
+ * Core HTML rendering module for medical form print output.
+ * Generates complete HTML documents with embedded CSS styles,
+ * ready for printing or PDF generation.
+ *
+ * Features:
+ * - Schema-driven rendering with PrintSchema configuration
+ * - Per-template baseUnit scaling support
+ * - Watermark support
+ * - Custom theme configuration
+ *
+ * @dependencies
+ * - ../types/print-schema - Print configuration types
+ * - ../types/options - Render options types
+ * - ../styles - CSS generation and theme system
+ * - ./section-renderers - Section-specific renderers
+ * - ../utils - Utility functions
+ *
+ * @usedBy
+ * - ../index.ts - Library main entry
+ * - ../node.ts - Node.js PDF generation entry
  */
 
 /**
@@ -815,7 +924,10 @@ declare function renderToIsolatedFragment(schema: PrintSchema, data: FormData, o
 /**
  * @fileoverview Section renderer registry
  * @module renderer/section-renderers
- * @modified 2024-04-06
+ * @version 1.1.0
+ * @author Kiro
+ * @created 2024-04-06
+ * @modified 2026-01-05
  */
 
 /**
@@ -2554,20 +2666,113 @@ declare function formatValue(value: unknown, type?: string, options?: {
  */
 declare function isChecked(values: unknown, optionValue: unknown): boolean;
 
+/**
+ * @fileoverview Pagination related type definitions
+ * @module pagination/types
+ * @version 1.1.0
+ * @author Kiro
+ * @created 2026-01-03
+ * @modified 2026-01-04
+ *
+ * @description
+ * Defines all types for the smart pagination module, including:
+ * - Page dimension configuration
+ * - Measurable content items
+ * - Pagination results
+ * - Overflow field configuration
+ * - Pagination configuration
+ * - Overflow text i18n configuration
+ *
+ * @requirements
+ * - 9.1: Calculate page breaks based on measured content height
+ * - 9.5: Support configurable page sizes
+ * - 9.7: Support pre-measuring content height
+ * - 5.1: Support i18n for overflow text
+ *
+ * @usedBy
+ * - ./page-dimensions.ts - Page dimension configuration
+ * - ./page-break-calculator.ts - Core pagination algorithm
+ * - ./overflow-handler.ts - Overflow field handling
+ * - ./paginated-renderer.ts - Paginated renderer
+ * - ./index.ts - Module entry
+ */
+/**
+ * Pagination module default configuration
+ */
+declare const PAGINATION_DEFAULTS: {
+    /** Maximum characters for overflow field first page */
+    readonly OVERFLOW_FIRST_LINE_CHARS: 60;
+    /** Minimum table row height estimate (mm) */
+    readonly MIN_ROW_HEIGHT: 8;
+    /** Default DPI (dots per inch), standard screen DPI is 96 */
+    readonly DPI: 96;
+    /** 1 inch = 25.4 millimeters */
+    readonly MM_PER_INCH: 25.4;
+    /** Default margins (mm) */
+    readonly MARGIN: {
+        readonly TOP: 8;
+        readonly BOTTOM: 8;
+        readonly LEFT: 10;
+        readonly RIGHT: 10;
+    };
+};
 /** @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
+ *
+ * ## Page Structure and Item Types
+ *
+ * ```
+ * ┌─────────────────────────────────────┐
+ * │           Header                    │  → type: 'header'
+ * │   Hospital, Department, Title       │
+ * ├─────────────────────────────────────┤
+ * │           Body                      │
+ * │   - info-grid, checkbox-grid        │  → type: 'section'
+ * │   - table header                    │  → type: 'table-header'
+ * │   - table rows                      │  → type: 'table-row'
+ * │   - notes-section                   │  → type: 'footer' (!)
+ * ├─────────────────────────────────────┤
+ * │           Footer                    │
+ * │   - Signature Area                  │  → type: 'signature'
+ * │   - Page Number + Notes             │  → type: 'footer'
+ * └─────────────────────────────────────┘
+ * ```
+ *
+ * ## Type Definitions
+ *
+ * - **header**: Page header (.print-header), contains hospital/department/title
+ * - **section**: Content sections like info-grid, checkbox-grid
+ * - **table-header**: Table header row (thead)
+ * - **table-row**: Table body row (tbody tr)
+ * - **signature**: Signature area (.signature-area), separate from footer
+ * - **footer**: Page footer (.print-footer) containing page number and notes,
+ *               also includes notes-section elements
+ *
+ * ## Important: Signature vs Footer
+ *
+ * Signature area has its own type 'signature', NOT 'footer'.
+ * This allows different pagination behavior:
+ * - Footer (page number): Always shown on each page
+ * - Signature: Configurable via signatureOnEachPage (true/false)
+ *
  * @requirements 9.1 - Identify different types of content items
  */
 declare const MEASURABLE_ITEM_TYPES: {
+    /** Page header with hospital, department, title */
     readonly HEADER: "header";
+    /** Content section (info-grid, checkbox-grid, etc.) */
     readonly SECTION: "section";
+    /** Table header row */
     readonly TABLE_HEADER: "table-header";
+    /** Table body row */
     readonly TABLE_ROW: "table-row";
+    /** Signature area (separate from footer, has own pagination rules) */
     readonly SIGNATURE: "signature";
+    /** Page footer with page number and notes */
     readonly FOOTER: "footer";
 };
 /**
@@ -2593,6 +2798,11 @@ interface PageDimensions {
     /** Right margin (mm) */
     marginRight: number;
 }
+/**
+ * Page size preset names
+ * @requirements 3.1 - Support A4, A5, 16K page sizes
+ */
+type PageSizePreset = '16K' | 'A4' | 'A5';
 /**
  * Measurable content item
  * @requirements 9.7 - Support pre-measuring content height
@@ -2746,11 +2956,43 @@ interface PageBreakOptions {
     footerHeight?: number;
     /** Whether to repeat table headers, default true */
     repeatTableHeaders?: boolean;
+    /**
+     * Extra height to reserve on the last page only (px), default 0
+     * Used for signature area when signatureOnEachPage is false
+     */
+    lastPageExtraHeight?: number;
+}
+/**
+ * Overflow text configuration for internationalization
+ * Configures user-visible text for overflow field pagination
+ *
+ * @requirements 5.1 - Support i18n for overflow text
+ *
+ * @example
+ * // Use Chinese (default)
+ * const config = { overflowText: DEFAULT_OVERFLOW_TEXT }
+ *
+ * // Use English
+ * const config = { overflowText: ENGLISH_OVERFLOW_TEXT }
+ */
+interface OverflowTextConfig {
+    /** Continuation marker on first page, e.g., "（续见附页）" */
+    seeNextMarker: string;
+    /** Label suffix on continuation page, e.g., "（续）" */
+    continuationSuffix: string;
+    /** Page title suffix for continuation pages, e.g., "（续）" */
+    pageTitleSuffix: string;
 }
 /**
- * Page size preset name
+ * Default overflow text configuration (Chinese)
+ * @requirements 5.1 - Default Chinese text
  */
-type PageSizePreset = '16K' | 'A4' | 'A5';
+declare const DEFAULT_OVERFLOW_TEXT: OverflowTextConfig;
+/**
+ * English overflow text configuration
+ * @requirements 5.1 - English text option
+ */
+declare const ENGLISH_OVERFLOW_TEXT: OverflowTextConfig;
 
 /**
  * @fileoverview Page dimension configuration and unit conversion
@@ -2946,6 +3188,7 @@ declare function buildTableHeaderMap(items: MeasurableItem[]): Map<string, Measu
  * 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)
+ * 6. Reserve extra height on last page for signature (when lastPageExtraHeight is set)
  *
  * @param items - All measurable content items
  * @param options - Page break calculation options
@@ -2999,11 +3242,11 @@ declare function getPageContentHeight(page: PageContent, items: MeasurableItem[]
  * - 9.7: Support overflow field pagination
  *
  * @dependencies
- * - ./types.ts - Type definitions
+ * - ../../types.ts - Type definitions
  *
  * @usedBy
  * - ./index.ts - Module entry
- * - ../renderer/paginated-renderer.ts - Paginated renderer (to be implemented)
+ * - ../../paginated-renderer.ts - Paginated renderer
  */
 
 /**
@@ -3092,13 +3335,742 @@ declare function processOverflowFields(data: Record<string, unknown>, configs: O
  */
 declare function hasAnyOverflowContent(data: Record<string, unknown>, configs: OverflowFieldConfig[]): boolean;
 
+/**
+ * @fileoverview Overflow field pagination rendering
+ * @module pagination/overflow-pagination
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-04
+ * @modified 2026-01-04
+ *
+ * @description
+ * Handles overflow field pagination rendering logic:
+ * - Identifies sections containing overflow fields
+ * - First page displays truncated content + continuation marker (red "see next page")
+ * - Continuation pages display remaining content with field label + "(continued)" suffix
+ * - Integrates with existing pagination features
+ *
+ * @requirements
+ * - 1.1: Identify sections containing overflow fields
+ * - 1.2: Support info-grid sections with overflow fields
+ * - 1.3: Support multiple overflow fields
+ * - 2.1: Render truncated content on first page
+ * - 2.2: Append continuation marker when there is overflow content
+ * - 3.1: Render remaining content on continuation pages
+ * - 3.2: Display field label with continuation suffix
+ *
+ * @dependencies
+ * - ./overflow-handler.ts - Overflow field processing core logic
+ * - ../../types.ts - Type definitions
+ * - ../../../types/print-schema.ts - PrintSection types
+ *
+ * @usedBy
+ * - ../../paginated-renderer.ts - Paginated renderer
+ */
+
+/** Class name generator function type */
+type ClassNameFn = (name: string) => string;
+/**
+ * Overflow field render context
+ * Contains all information needed to render overflow fields
+ */
+interface OverflowRenderContext {
+    /** Overflow field processing result */
+    result: OverflowFieldResult;
+    /** Field label (for continuation page display) */
+    fieldLabel: string;
+    /** Whether this is the first page */
+    isFirstPage: boolean;
+}
+/** CSS class names for overflow field rendering */
+declare const OVERFLOW_CSS_CLASSES: {
+    /** First page truncated content container */
+    readonly OVERFLOW_FIRST_LINE: "overflow-first-line";
+    /** Continuation page content container */
+    readonly OVERFLOW_CONTINUATION: "overflow-continuation";
+    /** "see next page" marker (red color) */
+    readonly SEE_NEXT: "see-next";
+    /** Field label on continuation page */
+    readonly OVERFLOW_LABEL: "overflow-label";
+    /** Overflow content (preserves whitespace) */
+    readonly OVERFLOW_CONTENT: "overflow-content";
+};
+/**
+ * Check if a section contains overflow fields
+ *
+ * @param section - PrintSection to check
+ * @param overflowFields - List of overflow field names
+ * @returns Whether section contains any overflow field
+ *
+ * @requirements 1.1, 1.2 - Identify sections containing overflow fields
+ *
+ * @example
+ * const isOverflow = isOverflowSection(section, ['nursingPoints'])
+ */
+declare function isOverflowSection(section: PrintSection, overflowFields: string[]): boolean;
+/**
+ * Find the label for an overflow field from section configuration
+ *
+ * @param section - PrintSection containing the field
+ * @param fieldName - Field name to find
+ * @returns Field label, or fieldName if not found
+ *
+ * @requirements 1.2 - Extract field label from info-grid configuration
+ *
+ * @example
+ * const label = findOverflowFieldLabel(section, 'nursingPoints')
+ * // Returns: "Nursing Points (add attachment if needed)"
+ */
+declare function findOverflowFieldLabel(section: PrintSection, fieldName: string): string;
+/**
+ * Find overflow field cell from section
+ *
+ * @param section - PrintSection to search
+ * @param fieldName - Field name to find
+ * @returns InfoGridCell if found, undefined otherwise
+ */
+declare function findOverflowFieldCell(section: PrintSection, fieldName: string): InfoGridCell | undefined;
+/**
+ * Extract overflow field configurations from PaginationConfig
+ *
+ * @param paginationConfig - Pagination configuration
+ * @returns Array of overflow field configurations
+ *
+ * @requirements 1.3 - Support multiple overflow fields
+ *
+ * @example
+ * const configs = getOverflowFieldsFromConfig(schema.pagination)
+ */
+declare function getOverflowFieldsFromConfig(paginationConfig?: PaginationConfig): OverflowFieldConfig[];
+/**
+ * Get overflow field names from PaginationConfig
+ *
+ * @param paginationConfig - Pagination configuration
+ * @returns Array of overflow field names
+ */
+declare function getOverflowFieldNames(paginationConfig?: PaginationConfig): string[];
+/**
+ * Render overflow field content for first page
+ * Displays truncated content with red "(see next page)" marker when there is overflow
+ *
+ * @param value - Field value
+ * @param maxChars - Maximum characters to display
+ * @param textConfig - Overflow text configuration for i18n
+ * @param cls - Class name generator function
+ * @returns Rendered HTML string
+ *
+ * @requirements 2.1, 2.2, 2.3, 2.4 - First page overflow rendering
+ *
+ * @example
+ * // Output: "1. Breastfeeding guidance <span class="see-next">(see next page)</span>"
+ * renderOverflowFirstLine(value, 60, DEFAULT_OVERFLOW_TEXT, cls)
+ */
+declare function renderOverflowFirstLine(value: unknown, maxChars: number, textConfig: OverflowTextConfig, cls: ClassNameFn): string;
+/**
+ * Render overflow field content for continuation page
+ * Displays field label with "(continued)" suffix and remaining content
+ *
+ * @param result - Overflow field processing result
+ * @param fieldLabel - Field label (e.g., "Nursing Points (add attachment if needed)")
+ * @param textConfig - Overflow text configuration for i18n
+ * @param cls - Class name generator function
+ * @returns Rendered HTML string
+ *
+ * @requirements 3.1, 3.2, 3.3, 3.4 - Continuation page overflow rendering
+ *
+ * @example
+ * // Output:
+ * // <div class="overflow-continuation">
+ * //   <div class="overflow-label">Nursing Points (continued):</div>
+ * //   <div class="overflow-content">2. Umbilical care, keep dry\n3. Jaundice monitoring...</div>
+ * // </div>
+ */
+declare function renderOverflowContinuation(result: OverflowFieldResult, fieldLabel: string, textConfig: OverflowTextConfig, cls: ClassNameFn): string;
+/**
+ * Merge overflow text configuration with defaults
+ *
+ * @param config - Partial overflow text configuration
+ * @returns Complete overflow text configuration
+ */
+declare function mergeOverflowTextConfig(config?: Partial<OverflowTextConfig>): OverflowTextConfig;
+/**
+ * Overflow continuation page render context
+ */
+interface OverflowContinuationPageContext {
+    /** Page number for this continuation page */
+    pageNumber: number;
+    /** Total pages (including this continuation page) */
+    totalPages: number;
+    /** Form title */
+    title: string;
+    /** Hospital name */
+    hospital?: string;
+    /** Department name */
+    department?: string;
+    /** Overflow field results with labels */
+    overflowFields: Array<{
+        result: OverflowFieldResult;
+        label: string;
+    }>;
+    /** Overflow text configuration */
+    textConfig: OverflowTextConfig;
+    /** Whether to show signature area */
+    showSignature?: boolean;
+    /** Signature HTML (pre-rendered) */
+    signatureHtml?: string;
+    /** Page number format */
+    pageNumberFormat?: string;
+}
+/**
+ * Render complete overflow continuation page
+ * Includes header (with "(continued)" suffix), overflow content, optional signature, and footer
+ *
+ * @param ctx - Continuation page context
+ * @param cls - Class name generator function
+ * @param pageSize - Page size class (e.g., "16k", "a4")
+ * @param orientation - Page orientation (e.g., "portrait", "landscape")
+ * @returns Rendered page HTML
+ *
+ * @requirements 3.1, 4.2, 4.3 - Continuation page rendering
+ *
+ * @example
+ * const pageHtml = renderOverflowContinuationPage(ctx, cls, '16k', 'portrait')
+ */
+declare function renderOverflowContinuationPage(ctx: OverflowContinuationPageContext, cls: ClassNameFn, pageSize?: string, orientation?: string): string;
+/**
+ * Check if any overflow fields have continuation content
+ *
+ * @param overflowFields - Array of overflow field results
+ * @returns Whether any field has continuation content
+ */
+declare function hasAnyContinuationContent(overflowFields: Array<{
+    result: OverflowFieldResult;
+}>): boolean;
+
+/**
+ * @fileoverview Pagination strategy interface and context
+ * @module pagination/strategies/pagination-strategy
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-04
+ * @modified 2026-01-04
+ *
+ * @description
+ * Defines the unified pagination strategy interface and context class.
+ * Implements the Strategy pattern for different pagination approaches:
+ * - Smart pagination (table-based measurement)
+ * - Overflow pagination (long text field handling)
+ *
+ * @requirements
+ * - 1.1: Define unified PaginationStrategy interface
+ * - 1.2: Interface has name property
+ * - 1.3: Interface has shouldApply method
+ * - 1.4: Interface has render method
+ * - 4.1: PaginationContext accepts strategies in constructor
+ * - 4.2: Context provides getApplicableStrategies method
+ * - 4.3: Context provides render method
+ * - 4.4: Context executes applicable strategies
+ *
+ * @dependencies
+ * - ../../types/print-schema - PrintSchema and FormData types
+ * - ../types - PaginationConfig and related types
+ *
+ * @usedBy
+ * - ./smart/smart-pagination-strategy.ts - Smart pagination strategy
+ * - ./overflow/overflow-pagination-strategy.ts - Overflow pagination strategy
+ * - ../paginated-renderer.ts - Main pagination renderer
+ */
+
+/**
+ * Extended PrintSchema with pagination configuration
+ * @requirements 1.1 - Support pagination configuration in schema
+ */
+interface PrintSchemaWithPagination extends PrintSchema {
+    /** Pagination configuration */
+    pagination?: PaginationConfig;
+}
+/**
+ * Pagination render options
+ * @requirements 1.4 - Render method options parameter
+ */
+interface PaginationRenderOptions {
+    /** Whether to render in isolated mode (with CSS namespace) */
+    isolated?: boolean;
+    /** Pre-measured content items for smart pagination */
+    measuredItems?: MeasurableItem[];
+    /** Overflow text configuration for i18n */
+    textConfig?: Partial<OverflowTextConfig>;
+}
+/**
+ * Pagination strategy interface
+ * Defines unified API for different pagination approaches
+ *
+ * @requirements 1.1, 1.2, 1.3, 1.4 - Unified pagination strategy interface
+ *
+ * @example
+ * class MyPaginationStrategy implements PaginationStrategy {
+ *   readonly name = 'my-strategy'
+ *
+ *   shouldApply(schema: PrintSchemaWithPagination): boolean {
+ *     return schema.pagination?.myStrategy?.enabled === true
+ *   }
+ *
+ *   render(schema: PrintSchemaWithPagination, data: FormData, options?: PaginationRenderOptions): string {
+ *     // Implementation here
+ *     return '<div>Rendered content</div>'
+ *   }
+ * }
+ */
+interface PaginationStrategy {
+    /**
+     * Strategy name identifier
+     * @requirements 1.2 - Interface has name property
+     */
+    readonly name: string;
+    /**
+     * Check if this strategy should be applied to the given schema
+     * @param schema - Print schema with pagination configuration
+     * @returns Whether this strategy applies
+     * @requirements 1.3 - Interface has shouldApply method
+     */
+    shouldApply(schema: PrintSchemaWithPagination): boolean;
+    /**
+     * Render paginated content using this strategy
+     * @param schema - Print schema with pagination configuration
+     * @param data - Form data to render
+     * @param options - Render options
+     * @returns Rendered HTML string
+     * @requirements 1.4 - Interface has render method
+     */
+    render(schema: PrintSchemaWithPagination, data: FormData, options?: PaginationRenderOptions): string;
+}
+/**
+ * Pagination context class
+ * Manages strategy selection and execution using the Strategy pattern
+ *
+ * @requirements 4.1, 4.2, 4.3, 4.4 - Strategy context implementation
+ *
+ * @example
+ * const strategies = [new SmartPaginationStrategy(), new OverflowPaginationStrategy()]
+ * const context = new PaginationContext(strategies)
+ *
+ * const applicableStrategies = context.getApplicableStrategies(schema)
+ * const html = context.render(schema, data, options)
+ */
+declare class PaginationContext {
+    private strategies;
+    /**
+     * Create pagination context with strategies
+     * @param strategies - Array of pagination strategies
+     * @requirements 4.1 - Context accepts strategies in constructor
+     */
+    constructor(strategies: PaginationStrategy[]);
+    /**
+     * Get strategies that apply to the given schema
+     * @param schema - Print schema with pagination configuration
+     * @returns Array of applicable strategies
+     * @requirements 4.2 - Context provides getApplicableStrategies method
+     */
+    getApplicableStrategies(schema: PrintSchemaWithPagination): PaginationStrategy[];
+    /**
+     * Render content using applicable strategies
+     * Uses the first applicable strategy, falls back to non-paginated rendering if none apply
+     * @param schema - Print schema with pagination configuration
+     * @param data - Form data to render
+     * @param options - Render options
+     * @returns Rendered HTML string
+     * @requirements 4.3, 4.4 - Context provides render method and executes strategies
+     */
+    render(schema: PrintSchemaWithPagination, data: FormData, options?: PaginationRenderOptions): string;
+    /**
+     * Add a strategy to the context
+     * @param strategy - Strategy to add
+     */
+    addStrategy(strategy: PaginationStrategy): void;
+    /**
+     * Remove a strategy from the context
+     * @param strategyName - Name of strategy to remove
+     * @returns Whether strategy was found and removed
+     */
+    removeStrategy(strategyName: string): boolean;
+    /**
+     * Get all registered strategies
+     * @returns Array of all strategies
+     */
+    getAllStrategies(): readonly PaginationStrategy[];
+    /**
+     * Get strategy by name
+     * @param name - Strategy name
+     * @returns Strategy if found, undefined otherwise
+     */
+    getStrategy(name: string): PaginationStrategy | undefined;
+}
+
+/**
+ * @fileoverview Measurement strategy interface (GoF Strategy Pattern)
+ * @module pagination/strategies/smart/measurement-strategy
+ * @version 1.4.0
+ * @author Kiro
+ * @created 2026-01-05
+ * @modified 2026-01-05
+ *
+ * @description
+ * Defines the MeasurementStrategy interface for decoupling measurement logic
+ * from pagination logic. This follows the GoF Strategy Pattern to allow
+ * different measurement implementations (e.g., DOM-based measurement).
+ *
+ * @requirements
+ * - 1.1: Define MeasurementStrategy interface with measure method
+ * - 1.2: Interface supports DOM-based measurement implementation
+ *
+ * @dependencies
+ * - ../pagination-strategy - PrintSchemaWithPagination type
+ * - ../../../types/print-schema - FormData type
+ * - ../../types - MeasurableItem type
+ *
+ * @usedBy
+ * - ./dom-measurement-strategy.ts - DOM measurement implementation
+ * - ./smart-pagination-strategy.ts - Smart pagination strategy
+ */
+
+/**
+ * Measurement configuration options
+ * Provides parameters needed for content measurement
+ *
+ * @requirements 1.1 - Configuration for measurement strategy
+ */
+interface MeasurementConfig {
+    /**
+     * Minimum row height in millimeters (for fallback estimation)
+     * Used when actual measurement is not possible
+     * @default 8
+     */
+    minRowHeight: number;
+    /**
+     * Available page height in pixels
+     * Used to determine content fitting and page breaks
+     */
+    pageHeight: number;
+}
+/**
+ * Measurement strategy interface (GoF Strategy Pattern)
+ *
+ * Defines a unified interface for measuring content heights.
+ * Implementations can provide different measurement approaches:
+ * - DOM-based measurement (browser environment)
+ * - Estimation-based measurement (fallback)
+ *
+ * @requirements 1.1, 1.2 - Unified measurement interface supporting DOM-based implementation
+ *
+ * @example
+ * ```typescript
+ * class DomMeasurementStrategy implements MeasurementStrategy {
+ *   measure(schema, data, config): MeasurableItem[] {
+ *     // Render to hidden container and measure actual heights
+ *     return measuredItems
+ *   }
+ * }
+ *
+ * // Usage with SmartPaginationStrategy
+ * const strategy = new SmartPaginationStrategy(new DomMeasurementStrategy())
+ * ```
+ */
+interface MeasurementStrategy {
+    /**
+     * Measure content and return measurable items with heights
+     *
+     * Implementations should:
+     * 1. Analyze the schema to identify measurable content
+     * 2. Use the data to determine actual content (e.g., table row count)
+     * 3. Measure or estimate heights for each content item
+     * 4. Return an array of MeasurableItem objects
+     *
+     * For table sections, implementations should create:
+     * - One item for the table header
+     * - One item for each data row
+     *
+     * @param schema - Print schema with pagination configuration
+     * @param data - Form data containing actual content (e.g., table rows)
+     * @param config - Measurement configuration options
+     * @returns Array of measurable items with heights in pixels
+     *
+     * @throws Error if measurement cannot be performed (e.g., non-browser environment for DOM strategy)
+     *
+     * @requirements 1.1 - measure method signature
+     * @requirements 1.2 - Support DOM-based measurement
+     */
+    measure(schema: PrintSchemaWithPagination, data: FormData, config: MeasurementConfig): MeasurableItem[];
+}
+
+/**
+ * @fileoverview Smart pagination strategy adapter
+ * @module pagination/strategies/smart/smart-pagination-strategy
+ * @version 1.4.0
+ * @author Kiro
+ * @created 2026-01-04
+ * @modified 2026-01-05
+ *
+ * @description
+ * Smart pagination strategy adapter that wraps the existing page-break-calculator logic.
+ * Implements the PaginationStrategy interface for table-based measurement pagination.
+ * Delegates to existing calculatePageBreaks function without modifying the algorithm.
+ *
+ * Uses GoF Strategy Pattern for measurement logic - accepts a MeasurementStrategy
+ * via dependency injection, defaulting to DomMeasurementStrategy for browser-based
+ * DOM measurement.
+ *
+ * @requirements
+ * - 1.3: SmartPaginationStrategy uses MeasurementStrategy for content measurement
+ * - 2.1: Create SmartPaginationStrategy in strategies/smart/
+ * - 2.3: Implement PaginationStrategy interface
+ * - 2.4: Delegate to existing calculatePageBreaks and renderPaginatedHtml
+ * - 2.5: shouldApply checks pagination.smartPagination.enabled === true
+ * - 4.1, 4.2, 4.3, 4.4: Pass correct measurement data to pagination algorithm
+ * - 5.1, 5.2, 5.3, 5.4: Deprecate estimateItems method
+ *
+ * @dependencies
+ * - ../pagination-strategy - PaginationStrategy interface
+ * - ./page-break-calculator - Existing smart pagination algorithm
+ * - ./measurement-strategy - MeasurementStrategy interface
+ * - ./dom-measurement-strategy - Default DOM measurement implementation
+ * - ../../paginated-renderer - Paginated HTML renderer
+ * - ../../types - Type definitions
+ *
+ * @usedBy
+ * - ../index.ts - Strategy exports
+ * - ../../paginated-renderer.ts - Main pagination renderer
+ */
+
+/**
+ * Smart pagination strategy adapter
+ * Wraps existing smart pagination logic in strategy interface
+ *
+ * Uses GoF Strategy Pattern for measurement - accepts a MeasurementStrategy
+ * via constructor injection, defaulting to DomMeasurementStrategy.
+ *
+ * @requirements 1.3, 2.1, 2.3, 2.4, 2.5, 4.1, 4.2, 4.3, 4.4 - Smart pagination strategy implementation
+ *
+ * @example
+ * // Default usage with DomMeasurementStrategy
+ * const strategy = new SmartPaginationStrategy()
+ * if (strategy.shouldApply(schema)) {
+ *   const html = strategy.render(schema, data, options)
+ * }
+ *
+ * @example
+ * // Custom measurement strategy
+ * const customStrategy = new SmartPaginationStrategy(myCustomMeasurementStrategy)
+ */
+declare class SmartPaginationStrategy implements PaginationStrategy {
+    /**
+     * Strategy name identifier
+     * @requirements 2.1 - Strategy name
+     */
+    readonly name = "smart-pagination";
+    /**
+     * Measurement strategy for content measurement (GoF Strategy Pattern)
+     * @requirements 1.3 - Use MeasurementStrategy for content measurement
+     */
+    private measurementStrategy;
+    /**
+     * Constructor with optional measurement strategy injection
+     * @param measurementStrategy - Custom measurement strategy (defaults to DomMeasurementStrategy)
+     * @requirements 1.3 - Dependency injection for measurement strategy
+     */
+    constructor(measurementStrategy?: MeasurementStrategy);
+    /**
+     * Check if smart pagination should be applied
+     * @param schema - Print schema with pagination configuration
+     * @returns Whether smart pagination is enabled
+     * @requirements 2.5 - shouldApply checks smartPagination.enabled
+     */
+    shouldApply(schema: PrintSchemaWithPagination): boolean;
+    /**
+     * Render content using smart pagination
+     * Delegates to existing calculatePageBreaks and renderPaginatedHtml functions
+     * Uses injected measurement strategy for DOM measurement
+     * @param schema - Print schema with pagination configuration
+     * @param data - Form data to render
+     * @param options - Render options
+     * @returns Rendered HTML string
+     * @requirements 1.3, 2.3, 2.4, 3.1, 3.2, 4.1, 4.2, 4.3, 4.4 - Delegate to existing functions with correct measurement data
+     */
+    render(schema: PrintSchemaWithPagination, data: FormData, options?: PaginationRenderOptions): string;
+    /**
+     * Extract header height from measured items
+     * Finds the item with type 'header' and returns its height
+     * @param items - All measured items
+     * @returns Header height in pixels, or 0 if no header item found
+     * @requirements 1.1, 1.2, 1.4 - Extract header height from measured results
+     */
+    private extractHeaderHeight;
+    /**
+     * Extract footer height from measured items
+     * Only includes 'footer' type items. Signature height is handled separately
+     * based on signatureOnEachPage configuration.
+     * @param items - All measured items
+     * @returns Footer height in pixels, or 0 if no footer items found
+     * @requirements 2.1, 2.2, 2.4 - Extract footer height from measured results
+     */
+    private extractFooterHeight;
+    /**
+     * Extract signature height from measured items
+     * @param items - All measured items
+     * @returns Signature height in pixels, or 0 if no signature items found
+     */
+    private extractSignatureHeight;
+    /**
+     * Filter content items for pagination calculation
+     * Excludes header, footer, and signature items - only keeps section and table items
+     * @param items - All measured items
+     * @returns Array containing only section, table-header, and table-row items
+     * @requirements 4.1, 4.2, 4.3, 4.4 - Filter non-content items from pagination
+     */
+    private filterContentItems;
+    /**
+     * Get page height for pagination calculation
+     * @param _schema - Print schema (unused in current implementation)
+     * @returns Page height in pixels
+     */
+    private getPageHeight;
+    /**
+     * Estimate measurable items when not provided
+     * Creates basic section items for each schema section
+     *
+     * @deprecated Since v1.4.0. Use DomMeasurementStrategy instead.
+     * This method only provides rough estimates and does not measure actual DOM heights.
+     * The method is no longer used internally - SmartPaginationStrategy now uses
+     * MeasurementStrategy (default: DomMeasurementStrategy) for accurate DOM-based measurement.
+     * Will be removed in v2.0.0.
+     *
+     * @see {@link DomMeasurementStrategy} - For accurate DOM-based measurement
+     * @see {@link MeasurementStrategy} - Interface for custom measurement strategies
+     *
+     * @param schema - Print schema
+     * @returns Estimated measurable items (inaccurate)
+     * @requirements 5.1, 5.2, 5.3, 5.4 - Deprecated method with annotations
+     */
+    private estimateItems;
+}
+
+/**
+ * @fileoverview Overflow pagination strategy adapter
+ * @module pagination/strategies/overflow/overflow-pagination-strategy
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-04
+ * @modified 2026-01-04
+ *
+ * @description
+ * Overflow pagination strategy adapter that wraps the existing overflow-handler logic.
+ * Implements the PaginationStrategy interface for long text field pagination.
+ * Delegates to existing processOverflowFields and renderPaginatedHtml functions.
+ *
+ * @requirements
+ * - 3.1: Create OverflowPaginationStrategy in strategies/overflow/
+ * - 3.3: Implement PaginationStrategy interface
+ * - 3.4: Delegate to existing renderPaginatedHtml with overflow config
+ * - 3.5: shouldApply checks pagination.overflow.fields has items
+ *
+ * @dependencies
+ * - ../pagination-strategy - PaginationStrategy interface
+ * - ./overflow-handler - Existing overflow field processing
+ * - ../../paginated-renderer - Paginated HTML renderer
+ * - ../../types - Type definitions
+ *
+ * @usedBy
+ * - ../index.ts - Strategy exports
+ * - ../../paginated-renderer.ts - Main pagination renderer
+ */
+
+/**
+ * Overflow pagination strategy adapter
+ * Wraps existing overflow field processing logic in strategy interface
+ *
+ * @requirements 3.1, 3.3, 3.4, 3.5 - Overflow pagination strategy implementation
+ *
+ * @example
+ * const strategy = new OverflowPaginationStrategy()
+ * if (strategy.shouldApply(schema)) {
+ *   const html = strategy.render(schema, data, options)
+ * }
+ */
+declare class OverflowPaginationStrategy implements PaginationStrategy {
+    /**
+     * Strategy name identifier
+     * @requirements 3.1 - Strategy name
+     */
+    readonly name = "overflow-pagination";
+    /**
+     * Check if overflow pagination should be applied
+     * @param schema - Print schema with pagination configuration
+     * @returns Whether overflow pagination is configured
+     * @requirements 3.5 - shouldApply checks pagination.overflow.fields has items
+     */
+    shouldApply(schema: PrintSchemaWithPagination): boolean;
+    /**
+     * Render content using overflow pagination
+     * Delegates to existing renderPaginatedHtml with overflow configuration
+     * @param schema - Print schema with pagination configuration
+     * @param data - Form data to render
+     * @param options - Render options
+     * @returns Rendered HTML string
+     * @requirements 3.4 - Delegate to existing renderPaginatedHtml with overflow config
+     */
+    render(schema: PrintSchemaWithPagination, data: FormData, options?: PaginationRenderOptions): string;
+    /**
+     * Create single page result for overflow pagination
+     * Overflow pagination uses a single logical page, with continuation pages handled separately
+     * @returns Single page break result
+     */
+    private createSinglePageResult;
+    /**
+     * Merge overflow text configuration with defaults
+     * @param config - Partial overflow text configuration
+     * @returns Complete overflow text configuration
+     */
+    private mergeOverflowTextConfig;
+}
+
+/**
+ * @fileoverview Pagination strategies main exports
+ * @module pagination/strategies
+ * @version 1.0.0
+ * @author Kiro
+ * @created 2026-01-04
+ * @modified 2026-01-04
+ *
+ * @description
+ * Main export file for all pagination strategies and related utilities.
+ * Provides unified access to the strategy pattern implementation.
+ *
+ * @requirements
+ * - 5.3: Export all strategies and context
+ * - 5.3: Export createDefaultPaginationContext factory
+ *
+ * @usedBy
+ * - ../index.ts - Pagination module main export
+ * - ../paginated-renderer.ts - Pagination renderer
+ */
+
+/**
+ * Create default pagination context with built-in strategies
+ * @returns PaginationContext with SmartPaginationStrategy and OverflowPaginationStrategy
+ * @requirements 5.3 - Export createDefaultPaginationContext factory
+ *
+ * @example
+ * const context = createDefaultPaginationContext()
+ * const html = context.render(schema, data, options)
+ */
+declare function createDefaultPaginationContext(): PaginationContext;
+
 /**
  * @fileoverview Paginated renderer
  * @module pagination/paginated-renderer
- * @version 1.1.0
+ * @version 1.3.0
  * @author Kiro
  * @created 2026-01-02
- * @modified 2026-01-03
+ * @modified 2026-01-05
  *
  * @description
  * Renders pagination results to multi-page HTML, each page independent and printable.
@@ -3108,6 +4080,7 @@ declare function hasAnyOverflowContent(data: Record<string, unknown>, configs: O
  * - Footer rendering on each page (page number display)
  * - Automatic table header insertion on continuation pages
  * - CSS pagination rules
+ * - Overflow field pagination with i18n support
  *
  * @requirements
  * - 11.1: Render each page as independent .print-page element
@@ -3116,6 +4089,7 @@ declare function hasAnyOverflowContent(data: Record<string, unknown>, configs: O
  * - 11.4: Add "(continued)" marker to continuation page titles
  * - 11.5: Support CSS page-break rules
  * - 11.6: Maintain consistent styles across pages
+ * - 5.1: Support i18n for overflow text
  *
  * @dependencies
  * - ./types.ts - Type definitions
@@ -3154,6 +4128,17 @@ interface PaginatedRenderConfig {
      * @default false
      */
     isolated?: boolean;
+    /**
+     * Overflow text configuration for i18n support
+     * Configures user-visible text for overflow field pagination
+     * @default DEFAULT_OVERFLOW_TEXT (Chinese)
+     *
+     * @example
+     * // Use English text
+     * import { ENGLISH_OVERFLOW_TEXT } from 'medical-form-printer'
+     * config: { overflowText: ENGLISH_OVERFLOW_TEXT }
+     */
+    overflowText?: Partial<OverflowTextConfig>;
 }
 /**
  * Paginated render context
@@ -3180,6 +4165,37 @@ 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)
+ * @requirements 2.1, 2.2, 3.1, 3.2 - Overflow field pagination
+ *
+ * @deprecated Since v1.3.0. Will be removed in v2.0.0.
+ * Use the strategy pattern API instead for better maintainability and extensibility.
+ *
+ * @see {@link createDefaultPaginationContext} - Factory for automatic strategy selection
+ * @see {@link SmartPaginationStrategy} - Table-based smart pagination
+ * @see {@link OverflowPaginationStrategy} - Long text field overflow handling
+ *
+ * @migration
+ * ```typescript
+ * // ❌ Before (deprecated)
+ * import { renderPaginatedHtml, calculatePageBreaks } from 'medical-print-renderer'
+ * const pageBreakResult = calculatePageBreaks(items, options)
+ * const html = renderPaginatedHtml({
+ *   schema, data, pageBreakResult, measuredItems: items,
+ *   config: { isolated: true }
+ * })
+ *
+ * // ✅ After (recommended) - Option 1: Automatic strategy selection
+ * import { createDefaultPaginationContext } from 'medical-print-renderer'
+ * const context = createDefaultPaginationContext()
+ * const html = context.render(schema, data, { isolated: true })
+ *
+ * // ✅ After (recommended) - Option 2: Direct strategy usage
+ * import { SmartPaginationStrategy } from 'medical-print-renderer'
+ * const strategy = new SmartPaginationStrategy()
+ * if (strategy.shouldApply(schema)) {
+ *   const html = strategy.render(schema, data, { isolated: true })
+ * }
+ * ```
  *
  * @param context - Paginated render context
  * @returns Complete paginated HTML string
@@ -3203,17 +4219,45 @@ declare const DEFAULT_PAGINATED_RENDER_CONFIG: Required<PaginatedRenderConfig>;
  *   measuredItems: items,
  *   config: { isolated: true }
  * })
+ *
+ * @example
+ * // With overflow field pagination (Chinese text)
+ * const html = renderPaginatedHtml({
+ *   schema: printSchemaWithOverflow,
+ *   data: formDataWithLongText,
+ *   pageBreakResult: result,
+ *   measuredItems: items,
+ * })
+ *
+ * @example
+ * // With overflow field pagination (English text)
+ * import { ENGLISH_OVERFLOW_TEXT } from 'medical-form-printer'
+ * const html = renderPaginatedHtml({
+ *   schema: printSchemaWithOverflow,
+ *   data: formDataWithLongText,
+ *   pageBreakResult: result,
+ *   measuredItems: items,
+ *   config: { overflowText: ENGLISH_OVERFLOW_TEXT }
+ * })
  */
 declare function renderPaginatedHtml(context: PaginatedRenderContext): string;
 /**
  * Generate pagination-related CSS rules
  * @requirements 11.5, 11.6 - CSS page-break rules
+ * @requirements 5.1, 5.2, 5.3, 5.4 - Overflow field CSS styles
  * @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
+ *
+ * @deprecated Use the strategy pattern API instead:
+ * ```typescript
+ * import { createDefaultPaginationContext } from 'medical-print-renderer'
+ * const context = createDefaultPaginationContext()
+ * const html = context.render(schema, data, { isolated: true })
+ * ```
  */
 declare function renderPaginatedHtmlSimple(schema: PrintSchema, data: FormData, pageBreakResult: PageBreakResult, measuredItems: MeasurableItem[], options?: RenderOptions, config?: PaginatedRenderConfig): string;
 /**
@@ -3224,10 +4268,10 @@ declare function createRenderConfigFromPaginationConfig(paginationConfig?: Pagin
 /**
  * @fileoverview Pagination module entry point
  * @module pagination
- * @version 1.0.0
+ * @version 1.1.0
  * @author Kiro
  * @created 2026-01-03
- * @modified 2026-01-03
+ * @modified 2026-01-04
  *
  * @description
  * Exports all pagination-related types and functions:
@@ -3235,9 +4279,11 @@ declare function createRenderConfigFromPaginationConfig(paginationConfig?: Pagin
  * - Page size configuration
  * - Pagination algorithm
  * - Overflow field handling
+ * - Strategy pattern interface and context
  *
  * @requirements
  * - 9.1: Calculate page breaks based on measured content height
+ * - 1.5: Export strategy interface and context
  *
  * @usedBy
  * - ../index.ts - Library main entry
@@ -3248,12 +4294,26 @@ declare function createRenderConfigFromPaginationConfig(paginationConfig?: Pagin
  * Print pagination utility function collection
  * Provides Vue Composable-like API style
  *
- * @param dimensions - Page size configuration, default 16K
- * @returns Pagination utility functions
+ * @deprecated Since v1.3.0. Will be removed in v2.0.0.
+ * Use the strategy pattern API instead for better maintainability.
  *
- * @example
+ * @see {@link createDefaultPaginationContext} - Recommended replacement
+ * @see {@link SmartPaginationStrategy} - For table-based pagination
+ *
+ * @migration
+ * ```typescript
+ * // ❌ Before (deprecated)
  * const { calculateBreaks, usableHeight } = usePrintPagination()
  * const result = calculateBreaks(measuredItems, usableHeight)
+ *
+ * // ✅ After (recommended)
+ * import { createDefaultPaginationContext } from 'medical-print-renderer'
+ * const context = createDefaultPaginationContext()
+ * const html = context.render(schema, data, { isolated: true })
+ * ```
+ *
+ * @param dimensions - Page size configuration, default 16K
+ * @returns Pagination utility functions
  */
 declare function usePrintPagination(dimensions?: PageDimensions): {
     /** Page size configuration */
@@ -3270,4 +4330,4 @@ declare function usePrintPagination(dimensions?: PageDimensions): {
     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 };
+export { AbstractPageRenderer, CSS_NAMESPACE, type CellType, type CheckboxGridConfig, type CheckboxOption, type ColorConfig, type ColumnConfig, ContainerSection, DEFAULT_BASE_UNIT, DEFAULT_DPI, DEFAULT_OVERFLOW_TEXT, DEFAULT_PAGINATED_RENDER_CONFIG, type DateFormatOptions, ENGLISH_OVERFLOW_TEXT, 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, MEASURABLE_ITEM_TYPES, MM_PER_INCH, type MeasurableItem, type MeasurableItemType, type MeasureResult, MeasureVisitor, type MergeDocumentItem, type MergeOptions, type NotesConfig, OVERFLOW_CSS_CLASSES, type OverflowContinuationPageContext, type OverflowFieldConfig, type OverflowFieldResult, OverflowPaginationStrategy, type OverflowRenderContext, type OverflowTextConfig, PAGE_16K, PAGE_A4, PAGE_A5, PAGE_PRESETS, PAGINATION_DEFAULTS, 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, PaginationContext, type PaginationRenderOptions, type PaginationStrategy, type PdfOptions, type PrintFooter, type PrintHeader, type PrintSchema, type PrintSchemaWithPagination, 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, SmartPaginationStrategy, 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, createDefaultPaginationContext, 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, findOverflowFieldCell, findOverflowFieldLabel, findTableHeader, footer, formatBoolean, formatDate, formatNumber, formatPadding, formatSize, formatValue, fragment, generateCss, generateIsolatedCss, generatePaginationCss, getDefaultFormatterFactory, getDefaultSectionRendererFactory, getFontCss, getFontDataUrl, getNamespacedClass, getOverflowFieldConfig, getOverflowFieldNames, getOverflowFieldsFromConfig, getOverflowFirstLine, getOverflowRest, getPageContentHeight, getPageDimensions, getPageStyles, getSectionRenderer, h, h1, hasAnyContinuationContent, hasAnyOverflowContent, hasOverflowContent, header, isChecked, isFontLoaded, isOverflowField, isOverflowSection, main, mergeOverflowTextConfig, mergeStyles, mergeTheme, mmToPt, mmToPx, namespaceClass, namespaceClasses, normalizeOpacity, p, processOverflowFields, ptToMm, pxToMm, registerSectionRenderer, renderOverflowContinuation, renderOverflowContinuationPage, renderOverflowFirstLine, renderPaginatedHtml, renderPaginatedHtmlSimple, renderSectionTree, renderToHtml, renderToIsolatedFragment, renderToIsolatedHtml, renderWatermarkHtml, scaleValue, span, styleToString, table, tbody, td, th, thead, tr, usePrintPagination, validatePageBreakResult, waitForFonts, when };