@campxdev/pdfme 1.1.0 → 1.2.1

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/parser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Parser — converts tokens into an AST (Abstract Syntax Tree).
+ * Uses recursive descent parsing with operator precedence.
+ *
+ * Input: Token[] from Lexer
+ * Output: ExprNode AST
+ */
+import type { Token } from './lexer';
+import type { ExprNode } from './ast.types';
+export declare class ParseError extends Error {
+    message: string;
+    position: number;
+    constructor(message: string, position: number);
+}
+/**
+ * Parser — builds AST from token stream.
+ */
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    /**
+     * Parse tokens into an ExprNode AST.
+     */
+    parse(): ExprNode;
+    /** Lowest precedence: OR */
+    private parseExpression;
+    private parseOr;
+    private parseAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseAdditive;
+    private parseMultiplicative;
+    private parseUnary;
+    private parsePostfix;
+    private parsePrimary;
+    private parseArguments;
+    private parseObjectLiteral;
+    private check;
+    private match;
+    private advance;
+    private current;
+    private previous;
+    private isAtEnd;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/range-resolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * RangeResolver — resolves range notation strings to ICell[] arrays.
+ *
+ * Notations:
+ *   - "col:0"     → all cells in column 0
+ *   - "col:self"  → all cells in the target column (rule scope)
+ *   - "row:3"     → all cells in row 3
+ *   - "row:self"  → all cells in the target row (rule scope)
+ *   - "r0c0:r2c3" → rectangular selection (rows 0-2, cols 0-3)
+ *   - "body"      → all body cells
+ *   - "self"      → selection rect (for selection-scoped rules)
+ */
+import type { ICell } from '../../interfaces/core/cell.interface';
+import type { EvalContext } from '../types/evaluation.types';
+export declare class RangeResolverError extends Error {
+    message: string;
+    constructor(message: string);
+}
+/**
+ * Resolve a range notation string to an array of cells.
+ * @param notation - range notation (e.g., "col:0", "row:self", "r0c0:r2c3", "body")
+ * @param ctx - evaluation context with cellRegistry, structureStore
+ * @returns array of ICell objects
+ */
+export declare function resolveRangeRef(notation: string, ctx: EvalContext): ICell[];

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/scope-vocabulary.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Palette Dictionary — what condition/result items users can pick per rule scope.
+ * Canvas uses this to render the condition builder UI.
+ * Engine evaluates the resulting expression strings; never reads this file.
+ */
+export type RuleScope = 'table' | 'region' | 'column' | 'row' | 'cell' | 'selection';
+export type ReturnType = 'string' | 'number' | 'boolean';
+/** A single palette item the user can pick from the condition builder */
+export interface PaletteItem {
+    /** Display label in canvas UI */
+    label: string;
+    /** The expression string to insert (e.g., "cell.value", "SUM(col:self)") */
+    exprTemplate: string;
+    /** What type this item evaluates to (for operator compatibility checking) */
+    returnType: ReturnType;
+    /** Whether this item needs additional parameters (e.g., CELL needs row, col) */
+    requiresParams?: boolean;
+    /** Help text for canvas tooltip */
+    description?: string;
+}
+/**
+ * Scope → Palette mapping.
+ * When canvas user selects a scope, show only items from that scope's palette.
+ */
+export declare const SCOPE_VOCABULARY: Record<RuleScope, PaletteItem[]>;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/text-measurer.d.ts

