import { Nullable } from '../../../../../types/general';
import { VegaTablePinnedType } from '../../../interface';
import { ColumnStructureModel } from './column-structure-model';
declare type IteratorMode = 'dfs' | 'bfs';
/**
 * ColumnRenderInputModel
 *
 * Render-time representation of a column or group node used by header/body renderers.
 * Built from a ColumnStructureModel tree, it carries computed layout metadata required
 * for rendering and pinned/sticky calculations (colSpan, rowSpan, pinned boundaries, etc).
 *
 * Instances form a forest (root-level nodes in an array) that mirrors the structure model
 * but contains additional render-specific properties and parent/child links for renderers.
 */
export declare class ColumnRenderInputModel {
  readonly key: string;
  readonly label: string;
  readonly pinned: VegaTablePinnedType;
  readonly colSpan: Nullable<number>;
  readonly rowSpan: Nullable<number>;
  readonly isViewStart: boolean;
  readonly isViewEnd: boolean;
  readonly isLeftEndPinned: boolean;
  readonly isRightStartPinned: boolean;
  readonly isNoPinnedEnd: boolean;
  readonly headHasGroupColumn: boolean;
  readonly headHasPinnedColumn: boolean;
  readonly headMaxDepth: number;
  readonly level: number;
  readonly columnIndex: number;
  readonly parent: Nullable<ColumnRenderInputModel>;
  readonly children: ColumnRenderInputModel[];
  private iteratorCacheMap;
  private leaves;
  /**
   * Create a new render input node.
   *
   * @param {string} key - Unique key (matches ColumnStructureModel.key).
   * @param {string} label - Optional display label (from structure model).
   * @param {VegaTablePinnedType} pinned - Pinned type for this node ('left' | 'right' | null).
   * @param {Nullable<number>} colSpan - Number of visual columns spanned by this node's subtree.
   * @param {Nullable<number>} rowSpan - Number of header rows this node should span.
   * @param {boolean} isViewStart - True when this node is the start of a visible view range.
   * @param {boolean} isViewEnd - True when this node is the end of a visible view range.
   * @param {boolean} isLeftEndPinned - True when node is last left-pinned sibling.
   * @param {boolean} isRightStartPinned - True when node is first right-pinned sibling.
   * @param {boolean} isNoPinnedEnd - True when node is last non-pinned sibling.
   * @param {boolean} headHasGroupColumn - Header contains group columns (affects rowSpan).
   * @param {boolean} headHasPinnedColumn - Header contains pinned columns.
   * @param {number} headMaxDepth - Maximum header depth (number of header rows).
   * @param {number} level - Level/index of this node within header rows (0-based).
   * @param {number} columnIndex - Sequential leaf index (used for ordering).
   * @param {Nullable<ColumnRenderInputModel>} parent - Parent render input node (null for root-level).
   * @param {ColumnRenderInputModel[]} children - Child render input nodes.
   */
  constructor(key: string, label: string, pinned: VegaTablePinnedType, colSpan: Nullable<number>, rowSpan: Nullable<number>, isViewStart: boolean, isViewEnd: boolean, isLeftEndPinned: boolean, isRightStartPinned: boolean, isNoPinnedEnd: boolean, headHasGroupColumn: boolean, headHasPinnedColumn: boolean, headMaxDepth: number, level: number, columnIndex: number, parent: Nullable<ColumnRenderInputModel>, children?: ColumnRenderInputModel[]);
  /**
   * Build a forest of ColumnRenderInputModel nodes from a ColumnStructureModel root.
   *
   * @param {ColumnStructureModel} rootModel - Root ColumnStructureModel that supplies tree and level data.
   * @returns {ColumnRenderInputModel[]} Array of root-level ColumnRenderInputModel nodes (the render forest).
   */
  static from(rootModel: ColumnStructureModel): ColumnRenderInputModel[];
  /**
   * True when the provided structure model is the last left-pinned sibling in its parent's children.
   * Used to mark boundary nodes for left-pinned groups.
   *
   * @param {ColumnStructureModel} model - Structure model to check.
   * @returns {boolean} True when model is the last left-pinned sibling.
   */
  private static isLeftEndPinned;
  /**
   * True when the provided structure model is the first right-pinned sibling in its parent's children.
   * Used to mark boundary nodes for right-pinned groups.
   *
   * @param {ColumnStructureModel} model - Structure model to check.
   * @returns {boolean} True when model is the first right-pinned sibling.
   */
  private static isRightStartPinned;
  /**
   * True when the provided structure model is the last non-pinned sibling in its parent's children.
   * Useful to handle the 'no-pinned-end' condition.
   *
   * @param {ColumnStructureModel} model - Structure model to check.
   * @returns {boolean} True when model is the last non-pinned sibling.
   */
  private static isNoPinnedEnd;
  /**
   * True when the provided model is the first child of its parent.
   *
   * @param {ColumnStructureModel} model - Structure model to check.
   * @returns {boolean} True when model is the first child.
   */
  private static isParentStart;
  /**
   * True when the provided model is the last child of its parent.
   *
   * @param {ColumnStructureModel} model - Structure model to check.
   * @returns {boolean} True when model is the last child.
   */
  private static isParentEnd;
  /**
   * Compute a node's colSpan by iterating its subtree and counting the maximum number
   * of nodes present at any single level (visual column span).
   *
   * @param {ColumnStructureModel} mode - ColumnStructureModel node to examine.
   * @returns {number} Number of visual columns spanned by the node.
   */
  private static getColSpan;
  /**
   * Return cached leaf render nodes for this subtree.
   * Caches the result on first call and returns cached array on subsequent calls.
   *
   * @returns {ColumnRenderInputModel[]} Array of leaf render input nodes.
   */
  getLeaves(): ColumnRenderInputModel[];
  /**
   * Generic iterator that supports traversal modes ('dfs' currently implemented).
   *
   * @param {IteratorMode} [mode='dfs'] - Iterator mode ('dfs' | 'bfs').
   * @returns {ColumnRenderInputModel[]} Traversal-ordered array of nodes.
   */
  iterator(mode?: IteratorMode): ColumnRenderInputModel[];
  /**
   * Depth-first pre-order traversal of this node and its descendants.
   * Caches the result for the 'dfs' mode to avoid repeated recursion.
   *
   * @returns {ColumnRenderInputModel[]} Array of nodes in DFS order (includes this node).
   */
  private dfsIterator;
  /**
   * True when this render node has no children (visual leaf).
   *
   * @returns {boolean} True when node is a leaf.
   */
  private isLeaf;
}
export {};