@@ -0,0 +1,88 @@
+/**
+ * TextMeasurer — pure engine-side text measurement.
+ * No renderer involved; uses font metric approximation.
+ *
+ * Font metric approximation:
+ *   charHeight = fontSize × 0.353 mm  (based on 72 DPI standard)
+ *   charWidth  = charHeight × 0.6     (monospace-ish approximation)
+ *
+ * This allows overflow detection and font size fitting without a renderer.
+ */
+import type { ICell } from '../../interfaces/core/cell.interface';
+export interface TextMetrics {
+    width: number;
+    height: number;
+}
+export interface FontStyle {
+    fontName?: string;
+    fontSize: number;
+}
+/**
+ * TextMeasurer — estimates text dimensions based on font metrics.
+ */
+export declare class TextMeasurer {
+    /**
+     * Measure text dimensions (width and height).
+     * @param text - text to measure
+     * @param style - font size and family
+     * @returns width and height in mm
+     */
+    static measureText(text: string, style: FontStyle): TextMetrics;
+    /**
+     * Check if text overflows a cell.
+     * @param cell - the cell to check
+     * @returns true if text overflows bounds
+     */
+    static cellOverflows(cell: ICell): boolean;
+    /**
+     * Find the largest font size that fits content in a cell.
+     * Iterates downward from current size until content fits or hits floor.
+     *
+     * @param text - text to fit
+     * @param style - current font style
+     * @param cellWidth - available width in mm
+     * @param cellHeight - available height in mm
+     * @param minFontSize - minimum acceptable font size (default 6)
+     * @returns font size that fits, or minFontSize if nothing fits
+     */
+    static findFittingFontSize(text: string, style: FontStyle, cellWidth: number, cellHeight: number, minFontSize?: number): number;
+    /**
+     * Wrap text to fit within a width, calculating resulting height.
+     * Simple word-wrap approximation (splits on spaces).
+     *
+     * @param text - text to wrap
+     * @param width - target width in mm
+     * @param fontSize - font size in pt
+     * @returns wrapped text and its height
+     */
+    /**
+     * Measure the required height for text wrapped within a given width.
+     * Accounts for lineHeight and characterSpacing from the cell style.
+     *
+     * @param text - text to measure
+     * @param availableWidth - available width in mm (after padding)
+     * @param style - fontSize (pt), lineHeight (multiplier), characterSpacing (pt)
+     * @returns required height in mm
+     */
+    static measureRequiredHeight(text: string, availableWidth: number, style: {
+        fontSize: number;
+        lineHeight?: number;
+        characterSpacing?: number;
+    }): number;
+    /**
+     * Measure the required width for text as a single line (no wrapping).
+     * Finds the widest line among newline-split lines.
+     *
+     * @param text - text to measure
+     * @param style - fontSize (pt), characterSpacing (pt)
+     * @returns required width in mm
+     */
+    static measureRequiredWidth(text: string, style: {
+        fontSize: number;
+        characterSpacing?: number;
+    }): number;
+    static wrapText(text: string, width: number, fontSize: number): {
+        text: string;
+        height: number;
+    };
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/var-catalog.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Variable Catalog — hardcoded Var definitions that the engine understands.
+ * Maps dot-path vars (e.g., "cell.value") to resolver functions.
+ *
+ * Canvas uses the catalog to show autocomplete / pick-list.
+ * Engine uses resolvers to evaluate Var nodes at runtime.
+ */
+import type { EvalContext } from '../types/evaluation.types';
+export interface VarDef {
+    /** Dot-path for this var (e.g., "cell.value") */
+    path: string;
+    /** Human-readable description */
+    description: string;
+    /** Return type (for operator compatibility checking) */
+    returnType: 'string' | 'number' | 'boolean';
+    /** Resolver function: given context, returns the value */
+    resolve: (ctx: EvalContext) => string | number | boolean | null | undefined;
+}
+/**
+ * Catalog of all variables the engine understands.
+ * Exported so canvas UI can display these as options.
+ */
+export declare const VAR_CATALOG: Record<string, VarDef>;
+/**
+ * Resolve a dot-path var against the given context.
+ * @param path - dot-path like "cell.value" or "table.rowCount"
+ * @param ctx - evaluation context
+ * @returns the resolved value, or null if var not found
+ */
+export declare function resolveVar(path: string, ctx: EvalContext): string | number | boolean | null | undefined;
+/**
+ * Get the list of all available var paths (for canvas UI).
+ */
+export declare function getAvailableVars(): VarDef[];

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Barrel export for the entire rules module.
+ */
+export * from './expression';
+export type { Rule, RulePayload, RuleInput, RuleUpdate } from './types/rule.types';
+export type { EvalContext, RuleOutput, StylePatch, DeltaInstruction, ComputedValue, ValidationResult as RuleValidationResult, RenderFlag, VisibilityFlag, LockFlag, EvaluationResult, ResolvedCell, RuleEvaluationStats, } from './types/evaluation.types';
+export { RuleRegistry, ruleRegistry } from './rule-registry';
+export type { IRuleRegistry, MatchContext } from '../interfaces/rules';
+export { RuleEngine } from './rule-engine';
+export type { IRuleEngine } from '../interfaces/rules';
+export { matchesCell } from './rule-matcher';
+export { SCOPE_VOCABULARY } from './expression/scope-vocabulary';
+export type { RuleScope } from './expression/scope-vocabulary';

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/rule-engine.d.ts

@@ -0,0 +1,36 @@
+/**
+ * RuleEngine — evaluates rules against cells and stores results.
+ *
+ * For each cell: find matching rules via RuleRegistry → evaluate condition AST →
+ * if true, evaluate result AST → classify output into EvaluationResult.
+ */
+import type { IRuleEngine } from '../interfaces/rules/rule-engine.interface';
+import type { IRuleRegistry } from '../interfaces/rules/rule-registry.interface';
+import type { ICellRegistry } from '../interfaces/stores/cell-registry.interface';
+import type { IStructureStore } from '../interfaces/stores/structure-store.interface';
+import type { ITable } from '../interfaces/table/table.inteface';
+import type { ICell } from '../interfaces/core';
+import type { RulePayload } from './types/rule.types';
+import type { EvaluationResult, ResolvedCell } from './types/evaluation.types';
+export declare class RuleEngine implements IRuleEngine {
+    private ruleRegistry;
+    private cellRegistry;
+    private structureStore;
+    private table;
+    private results;
+    constructor(ruleRegistry: IRuleRegistry, cellRegistry: ICellRegistry, structureStore: IStructureStore, table: ITable);
+    evaluateCell(cell: ICell): EvaluationResult;
+    evaluateAll(): void;
+    getResult(cellId: string): EvaluationResult | undefined;
+    getAllResults(): ReadonlyMap<string, EvaluationResult>;
+    resolveCell(cell: ICell): ResolvedCell;
+    clearResults(): void;
+    exportRules(): RulePayload[];
+    importRules(payloads: RulePayload[]): void;
+    private buildMatchContext;
+    private buildEvalContext;
+    private evaluateCellWithContext;
+    private evaluateRule;
+    private classifyOutput;
+    private walkTree;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/rule-matcher.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RuleMatcher — pure function that checks whether a rule's target matches a given cell.
+ *
+ * Used by RuleRegistry.getRulesForCell() to filter applicable rules.
+ */
+import type { ICell } from '../interfaces/core';
+import type { ICellRegistry } from '../interfaces/stores/cell-registry.interface';
+import type { IStructureStore } from '../interfaces/stores/structure-store.interface';
+import type { Rule } from './types/rule.types';
+export interface MatchContext {
+    /** Number of layout grid rows occupied by theader. body rowIndex = cell.layout.row - theaderDepth */
+    theaderDepth: number;
+    /** Number of layout grid cols occupied by lheader. body colIndex = cell.layout.col - lheaderDepth */
+    lheaderDepth: number;
+    /** For column(headerName) resolution */
+    structureStore: IStructureStore;
+    /** For reading theader leaf cell rawValue */
+    cellRegistry: ICellRegistry;
+}
+/**
+ * Check whether a rule's target matches the given cell.
+ */
+export declare function matchesCell(rule: Rule, cell: ICell, ctx: MatchContext): boolean;
+/**
+ * Resolve a theader leaf cell's rawValue to a 0-based body column index.
+ * Returns undefined if no leaf cell with that name is found.
+ */
+export declare function resolveHeaderNameToColIndex(headerName: string, ctx: MatchContext): number | undefined;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/rule-registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * RuleRegistry — stores rules and answers "which rules apply to this cell?"
+ *
+ * Manages CRUD, AST compilation, valueDeps extraction, and the depIndex
+ * for reactive re-evaluation.
+ */
+import type { IRuleRegistry } from '../interfaces/rules';
+import type { ICell } from '../interfaces/core';
+import type { Rule, RuleInput, RulePayload, RuleUpdate } from './types/rule.types';
+import type { RuleScope } from '../types/rule-target.types';
+import { type MatchContext } from './rule-matcher';
+export declare class RuleRegistry implements IRuleRegistry {
+    private rules;
+    private depIndex;
+    addRule(input: RuleInput): string;
+    removeRule(ruleId: string): void;
+    updateRule(ruleId: string, update: RuleUpdate): boolean;
+    getRule(ruleId: string): Rule | undefined;
+    getAll(): Rule[];
+    enableRule(ruleId: string): void;
+    disableRule(ruleId: string): void;
+    getRulesForCell(cell: ICell, ctx: MatchContext): Rule[];
+    getRulesByScope(scope: RuleScope): Rule[];
+    searchByLabel(query: string): Rule[];
+    getRulesByValueDep(depKey: string): Rule[];
+    export(): RulePayload[];
+    import(payloads: RulePayload[]): void;
+    private buildRule;
+    private addToDep;
+    private removeFromDep;
+}
+export declare const ruleRegistry: RuleRegistry;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/types/evaluation.types.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Types for rule evaluation — context, outputs, and resolved results.
+ */
+import type { ICell } from '../../interfaces/core/cell.interface';
+import type { IStructureStore } from '../../interfaces/stores/structure-store.interface';
+import type { ICellRegistry } from '../../interfaces/stores/cell-registry.interface';
+import type { CellStyle } from '../../types';
+import { ITable } from '../../interfaces';
+/**
+ * EvalContext — the runtime environment for expression evaluation.
+ * Passed to the evaluator so expressions can resolve Vars, FnCalls, and RangeRefs.
+ */
+export interface EvalContext {
+    /** The cell currently being evaluated (if applicable) */
+    cell?: ICell;
+    /** The table instance (for accessing stores, counts, etc.) */
+    table: ITable;
+    /** Direct access to cell store for lookups */
+    cellRegistry: ICellRegistry;
+    /** Direct access to structure store for topology queries */
+    structureStore: IStructureStore;
+    /** Current row index (for relative "self" resolution in row-scoped rules) */
+    rowIndex?: number;
+    /** Current column index (for relative "self" resolution in column-scoped rules) */
+    colIndex?: number;
+    /** Current selection rect (for "self" resolution in selection-scoped rules) */
+    selectionRect?: {
+        rowStart: number;
+        colStart: number;
+        rowEnd: number;
+        colEnd: number;
+    };
+}
+/**
+ * RuleOutput — what a rule's result expression evaluates to.
+ * Union of all possible side-effects a rule can produce.
+ */
+export type RuleOutput = StylePatch | DeltaInstruction | ComputedValue | ValidationResult | RenderFlag | VisibilityFlag | LockFlag;
+/**
+ * StylePatch — partial style override (never stored on cell, merged at display time).
+ * Uses Partial<CellStyle> for pdfme compatibility.
+ */
+export interface StylePatch {
+    type: 'style';
+    style: Partial<CellStyle>;
+}
+/**
+ * DeltaInstruction — request to LayoutEngine to adjust geometry.
+ * Only ever increases dimensions; never decreases without explicit user action.
+ */
+export type DeltaInstruction = {
+    type: 'row-height-min';
+    rowIndex: number;
+    minHeight: number;
+} | {
+    type: 'col-width-min';
+    colIndex: number;
+    minWidth: number;
+};
+/**
+ * ComputedValue — rule computes a new value for the cell.
+ * Replaces cell.computedValue in the EvaluationResult.
+ */
+export interface ComputedValue {
+    type: 'computedValue';
+    value: string | number;
+}
+/**
+ * ValidationResult — rule performs validation and produces error/warning.
+ * Stored in EvaluationResult for renderer to display.
+ */
+export interface ValidationResult {
+    type: 'validation';
+    valid: boolean;
+    message?: string;
+    severity?: 'error' | 'warning' | 'info';
+}
+/**
+ * RenderFlag — flags for renderer (e.g., clip overflowing text).
+ * Stored in EvaluationResult for renderer to interpret.
+ */
+export interface RenderFlag {
+    type: 'renderFlag';
+    clip?: boolean;
+    wrap?: boolean;
+}
+/**
+ * VisibilityFlag — hide or show the cell.
+ */
+export interface VisibilityFlag {
+    type: 'visibility';
+    hidden: boolean;
+}
+/**
+ * LockFlag — lock/unlock the cell for editing.
+ */
+export interface LockFlag {
+    type: 'lock';
+    locked: boolean;
+}
+/**
+ * EvaluationResult — the complete result of evaluating all rules for one cell.
+ * Collected per cell after all matching rules have fired.
+ */
+export interface EvaluationResult {
+    /** Cell ID being evaluated */
+    cellId: string;
+    /** Merged style patches from all rules (lower priority rules applied first) */
+    stylePatches: StylePatch[];
+    /** Geometry delta instructions from overflow/layout rules */
+    deltaInstructions: DeltaInstruction[];
+    /** Computed value (if any rule produced one) */
+    computedValue?: string | number;
+    /** Validation result (if any rule validated) */
+    validationResult?: ValidationResult;
+    /** Render flags (clip, wrap, etc.) */
+    renderFlags: RenderFlag[];
+    /** Visibility state */
+    hidden?: boolean;
+    /** Lock state */
+    locked?: boolean;
+    /** List of rule IDs that evaluated for this cell (for debugging) */
+    firedRuleIds: string[];
+}
+/**
+ * ResolvedCell — the final renderer-agnostic snapshot of a cell.
+ * Output of the entire evaluation pipeline; both canvas and PDF renderers consume this.
+ * No rule logic in renderers — they just draw what's in ResolvedCell.
+ */
+export interface ResolvedCell {
+    /** Cell ID */
+    cellId: string;
+    /** Display value (rawValue or computedValue from rules) */
+    displayValue: string | number;
+    /** Layout geometry */
+    layout: {
+        row: number;
+        col: number;
+        rowSpan: number;
+        colSpan: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Resolved style (base cell style + merged patches from rules) */
+    resolvedStyle: CellStyle;
+    /** Overflow handling mode */
+    overflowMode?: 'clip' | 'wrap' | 'increase-height' | 'increase-width';
+    /** Render flags */
+    renderFlags: {
+        clip?: boolean;
+        wrap?: boolean;
+    };
+    /** Visibility */
+    hidden?: boolean;
+    /** Edit lock */
+    locked?: boolean;
+    /** Validation state */
+    validation?: {
+        valid: boolean;
+        message?: string;
+        severity?: 'error' | 'warning' | 'info';
+    };
+}
+/**
+ * RuleEvaluationStats — for debugging and performance monitoring.
+ * Tracks which rules fired and how long evaluation took.
+ */
+export interface RuleEvaluationStats {
+    cellId: string;
+    firedRuleIds: string[];
+    evaluationTimeMs: number;
+    evaluationErrors: Array<{
+        ruleId: string;
+        error: Error;
+    }>;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Barrel export for all rule type definitions.
+ */
+export type { Rule, RulePayload, RuleInput, RuleUpdate } from './rule.types';
+export type { EvalContext, RuleOutput, StylePatch, DeltaInstruction, ComputedValue, ValidationResult, RenderFlag, VisibilityFlag, LockFlag, EvaluationResult, ResolvedCell, RuleEvaluationStats, } from './evaluation.types';

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/types/rule.types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Rule — the unified shape for all rules (prebuilt and user-created).
+ * Canvas stores condition and result as strings; engine compiles them to AST on first use.
+ */
+import type { RuleTarget } from '../../types/rule-target.types';
+import type { ExprNode } from '../expression/ast.types';
+/**
+ * A single rule that applies conditions to cells and produces results.
+ *
+ * Rules are stored with expression strings (so canvas can edit them).
+ * The engine compiles strings to AST once and caches the AST.
+ * AST cache fields are never serialized to storage.
+ */
+export interface Rule {
+    /** Unique identifier for this rule (assigned by RuleRegistry) */
+    ruleId: string;
+    /** Which cells this rule applies to (scope + selector) */
+    target: RuleTarget;
+    /** Condition expression as string (e.g., "cell.value > 100", "always")
+     *  Canvas stores and edits this directly.
+     *  Evaluates to boolean at runtime.
+     */
+    condition: string;
+    /** Result expression as string (e.g., "{ style: { backgroundColor: 'red' } }")
+     *  Canvas stores and edits this directly.
+     *  Evaluates to RuleOutput shape at runtime.
+     */
+    result: string;
+    /**
+     * Compiled AST cache for condition expression.
+     * NOT serialized to storage — regenerated on first evaluation.
+     * @internal
+     */
+    _conditionAst?: ExprNode;
+    /**
+     * Compiled AST cache for result expression.
+     * NOT serialized to storage — regenerated on first evaluation.
+     * @internal
+     */
+    _resultAst?: ExprNode;
+    /** Priority determines evaluation order when multiple rules target the same cell.
+     *  Lower number = higher priority (evaluates first).
+     *  Default: 0 (lowest priority, can be overridden).
+     *  Prebuilt rules typically use 0; user rules can use higher values.
+     */
+    priority: number;
+    /** Whether this rule is active. Disabled rules are indexed but not evaluated. */
+    enabled: boolean;
+    /** Optional human-readable label for canvas UI */
+    label?: string;
+    /**
+     * Dependency keys auto-extracted from result AST.
+     * Used by value-dependency-index for reactive re-firing.
+     *
+     * Examples:
+     *   - "cell.value"    → this rule reads cell.value
+     *   - "col:2"         → this rule reads column 2 (any cell in it)
+     *   - "row:3"         → this rule reads row 3 (any cell in it)
+     *   - "table.rowCount"→ this rule reads table.rowCount
+     *
+     * When any of these keys' values change, this rule is re-evaluated.
+     */
+    valueDeps: string[];
+}
+/**
+ * Serializable rule payload (for storage/API).
+ * Excludes AST cache fields (_conditionAst, _resultAst).
+ */
+export type RulePayload = Omit<Rule, '_conditionAst' | '_resultAst'>;
+/**
+ * Rule creation input (canvas or programmatic).
+ * ruleId and valueDeps are assigned by the registry.
+ */
+export type RuleInput = Omit<Rule, 'ruleId' | 'valueDeps' | '_conditionAst' | '_resultAst'>;
+/**
+ * Partial rule update (e.g., enable/disable, change priority, edit condition).
+ */
+export type RuleUpdate = Partial<RuleInput>;

package/dist/types/_vendors/schemas/dynamicTable/engine/stores/cell-registry.store.d.ts

@@ -0,0 +1,20 @@
+import { ICell, ICellRegistry } from "../interfaces";
+import { CellPayload, CellStyle, OverflowMode, Region } from "../types";
+/** @deprecated Import from '../styles' instead */
+export { defaultCellStyle } from "../styles/defaults";
+/** @deprecated Use defaultCellStyle from '../styles' instead */
+export { defaultCellStyle as defaultStyle } from "../styles/defaults";
+export declare class CellRegistry implements ICellRegistry {
+    private cellsById;
+    private cellsByAddress;
+    private cellIdToAddress;
+    constructor();
+    setCellAddress(cellId: string, address: string): void;
+    clearCellAddress(cellId: string): void;
+    createCell(region: Region, rawValue?: string, style?: Partial<CellStyle>, isDynamic?: boolean): string;
+    createCellWithId(cellId: string, region: Region, rawValue?: string, style?: Partial<CellStyle>, isDynamic?: boolean, computedValue?: string | number, overflow?: OverflowMode): string;
+    deleteCell(cellId: string): void;
+    getCellByAddress(address: string): ICell | undefined;
+    getCellById(cellId: string): ICell | undefined;
+    updateCell(cellId: string, payload: CellPayload): void;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/stores/merge-registry.stores.d.ts

@@ -0,0 +1,51 @@
+import { IMergeRegistry, IStructureStore } from "../interfaces";
+import { Rect } from "../types/common";
+export declare class MergeRegistry implements IMergeRegistry {
+    private mergeRegistry;
+    private structureStore;
+    constructor(structureStore: IStructureStore);
+    /**
+     * Create a merge for the given rectangle
+     * Validates the merge before adding it
+     */
+    createMerge(rect: Rect): void;
+    /**
+     * Delete a merge by its root cell ID
+     * The root cell ID is the primary key in the merge registry
+     */
+    deleteMerge(cellId: string): void;
+    /**
+     * Get merge by root cell ID
+     * Returns the merge rectangle if it exists
+     */
+    getMergeByRootId(cellId: string): Rect | undefined;
+    /**
+     * Find a merge that contains a specific cell by its ID
+     * Returns the merge rectangle and the root cell ID if found
+     * Useful when you have a cell ID and need to find its merge
+     */
+    findMergeByContainedCell(cellId: string): {
+        rootCellId: string;
+        merge: Rect;
+    } | undefined;
+    /**
+     * Check if a cell is part of any merge
+     * Returns true if the cell ID is a merge root
+     */
+    isMergeRoot(cellId: string): boolean;
+    /**
+     * Get all cells that are merge roots
+     * These are the cellIds that have merges associated with them
+     */
+    getMergeRoots(): string[];
+    /**
+     * Validate if a merge rectangle is valid for the table structure
+     *
+     * For body/undefined regions: validates against full table bounds
+     * For header regions (theader, lheader, rheader, footer): skips strict validation
+     * since header bounds are region-local and validated at layout time
+     */
+    isValidMerge(rect: Rect): boolean;
+    private isChild;
+    getMergeSet(): Map<string, Rect>;
+}