//#region src/js/ts-types/base.d.ts
type MaybeUndef<T> = T | undefined;
type PromiseOrUndef<T> = undefined | Promise<T | undefined>;
type PromiseMaybeUndef<T> = Promise<T | undefined>;
type MaybePromise<T> = T | Promise<T>;
type MaybeCall<T, A extends any[]> = T | ((...args: A) => T);
type MaybePromiseOrCall<T, A extends any[]> = T | Promise<T> | ((...args: A) => T);
type MaybePromiseOrUndef<T> = T | undefined | Promise<T | undefined>;
type MaybeCallOrUndef<T, A extends any[]> = undefined | T | ((...args: A) => T);
type MaybePromiseOrCallOrUndef<T, A extends any[]> = T | undefined | Promise<T | undefined> | ((...args: A) => T);
type PromiseMaybeUndefOrCall<T, A extends any[]> = Promise<T | undefined> | ((...args: A) => T);
type PromiseMaybeCallOrUndef<T, A extends any[]> = Promise<MaybeCallOrUndef<T, A>>;
type AnyFunction = (...args: any[]) => any;
interface RectProps {
  left: number;
  right: number;
  top: number;
  bottom: number;
  width: number;
  height: number;
}
type ColorDef = CanvasRenderingContext2D["fillStyle"];
//#endregion
//#region src/js/ts-types/grid.d.ts
interface CellAddress {
  col: number;
  row: number;
}
interface CellRange {
  start: CellAddress;
  end: CellAddress;
}
type FieldGetter<T> = (record: T) => any;
type FieldSetter<T> = (record: T, value: any) => boolean;
interface FieldAssessor<T> {
  get: FieldGetter<T>;
  set: FieldSetter<T>;
}
type FieldDef<T> = keyof T | FieldGetter<T> | FieldAssessor<T>;
type FieldData = MaybePromiseOrUndef<any>;
//#endregion
//#region src/js/core/EventTarget.d.ts
/** @private */
declare const _$2: unique symbol;
/**
 * event target.
 */
declare class EventTarget$1 {
  private [_$2];
  /**
   * Adds an event listener.
   * @param  {string} type The event type id.
   * @param  {function} listener Callback method.
   * @return {number} unique id for the listener.
   */
  listen(type: string, listener: AnyListener): EventListenerId;
  /**
   * Removes an event listener which was added with listen() by the id returned by listen().
   * @param  {number} id the id returned by listen().
   * @return {void}
   */
  unlisten(id: EventListenerId | `${EventListenerId}`): void;
  addEventListener(type: string, listener: AnyListener): void;
  removeEventListener(type: string, listener: AnyListener): void;
  hasListeners(type: string): boolean;
  /**
   * Fires all registered listeners
   * @param  {string}    type The type of the listeners to fire.
   * @param  {...*} args fire arguments
   * @return {*} the result of the last listener
   */
  fireListeners(type: string, ...args: any[]): any;
  dispose(): void;
}
//#endregion
//#region src/js/data/internal/types.d.ts
type PromiseCacheValue<V> = MaybePromiseOrUndef<V>;
//#endregion
//#region src/js/data/DataSource.d.ts
/** @private */
declare const EVENT_TYPE$1: {
  readonly UPDATE_LENGTH: "update_length";
  readonly UPDATED_LENGTH: "updated_length";
  readonly UPDATED_ORDER: "updated_order";
};
interface DataSourceParam<T> {
  get: (index: number) => T;
  length: number;
  source?: any;
}
/**
 * grid data source
 *
 * @classdesc cheetahGrid.data.DataSource
 * @memberof cheetahGrid.data
 */
declare class DataSource<T> extends EventTarget$1 implements DataSourceAPI<T> {
  private _get;
  private _length;
  private readonly _source;
  protected _sortedIndexMap: null | number[];
  static get EVENT_TYPE(): typeof EVENT_TYPE$1;
  static ofArray<T>(array: T[]): DataSource<T>;
  constructor(obj?: DataSourceParam<T> | DataSource<T>);
  get source(): any;
  get(index: number): MaybePromiseOrUndef<T>;
  getField<F extends FieldDef<T>>(index: number, field: F): FieldData;
  hasField(index: number, field: FieldDef<T>): boolean;
  setField<F extends FieldDef<T>>(index: number, field: F, value: any): MaybePromise<boolean>;
  sort(field: FieldDef<T>, order: "desc" | "asc"): MaybePromise<void>;
  get length(): number;
  set length(length: number);
  get dataSource(): DataSource<T>;
  dispose(): void;
  protected getOriginal(index: number): MaybePromiseOrUndef<T>;
  protected getOriginalField<F extends FieldDef<T>>(index: number, field: F): FieldData;
  protected hasOriginalField(index: number, field: FieldDef<T>): boolean;
  protected setOriginalField<F extends FieldDef<T>>(index: number, field: F, value: any): MaybePromise<boolean>;
  protected fieldPromiseCallBackInternal<F extends FieldDef<T>>(_index: number, _field: F, _value: PromiseCacheValue<any>): void;
  protected recordPromiseCallBackInternal(_index: number, _record: PromiseCacheValue<T>): void;
  static EMPTY: DataSource<any>;
}
//#endregion
//#region src/js/data/CachedDataSource.d.ts
/**
 * grid data source for caching Promise data
 *
 * @classdesc cheetahGrid.data.CachedDataSource
 * @memberof cheetahGrid.data
 */
declare class CachedDataSource<T> extends DataSource<T> {
  private _rCache;
  private _fCache;
  static get EVENT_TYPE(): typeof DataSource.EVENT_TYPE;
  static ofArray<T>(array: T[]): CachedDataSource<T>;
  constructor(opt?: DataSourceParam<T>);
  protected getOriginal(index: number): MaybePromiseOrUndef<T>;
  protected getOriginalField<F extends FieldDef<T>>(index: number, field: F): FieldData;
  protected setOriginalField<F extends FieldDef<T>>(index: number, field: F, value: any): MaybePromise<boolean>;
  clearCache(): void;
  protected fieldPromiseCallBackInternal<F extends FieldDef<T>>(index: number, field: F, value: PromiseCacheValue<any>): void;
  protected recordPromiseCallBackInternal(index: number, record: PromiseCacheValue<T>): void;
  dispose(): void;
}
//#endregion
//#region src/js/data/FilterDataSource.d.ts
/** @private */
type Filter<T> = (record: T | undefined) => boolean;
/**
 * grid data source for filter
 *
 * @classdesc cheetahGrid.data.FilterDataSource
 * @memberof cheetahGrid.data
 */
declare class FilterDataSource<T> extends DataSource<T> {
  private _dataSource;
  private _handler;
  private _filterData;
  static get EVENT_TYPE(): typeof DataSource.EVENT_TYPE;
  constructor(dataSource: DataSource<T>, filter: Filter<T>);
  get filter(): Filter<T> | null;
  set filter(filter: Filter<T> | null);
  protected getOriginal(index: number): MaybePromiseOrUndef<T>;
  sort(field: FieldDef<T>, order: "desc" | "asc"): MaybePromise<void>;
  get source(): any;
  get dataSource(): DataSource<T>;
  dispose(): void;
}
declare namespace data_d_exports {
  export { CachedDataSource, DataSource, DataSourceParam, FilterDataSource };
}
//#endregion
//#region src/js/core/DG_EVENT_TYPE.d.ts
interface DrawGridEvents {
  /**
   * Indicates when the cell was clicked.
   */
  CLICK_CELL: "click_cell";
  /**
   * Indicates when the cell was double-clicked.
   */
  DBLCLICK_CELL: "dblclick_cell";
  /**
   * Indicates when the cell was double-taped.
   */
  DBLTAP_CELL: "dbltap_cell";
  /**
   * Indicates when pointing device button is pressed in a cell.
   */
  MOUSEDOWN_CELL: "mousedown_cell";
  /**
   * Indicates when pointing device button is released in a cell.
   */
  MOUSEUP_CELL: "mouseup_cell";
  /**
   * Indicates the cell selection state has changed.
   */
  SELECTED_CELL: "selected_cell";
  /**
   * Indicates key-downed.
   */
  KEYDOWN: "keydown";
  MOUSEMOVE_CELL: "mousemove_cell";
  MOUSEENTER_CELL: "mouseenter_cell";
  MOUSELEAVE_CELL: "mouseleave_cell";
  MOUSEOVER_CELL: "mouseover_cell";
  MOUSEOUT_CELL: "mouseout_cell";
  TOUCHSTART_CELL: "touchstart_cell";
  /**
   * Indicates when the user attempts to open a context menu in the cell.
   */
  CONTEXTMENU_CELL: "contextmenu_cell";
  INPUT_CELL: "input_cell";
  PASTE_CELL: "paste_cell";
  DELETE_CELL: "delete_cell";
  EDITABLEINPUT_CELL: "editableinput_cell";
  MODIFY_STATUS_EDITABLEINPUT_CELL: "modify_status_editableinput_cell";
  /**
   * Indicates when the column width has changed.
   */
  RESIZE_COLUMN: "resize_column";
  /**
   * Indicates when scrolled.
   */
  SCROLL: "scroll";
  FOCUS_GRID: "focus_grid";
  BLUR_GRID: "blur_grid";
}
/**
 * DrawGrid event types
 * @classdesc cheetahGrid.core.EVENT_TYPE
 * @memberof cheetahGrid.core
 */
declare const DG_EVENT_TYPE: DrawGridEvents;
//#endregion
//#region src/js/internal/EventHandler.d.ts
/** @private */
type EventHandlerTarget = EventTarget | EventTarget$1;
/** @private */
type Listener = AnyFunction;
declare class EventHandler {
  private _listeners;
  on<TYPE extends keyof GlobalEventHandlersEventMap>(target: EventHandlerTarget, type: TYPE, listener: (event: GlobalEventHandlersEventMap[TYPE]) => any, ...options: any[]): EventListenerId;
  on(target: EventHandlerTarget, type: string, listener: Listener, ...options: any[]): EventListenerId;
  once<TYPE extends keyof GlobalEventHandlersEventMap>(target: EventHandlerTarget, type: TYPE, listener: (event: GlobalEventHandlersEventMap[TYPE]) => any, ...options: any[]): EventListenerId;
  once(target: EventHandlerTarget, type: string, listener: Listener, ...options: (boolean | AddEventListenerOptions)[]): EventListenerId;
  tryWithOffEvents(target: EventHandlerTarget, type: string, call: () => void): void;
  off(id: EventListenerId | null | undefined): void;
  fire(target: EventTarget, type: string, ...args: any[]): void;
  hasListener(target: EventTarget, type: string): boolean;
  clear(): void;
  dispose(): void;
}
//#endregion
//#region src/js/internal/NumberMap.d.ts
declare class NumberMap<T> {
  private _keys;
  private _vals;
  private _sorted;
  put(key: number, value: T): void;
  remove(key: number): void;
  get(key: number): T | undefined;
  has(key: number): boolean;
  each(keyFrom: number, keyTo: number, fn: (t: T, k: number) => void): void;
}
//#endregion
//#region src/js/internal/Rect.d.ts
declare class Rect implements RectProps {
  private _left;
  private _top;
  private _width;
  private _height;
  private _right;
  private _bottom;
  constructor(left: number, top: number, width: number, height: number);
  static bounds(left: number, top: number, right: number, bottom: number): Rect;
  static max(rect1: Rect, rect2: Rect): Rect;
  get left(): number;
  set left(left: number);
  get top(): number;
  set top(top: number);
  get width(): number;
  set width(width: number);
  get height(): number;
  set height(height: number);
  get right(): number;
  set right(right: number);
  get bottom(): number;
  set bottom(bottom: number);
  offsetLeft(offset: number): void;
  offsetTop(offset: number): void;
  copy(): Rect;
  intersection(rect: Rect): Rect | null;
  contains(another: Rect): boolean;
  inPoint(x: number, y: number): boolean;
}
//#endregion
//#region src/js/internal/Scrollable.d.ts
declare class Scrollable {
  private _handler;
  private _scrollable;
  private _height;
  private _width;
  private _endPointElement;
  private _p;
  constructor();
  calcTop(top: number): number;
  getElement(): HTMLDivElement;
  setScrollSize(width: number, height: number): void;
  get scrollWidth(): number;
  set scrollWidth(width: number);
  get scrollHeight(): number;
  set scrollHeight(height: number);
  get scrollLeft(): number;
  set scrollLeft(scrollLeft: number);
  get scrollTop(): number;
  set scrollTop(scrollTop: number);
  onScroll(fn: (evt: Event) => void): void;
  dispose(): void;
  private _update;
}
//#endregion
//#region src/js/internal/symbolManager.d.ts
declare const PROTECTED_SYMBOL: unique symbol;
declare const CHECK_COLUMN_STATE_ID: unique symbol;
declare const RADIO_COLUMN_STATE_ID: unique symbol;
declare const BUTTON_COLUMN_STATE_ID: unique symbol;
declare const COLUMN_FADEIN_STATE_ID: unique symbol;
declare const BRANCH_GRAPH_COLUMN_STATE_ID: unique symbol;
declare const TREE_COLUMN_STATE_ID: unique symbol;
declare const SMALL_DIALOG_INPUT_EDITOR_STATE_ID: unique symbol;
declare const INLINE_INPUT_EDITOR_STATE_ID: unique symbol;
declare const INLINE_MENU_EDITOR_STATE_ID: unique symbol;
declare const CHECK_HEADER_STATE_ID: unique symbol;
//#endregion
//#region src/js/core/DrawGrid.d.ts
/**
 * managing mouse down moving
 * @private
 */
declare class BaseMouseDownMover {
  protected _grid: DrawGrid;
  private _handler;
  private _events;
  private _started;
  private _moved;
  private _mouseEndPoint?;
  constructor(grid: DrawGrid);
  moving(_e: MouseEvent | TouchEvent): boolean;
  lastMoving(e: MouseEvent | TouchEvent): boolean;
  protected _bindMoveAndUp(e: MouseEvent | TouchEvent): void;
  private _mouseMove;
  protected _moveInternal(_e: MouseEvent | TouchEvent): boolean;
  private _mouseUp;
  protected _upInternal(_e: MouseEvent | TouchEvent): void;
  dispose(): void;
}
/**
 * managing cell selection operation with mouse
 * @private
 */
declare class CellSelector extends BaseMouseDownMover {
  private _cell?;
  start(e: MouseEvent | TouchEvent): void;
  select(e: MouseEvent | TouchEvent): void;
  protected _moveInternal(e: MouseEvent | TouchEvent): boolean;
  private _getTargetCell;
}
/**
 * managing row width changing operation with mouse
 * @private
 */
declare class ColumnResizer extends BaseMouseDownMover {
  private _targetCol;
  private _x;
  private _preX;
  private _invalidateAbsoluteLeft;
  constructor(grid: DrawGrid);
  start(col: number, e: MouseEvent | TouchEvent): void;
  protected _moveInternal(e: MouseEvent | TouchEvent): boolean;
  protected _upInternal(_e: MouseEvent | TouchEvent): void;
}
/**
 * Manage focus
 * @private
 */
declare class FocusControl extends EventTarget$1 {
  private _grid;
  private _scrollable;
  private _handler;
  private _input;
  private _isComposition?;
  private _compositionEnd?;
  private _inputStatus?;
  private _keyDownMoveCallback?;
  constructor(grid: DrawGrid, parentElement: HTMLElement, scrollable: Scrollable, selection: Selection$1);
  fireKeyDownMove(keyCode: number, e: KeyboardEvent): void;
  onKeyDownMove(fn: KeyboardEventListener): void;
  onKeyDown(fn: (e: KeydownEvent) => void): EventListenerId;
  onInput(fn: (value: string) => void): EventListenerId;
  onDelete(fn: (e: KeyboardEvent) => void): EventListenerId;
  onCopy(fn: (e: ClipboardEvent) => void): EventListenerId;
  onPaste(fn: (e: {
    value: string;
    event: ClipboardEvent;
  }) => void): EventListenerId;
  onFocus(fn: (e: FocusEvent) => void): EventListenerId;
  onBlur(fn: (e: FocusEvent) => void): EventListenerId;
  focus(): void;
  setFocusRect(rect: Rect): void;
  get editMode(): boolean;
  set editMode(editMode: boolean);
  resetInputStatus(): void;
  storeInputStatus(): void;
  setDefaultInputStatus(): void;
  get input(): HTMLInputElement;
  dispose(): void;
}
/**
 * Selected area management
 */
declare class Selection$1 extends EventTarget$1 {
  private _grid;
  private _sel;
  private _focus;
  private _start;
  private _end;
  private _isWrapped?;
  constructor(grid: DrawGrid);
  get range(): CellRange;
  set range(range: CellRange);
  get focus(): CellAddress;
  get select(): CellAddress;
  set select(cell: CellAddress);
  private _setSelectCell;
  _setFocusCell(col: number, row: number, keepSelect: boolean, ignoreBeforeHook?: boolean): void;
  private _wrapFireSelectedEvent;
  _updateGridRange(): boolean;
  private _callBeforeHooks;
}
/** @private */
type DrawLayerFunction = (ctx: CanvasRenderingContext2D) => void;
/**
 * This class manages the drawing process for each layer
 */
/** @private */
declare class DrawLayers {
  private _layers;
  constructor();
  addDraw(level: number, fn: DrawLayerFunction): void;
  draw(ctx: CanvasRenderingContext2D): void;
}
/**
 * Context of cell drawing
 * @private
 */
declare class DrawCellContext implements CellContext {
  private _col;
  private _row;
  private _mode;
  private _ctx;
  private _rect;
  private _drawRect;
  private _drawing;
  private _selection;
  private _drawLayers;
  private _childContexts;
  private _cancel?;
  private _grid?;
  private _onTerminate?;
  private _rectFilter;
  /**
   * constructor
   * @param {number} col index of column
   * @param {number} row index of row
   * @param {CanvasRenderingContext2D} ctx context
   * @param {Rect} rect rect of cell area
   * @param {Rect} drawRect rect of drawing area
   * @param {boolean} drawing `true` if drawing is in progress
   * @param {object} selection the selection
   * @param {Array} drawLayers array of draw layers
   * @private
   */
  constructor(col: number, row: number, ctx: CanvasRenderingContext2D, rect: Rect | null, drawRect: Rect | null, drawing: boolean, selection: Selection$1, drawLayers: DrawLayers);
  get drawing(): boolean;
  get row(): number;
  get col(): number;
  cancel(): void;
  /**
   * select status.
   * @return {object} select status
   */
  getSelection(): {
    select: CellAddress;
    range: CellRange;
  };
  /**
   * Canvas context.
   * @return {CanvasRenderingContext2D} Canvas context.
   */
  getContext(): CanvasRenderingContext2D;
  /**
   * Rectangle of cell.
   * @return {Rect} rect Rectangle of cell.
   */
  getRect(): Rect;
  setRectFilter(rectFilter: (base: Rect) => Rect): void;
  /**
   * Rectangle of Drawing range.
   * @return {Rect} Rectangle of Drawing range.
   */
  getDrawRect(): Rect | null;
  private _isOutOfRange;
  /**
   * get Context of current state
   * @return {DrawCellContext} current DrawCellContext.
   */
  toCurrentContext(): DrawCellContext;
  addLayerDraw(level: number, fn: DrawLayerFunction): void;
  private _toRelativeDrawRect;
  _delayMode(grid: DrawGrid, onTerminate: () => void): void;
  /**
   * terminate
   * @return {void}
   */
  terminate(): void;
  private _getRectInternal;
}
/** @protected */
interface DrawGridProtected {
  element: HTMLElement;
  scrollable: Scrollable;
  handler: EventHandler;
  selection: Selection$1;
  focusControl: FocusControl;
  canvas: HTMLCanvasElement;
  context: CanvasRenderingContext2D;
  rowCount: number;
  colCount: number;
  frozenColCount: number;
  frozenRowCount: number;
  defaultRowHeight: number;
  defaultColWidth: string | number;
  font?: string;
  underlayBackgroundColor?: string;
  keyboardOptions?: DrawGridKeyboardOptions;
  disableColumnResize?: boolean;
  trimOnPaste: boolean;
  rowHeightsMap: NumberMap<number>;
  colWidthsMap: NumberMap<string | number>;
  colWidthsLimit: {
    [col: number]: {
      max?: string | number;
      min?: string | number;
    };
  };
  calcWidthContext: {
    full: number;
    em: number;
  };
  columnResizer: ColumnResizer;
  cellSelector: CellSelector;
  drawCells: {
    [row: number]: {
      [col: number]: DrawCellContext;
    };
  };
  cellTextOverflows: {
    [at: string]: string;
  };
  focusedGrid: boolean;
  config: {
    [name: string]: any;
  } | undefined;
  scroll: {
    left: number;
    top: number;
  };
  disposables?: {
    dispose(): void;
  }[] | null;
}
interface DrawGridConstructorOptions {
  rowCount?: number;
  colCount?: number;
  frozenColCount?: number;
  frozenRowCount?: number;
  /**
   * Default grid row height. default 40
   */
  defaultRowHeight?: number;
  /**
   * Default grid col width. default 80
   */
  defaultColWidth?: string | number;
  font?: string;
  underlayBackgroundColor?: string;
  keyboardOptions?: DrawGridKeyboardOptions;
  /**
   * Canvas parent element
   */
  parentElement?: HTMLElement | null;
  /**
   * Disable column resizing
   */
  disableColumnResize?: boolean;
  /**
   * If set to true, trim the pasted text on pasting.
   */
  trimOnPaste?: boolean;
}
/**
 * DrawGrid
 * @classdesc cheetahGrid.core.DrawGrid
 * @memberof cheetahGrid.core
 */
declare abstract class DrawGrid extends EventTarget$1 implements DrawGridAPI {
  protected [PROTECTED_SYMBOL]: DrawGridProtected;
  static get EVENT_TYPE(): typeof DG_EVENT_TYPE;
  constructor(options?: DrawGridConstructorOptions);
  /**
   * Get root element.
   * @returns {HTMLElement} root element
   */
  getElement(): HTMLElement;
  /**
   * Get canvas element.
   */
  get canvas(): HTMLCanvasElement;
  /**
   * Focus the grid.
   * @return {void}
   */
  focus(): void;
  hasFocusGrid(): boolean;
  /**
   * Get the selection instance.
   */
  get selection(): Selection$1;
  /**
   * Get the number of rows.
   */
  get rowCount(): number;
  /**
   * Set the number of rows.
   */
  set rowCount(rowCount: number);
  /**
   * Get the number of columns.
   */
  get colCount(): number;
  /**
   * Set the number of columns.
   */
  set colCount(colCount: number);
  /**
   * Get the number of frozen columns.
   */
  get frozenColCount(): number;
  /**
   * Set the number of frozen columns.
   */
  set frozenColCount(frozenColCount: number);
  /**
   * Get the number of frozen rows.
   */
  get frozenRowCount(): number;
  /**
   * Set the number of frozen rows.
   */
  set frozenRowCount(frozenRowCount: number);
  /**
   * Get the default row height.
   *
   */
  get defaultRowHeight(): number;
  /**
   * Set the default row height.
   */
  set defaultRowHeight(defaultRowHeight: number);
  /**
   * Get the default column width.
   */
  get defaultColWidth(): string | number;
  /**
   * Set the default column width.
   */
  set defaultColWidth(defaultColWidth: string | number);
  /**
   * Get the font definition as a string.
   */
  get font(): string | undefined;
  /**
   * Set the font definition with the given string.
   */
  set font(font: string | undefined);
  /**
   * Get the background color of the underlay.
   */
  get underlayBackgroundColor(): string | undefined;
  /**
   * Set the background color of the underlay.
   */
  set underlayBackgroundColor(underlayBackgroundColor: string | undefined);
  /**
   * If set to true, trim the pasted text on pasting.
   */
  get trimOnPaste(): boolean;
  set trimOnPaste(trimOnPaste: boolean);
  get keyboardOptions(): DrawGridKeyboardOptions | null;
  set keyboardOptions(keyboardOptions: DrawGridKeyboardOptions | null);
  configure(name: "fadeinWhenCallbackInPromise", value?: boolean): boolean;
  /**
   * Apply the changed size.
   * @return {void}
   */
  updateSize(): void;
  /**
   * Apply the changed scroll size.
   * @return {boolean} `true` if there was a change in the scroll size
   */
  updateScroll(): boolean;
  /**
   * Get the row height of the given the row index.
   * @param  {number} row The row index
   * @return {number} The row height
   */
  getRowHeight(row: number): number;
  /**
   * Set the row height of the given the row index.
   * @param  {number} row The row index
   * @param  {number} height The row height
   * @return {void}
   */
  setRowHeight(row: number, height: number | null): void;
  /**
   * Get the column width of the given the column index.
   * @param  {number} col The column index
   * @return {number} The column width
   */
  getColWidth(col: number): number;
  /**
   * Set the column width of the given the column index.
   * @param  {number} col The column index
   * @param  {number} width The column width
   * @return {void}
   */
  setColWidth(col: number, width: string | number | null): void;
  /**
   * Get the column max width of the given the column index.
   * @param  {number} col The column index
   * @return {number} The column max width
   */
  getMaxColWidth(col: number): string | number | undefined;
  /**
   * Set the column max width of the given the column index.
   * @param  {number} col The column index
   * @param  {number} maxwidth The column max width
   * @return {void}
   */
  setMaxColWidth(col: number, maxwidth: string | number | null): void;
  /**
   * Get the column min width of the given the column index.
   * @param  {number} col The column index
   * @return {number} The column min width
   */
  getMinColWidth(col: number): string | number | undefined;
  /**
   * Set the column min width of the given the column index.
   * @param  {number} col The column index
   * @param  {number} minwidth The column min width
   * @return {void}
   */
  setMinColWidth(col: number, minwidth: string | number | null): void;
  /**
   * Get the rect of the cell.
   * @param {number} col index of column, of the cell
   * @param {number} row index of row, of the cell
   * @returns {Rect} the rect of the cell.
   */
  getCellRect(col: number, row: number): Rect;
  /**
   * Get the relative rectangle of the cell.
   * @param {number} col index of column, of the cell
   * @param {number} row index of row, of the cell
   * @returns {Rect} the rect of the cell.
   */
  getCellRelativeRect(col: number, row: number): Rect;
  /**
   * Get the rectangle of the cells area.
   * @param {number} startCol index of the starting column, of the cell
   * @param {number} startRow index of the starting row, of the cell
   * @param {number} endCol index of the ending column, of the cell
   * @param {number} endRow index of the ending row, of the cell
   * @returns {Rect} the rect of the cells.
   */
  getCellsRect(startCol: number, startRow: number, endCol: number, endRow: number): Rect;
  getCellRangeRect(range: CellRange): Rect;
  isFrozenCell(col: number, row: number): {
    row: boolean;
    col: boolean;
  } | null;
  getRowAt(absoluteY: number): number;
  getColAt(absoluteX: number): number;
  getCellAt(absoluteX: number, absoluteY: number): CellAddress;
  /**
   * Scroll to where cell is visible.
   * @param  {number} col The column index.
   * @param  {number} row The row index
   * @return {void}
   */
  makeVisibleCell(col: number, row: number): void;
  /**
   * Moves the focus cursor to the given cell.
   * @param  {number} col The column index.
   * @param  {number} row The row index
   * @return {void}
   */
  setFocusCursor(col: number, row: number): void;
  /**
   * Focus the cell.
   * @param  {number} col The column index.
   * @param  {number} row The row index
   * @return {void}
   */
  focusCell(col: number, row: number): void;
  /**
   * Redraws the range of the given cell.
   * @param  {number} col The column index of cell.
   * @param  {number} row The row index of cell.
   * @return {void}
   */
  invalidateCell(col: number, row: number): void;
  /**
   * Redraws the range of the given cells.
   * @param {number} startCol index of the starting column, of the cell
   * @param {number} startRow index of the starting row, of the cell
   * @param {number} endCol index of the ending column, of the cell
   * @param {number} endRow index of the ending row, of the cell
   * @return {void}
   */
  invalidateGridRect(startCol: number, startRow: number, endCol?: number, endRow?: number): void;
  invalidateCellRange(range: CellRange): void;
  /**
   * Redraws the whole grid.
   * @return {void}
   */
  invalidate(): void;
  /**
   * Get the number of scrollable rows fully visible in the grid. visibleRowCount does not include the frozen rows counted by the frozenRowCount property. It does not include any partially visible rows on the bottom of the grid.
   * @returns {number}
   */
  get visibleRowCount(): number;
  /**
   * Get the number of scrollable columns fully visible in the grid. visibleColCount does not include the frozen columns counted by the frozenColCount property. It does not include any partially visible columns on the right of the grid.
   * @returns {number}
   */
  get visibleColCount(): number;
  /**
   * Get the index of the first row in the scrollable region that is visible.
   * @returns {number}
   */
  get topRow(): number;
  /**
   * Get the index of the first column in the scrollable region that is visible.
   * @returns {number}
   */
  get leftCol(): number;
  /**
   * gets or sets the number of pixels that an element's content is scrolled vertically
   */
  get scrollTop(): number;
  set scrollTop(scrollTop: number);
  /**
   * gets or sets the number of pixels that an element's content is scrolled from its left edge
   */
  get scrollLeft(): number;
  set scrollLeft(scrollLeft: number);
  /**
   * Get the value of cell with the copy action.
   * <p>
   * Please implement
   * </p>
   *
   * @protected
   * @param col Column index of cell.
   * @param row Row index of cell.
   * @param range Copy range.
   * @return {string} the value of cell
   */
  protected getCopyCellValue(_col: number, _row: number, _range: CellRange): unknown;
  /**
   * Draw a cell
   * <p>
   * Please implement cell drawing.
   * </p>
   *
   * @protected
   * @param  {number} col Column index of cell.
   * @param  {number} row Row index of cell.
   * @param  {DrawCellContext} context context of cell drawing.
   * @return {void}
   */
  protected abstract onDrawCell(col: number, row: number, context: CellContext): Promise<void> | void;
  /**
   * Get the overflowed text in the cell rectangle, from the given cell.
   * @param  {number} col The column index.
   * @param  {number} row The row index
   * @return {string | null} The text overflowing the cell rect.
   */
  getCellOverflowText(col: number, row: number): string | null;
  /**
   * Set the overflowed text in the cell rectangle, to the given cell.
   * @param  {number} col The column index.
   * @param  {number} row The row index
   * @param  {string} overflowText The overflowed text in the cell rectangle.
   * @return {void}
   */
  setCellOverflowText(col: number, row: number, overflowText: string | false): void;
  addDisposable(disposable: {
    dispose(): void;
  }): void;
  /**
   * Dispose the grid instance.
   * @returns {void}
   */
  dispose(): void;
  getAttachCellsArea(range: CellRange): {
    element: HTMLElement;
    rect: Rect;
  };
  onKeyDownMove(evt: KeyboardEvent): void;
  protected bindEventsInternal(): void;
  protected getTargetRowAtInternal(_absoluteY: number): {
    row: number;
    top: number;
  } | void;
  protected getRowsHeightInternal(_startRow: number, _endRow: number): number | void;
  protected getRowHeightInternal(_row: number): number | void;
  protected getScrollHeightInternal(_row?: number): number | void;
  protected getMoveLeftColByKeyDownInternal({
    col
  }: CellAddress): number;
  protected getMoveRightColByKeyDownInternal({
    col
  }: CellAddress): number;
  protected getMoveUpRowByKeyDownInternal({
    row
  }: CellAddress): number;
  protected getMoveDownRowByKeyDownInternal({
    row
  }: CellAddress): number;
  protected getOffsetInvalidateCells(): number;
  protected getCopyRangeInternal(range: CellRange): CellRange;
  protected _getInitContext(): CanvasRenderingContext2D;
  fireListeners<TYPE extends keyof DrawGridEventHandlersEventMap>(type: TYPE, ...event: DrawGridEventHandlersEventMap[TYPE]): DrawGridEventHandlersReturnMap[TYPE][];
}
//#endregion
//#region src/js/header/action/BaseAction.d.ts
declare class BaseAction$1<T> {
  protected _disabled: boolean;
  constructor(option?: BaseActionOption);
  get disabled(): boolean;
  set disabled(disabled: boolean);
  clone(): BaseAction$1<T>;
  bindGridEvent(_grid: ListGridAPI<T>, _cellId: LayoutObjectId): EventListenerId[];
  onChangeDisabledInternal(): void;
}
//#endregion
//#region src/js/ts-types-internal/grid-engine.d.ts
type ColumnFadeinState = {
  activeFadeins?: ((point: number) => void)[];
  cells: {
    [key: string]: {
      opacity: number;
    };
  };
};
type ButtonColumnState = {
  mouseActiveCell?: CellAddress;
};
type CheckColumnState = {
  elapsed: {
    [key: string]: number;
  };
  block: {
    [key: string]: boolean;
  };
  mouseActiveCell?: CellAddress;
};
type RadioColumnState = {
  elapsed: {
    [key: string]: number;
  };
  block: {
    [key: string]: boolean;
  };
  mouseActiveCell?: CellAddress;
};
interface BranchLine {
  readonly fromIndex?: number;
  toIndex?: number;
  readonly colorIndex: number;
  readonly point?: BranchPoint;
}
interface BranchPoint {
  readonly index: number;
  readonly commit: boolean;
  lines: BranchLine[];
  readonly tag?: string;
}
type BranchGraphColumnState<T> = Map<FieldDef<T>, {
  timeline: BranchPoint[][];
  branches: string[];
}>;
type InputEditorState = {
  element?: any;
};
type CheckHeaderState = {
  elapsed: {
    [key: string]: number;
  };
  block: {
    [key: string]: boolean;
  };
  mouseActiveCell?: CellAddress;
};
type TreeColumnState<T> = {
  drawnIcons?: unknown;
  cache?: Map<FieldDef<T>, unknown>;
};
interface GridInternal<T> extends ListGridAPI<T> {
  [COLUMN_FADEIN_STATE_ID]?: ColumnFadeinState;
  [BUTTON_COLUMN_STATE_ID]?: ButtonColumnState;
  [CHECK_COLUMN_STATE_ID]?: CheckColumnState;
  [RADIO_COLUMN_STATE_ID]?: RadioColumnState;
  [BRANCH_GRAPH_COLUMN_STATE_ID]?: BranchGraphColumnState<T>;
  [TREE_COLUMN_STATE_ID]?: TreeColumnState<T>;
  [INLINE_MENU_EDITOR_STATE_ID]?: InputEditorState;
  [INLINE_INPUT_EDITOR_STATE_ID]?: InputEditorState;
  [SMALL_DIALOG_INPUT_EDITOR_STATE_ID]?: InputEditorState;
  [CHECK_HEADER_STATE_ID]?: CheckHeaderState;
}
//#endregion
//#region src/js/ts-types-internal/data.d.ts
type SimpleColumnIconOption = {
  content?: string;
  font?: string;
  color?: ColorDef;
  className?: string;
  tagName?: string;
  isLiga?: boolean;
  width?: number;
  src?: MaybePromise<string>;
  svg?: string;
  name?: string;
  path?: string;
  offsetTop?: number;
  offsetLeft?: number;
};
//#endregion
//#region src/js/header/action/CheckHeaderAction.d.ts
declare class CheckHeaderAction<T> extends BaseAction$1<T> {
  clone(): CheckHeaderAction<T>;
  bindGridEvent(grid: GridInternal<T>, cellId: LayoutObjectId): EventListenerId[];
}
//#endregion
//#region src/js/header/action/SortHeaderAction.d.ts
declare class SortHeaderAction<T> extends BaseAction$1<T> {
  private _sort;
  constructor(option?: SortHeaderActionOption<T>);
  get sort(): SortOption<T>;
  set sort(sort: SortOption<T>);
  clone(): SortHeaderAction<T>;
  _executeSort(newState: SortState, grid: ListGridAPI<T>): void;
  bindGridEvent(grid: ListGridAPI<T>, cellId: LayoutObjectId): EventListenerId[];
}
declare namespace action_d_exports {
  export { ACTIONS$1 as ACTIONS, BaseAction$1 as BaseAction, BaseActionOption, CheckHeaderAction, SortHeaderAction, SortHeaderActionOption, of$6 as of, ofCell$1 as ofCell };
}
declare class ImmutableSortHeaderAction<T> extends SortHeaderAction<T> {
  get disabled(): boolean;
}
declare class ImmutableCheckHeaderAction<T> extends CheckHeaderAction<T> {
  get disabled(): boolean;
}
declare const ACTIONS$1: {
  SORT: ImmutableSortHeaderAction<any>;
  CHECK: ImmutableCheckHeaderAction<any>;
};
/**
 * column actions
 * @namespace cheetahGrid.columns.action
 * @memberof cheetahGrid.columns
 */

declare function of$6<T>(headerAction: HeaderActionOption | BaseAction$1<T> | null | undefined): BaseAction$1<T> | undefined;
declare function ofCell$1<T>(headerCell: BaseHeaderDefine<T>): BaseAction$1<T> | undefined;
//#endregion
//#region src/js/header/style/BaseStyle.d.ts
declare class BaseStyle$1 extends EventTarget$1 implements ColumnStyle {
  private _bgColor?;
  static get EVENT_TYPE(): {
    CHANGE_STYLE: string;
  };
  static get DEFAULT(): BaseStyle$1;
  constructor({
    bgColor
  }?: BaseStyleOption);
  get bgColor(): ColorDef | undefined;
  set bgColor(bgColor: ColorDef | undefined);
  doChangeStyle(): void;
  clone(): BaseStyle$1;
}
//#endregion
//#region src/js/internal/canvases.d.ts
type PaddingOption = {
  left?: number;
  right?: number;
  top?: number;
  bottom?: number;
};
declare namespace canvashelper_d_exports {
  export { Canvashelper, DrawButtonOption, DrawCheckboxOption, DrawInlineImageRectOption, DrawRadioButtonOption, FillTextRectOption, drawButton, drawCheckbox, drawInlineImageRect, drawRadioButton, fillCircle, fillRoundRect, fillTextRect, measureCheckbox, measureRadioButton, roundRect, strokeCircle, strokeColorsRect, strokeRoundRect };
}
declare function strokeColorsRect(ctx: CanvasRenderingContext2D, borderColors: [ColorDef | null, ColorDef | null, ColorDef | null, ColorDef | null], left: number, top: number, width: number, height: number): void;
declare function roundRect(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number, radius: number): void;
declare function fillRoundRect(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number, radius: number): void;
declare function strokeRoundRect(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number, radius: number): void;
declare function fillCircle(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number): void;
declare function strokeCircle(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number): void;
type FillTextRectOption = {
  offset?: number;
  padding?: PaddingOption;
};
declare function fillTextRect(ctx: CanvasRenderingContext2D, text: string, left: number, top: number, width: number, height: number, {
  offset,
  padding
}?: FillTextRectOption): void;
type DrawInlineImageRectOption = {
  offset?: number;
  padding?: PaddingOption;
};
declare function drawInlineImageRect(ctx: CanvasRenderingContext2D, image: CanvasImageSource, srcLeft: number, srcTop: number, srcWidth: number, srcHeight: number, destWidth: number, destHeight: number, left: number, top: number, width: number, height: number, {
  offset,
  padding
}?: DrawInlineImageRectOption): void;
/**
 * Returns an object containing the width of the checkbox.
 * @param  {CanvasRenderingContext2D} ctx canvas context
 * @return {Object} Object containing the width of the checkbox
 * @memberof cheetahGrid.tools.canvashelper
 */
declare function measureCheckbox(ctx: CanvasRenderingContext2D): {
  width: number;
};
/**
 * Returns an object containing the width of the radio button.
 * @param  {CanvasRenderingContext2D} ctx canvas context
 * @return {Object} Object containing the width of the radio button
 * @memberof cheetahGrid.tools.canvashelper
 */
declare function measureRadioButton(ctx: CanvasRenderingContext2D): {
  width: number;
};
type DrawCheckboxOption = {
  uncheckBgColor?: ColorDef;
  checkBgColor?: ColorDef;
  borderColor?: ColorDef;
  boxSize?: number;
};
/**
 * draw Checkbox
 * @param  {CanvasRenderingContext2D} ctx canvas context
 * @param  {number} x The x coordinate where to start drawing the checkbox (relative to the canvas)
 * @param  {number} y The y coordinate where to start drawing the checkbox (relative to the canvas)
 * @param  {boolean|number} check checkbox check status
 * @param  {object} option option
 * @return {void}
 * @memberof cheetahGrid.tools.canvashelper
 */
declare function drawCheckbox(ctx: CanvasRenderingContext2D, x: number, y: number, check: number | boolean, {
  uncheckBgColor,
  checkBgColor,
  borderColor,
  boxSize
}?: DrawCheckboxOption): void;
type DrawRadioButtonOption = {
  checkColor?: ColorDef;
  borderColor?: ColorDef;
  bgColor?: ColorDef;
  boxSize?: number;
};
/**
 * draw Radio button
 * @param  {CanvasRenderingContext2D} ctx canvas context
 * @param  {number} x The x coordinate where to start drawing the radio button (relative to the canvas)
 * @param  {number} y The y coordinate where to start drawing the radio button (relative to the canvas)
 * @param  {boolean|number} check radio button check status
 * @param  {object} option option
 * @return {void}
 * @memberof cheetahGrid.tools.canvashelper
 */
declare function drawRadioButton(ctx: CanvasRenderingContext2D, x: number, y: number, check: number | boolean, {
  checkColor,
  borderColor,
  bgColor,
  boxSize
}?: DrawRadioButtonOption): void;
type DrawButtonOption = {
  backgroundColor?: ColorDef;
  bgColor?: ColorDef;
  radius?: number;
  shadow?: {
    color?: string;
    blur?: number;
    offsetX?: number;
    offsetY?: number;
    offset?: {
      x?: number;
      y?: number;
    };
  };
};
/**
 * draw Button
 */
declare function drawButton(ctx: CanvasRenderingContext2D, left: number, top: number, width: number, height: number, option?: DrawButtonOption): void;
type Canvashelper = {
  roundRect: typeof roundRect;
  fillRoundRect: typeof fillRoundRect;
  strokeRoundRect: typeof strokeRoundRect;
  drawCheckbox: typeof drawCheckbox;
  measureCheckbox: typeof measureCheckbox;
  fillTextRect: typeof fillTextRect;
  drawButton: typeof drawButton;
  drawInlineImageRect: typeof drawInlineImageRect;
  strokeColorsRect: typeof strokeColorsRect;
};
//#endregion
//#region src/js/element/Inline.d.ts
type InlineDrawOption = {
  ctx: CanvasRenderingContext2D;
  canvashelper: Canvashelper;
  rect: RectProps;
  offset: number;
  offsetLeft: number;
  offsetRight: number;
  offsetTop: number;
  offsetBottom: number;
};
declare class Inline implements InlineAPI {
  private _content;
  constructor(content?: string);
  width({
    ctx
  }: {
    ctx: CanvasRenderingContext2D;
  }): number;
  font(): string | null;
  color(): ColorDef | null;
  canDraw(): boolean;
  onReady(_callback: AnyFunction): void;
  draw({
    ctx,
    canvashelper,
    rect,
    offset,
    offsetLeft,
    offsetRight,
    offsetTop,
    offsetBottom
  }: InlineDrawOption): void;
  canBreak(): boolean;
  splitIndex(index: number): {
    before: Inline | null;
    after: Inline | null;
  };
  breakWord(ctx: CanvasRenderingContext2D, width: number): {
    before: Inline | null;
    after: Inline | null;
  };
  breakAll(ctx: CanvasRenderingContext2D, width: number): {
    before: Inline | null;
    after: Inline | null;
  };
  toString(): string;
}
//#endregion
//#region src/js/element/InlineDrawer.d.ts
type InlineDrawerFunction = (options: InlineDrawOption) => void;
declare class InlineDrawer extends Inline {
  private _draw;
  private _width;
  private _color?;
  constructor({
    draw,
    width,
    color
  }: {
    draw: InlineDrawerFunction;
    width: number;
    height: number;
    color?: ColorDef;
  });
  width(_arg: {
    ctx: CanvasRenderingContext2D;
  }): number;
  font(): string | null;
  color(): ColorDef | null;
  canDraw(): boolean;
  onReady(_callback: AnyFunction): void;
  draw({
    ctx,
    canvashelper,
    rect,
    offset,
    offsetLeft,
    offsetRight,
    offsetTop,
    offsetBottom
  }: InlineDrawOption): void;
  canBreak(): boolean;
  toString(): string;
}
//#endregion
//#region src/js/GridCanvasHelper.d.ts
type ColorsDef$1 = ColorDef | (ColorDef | null)[];
declare class GridCanvasHelper<T> implements GridCanvasHelperAPI {
  private _grid;
  private _theme;
  constructor(grid: ListGridAPI<T>);
  createCalculator(context: CellContext, font: string | undefined): {
    calcWidth(width: number | string): number;
    calcHeight(height: number | string): number;
  };
  getColor(color: ColorPropertyDefine, col: number, row: number, ctx: CanvasRenderingContext2D): ColorDef;
  getColor(color: ColorsPropertyDefine, col: number, row: number, ctx: CanvasRenderingContext2D): ColorsDef$1;
  getStyleProperty<T>(style: T | ((args: StylePropertyFunctionArg) => T), col: number, row: number, ctx: CanvasRenderingContext2D): T;
  toBoxArray(obj: ColorsDef$1): [ColorDef | null, ColorDef | null, ColorDef | null, ColorDef | null];
  toBoxPixelArray(value: number | string | (number | string)[], context: CellContext, font: string | undefined): [number, number, number, number];
  get theme(): RequiredThemeDefine;
  drawWithClip(context: CellContext, draw: (ctx: CanvasRenderingContext2D) => void): void;
  drawBorderWithClip(context: CellContext, draw: (ctx: CanvasRenderingContext2D) => void): void;
  text(text: string | (Inline | string)[], context: CellContext, {
    padding,
    offset,
    color,
    textAlign,
    textBaseline,
    font,
    textOverflow,
    icons,
    trailingIcon
  }?: {
    padding?: number | string | (number | string)[];
    offset?: number;
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: FontPropertyDefine;
    textOverflow?: TextOverflow;
    icons?: SimpleColumnIconOption[];
    trailingIcon?: SimpleColumnIconOption;
  }): void;
  multilineText(lines: string[], context: CellContext, {
    padding,
    offset,
    color,
    textAlign,
    textBaseline,
    font,
    lineHeight,
    autoWrapText,
    lineClamp,
    textOverflow,
    icons,
    trailingIcon
  }?: {
    padding?: number | string | (number | string)[];
    offset?: number;
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: FontPropertyDefine;
    lineHeight?: string | number;
    autoWrapText?: boolean;
    lineClamp?: LineClamp;
    textOverflow?: TextOverflow;
    icons?: SimpleColumnIconOption[];
    trailingIcon?: SimpleColumnIconOption;
  }): void;
  fillText(text: string, x: number, y: number, context: CellContext, {
    color,
    textAlign,
    textBaseline,
    font
  }?: {
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: FontPropertyDefine;
  }): void;
  fillCell(context: CellContext, {
    fillColor
  }?: {
    fillColor?: ColorPropertyDefine;
  }): void;
  fillCellWithState(context: CellContext, option?: {
    fillColor?: ColorPropertyDefine;
  }): void;
  fillRect(rect: RectProps, context: CellContext, {
    fillColor
  }?: {
    fillColor?: ColorPropertyDefine;
  }): void;
  fillRectWithState(rect: RectProps, context: CellContext, option?: {
    fillColor?: ColorPropertyDefine;
  }): void;
  getFillColorState(context: CellContext, option?: {
    fillColor?: ColorPropertyDefine;
  }): ColorPropertyDefine;
  border(context: CellContext, {
    borderColor,
    lineWidth
  }?: {
    borderColor?: ColorsPropertyDefine;
    lineWidth?: number;
  }): void;
  borderWithState(context: CellContext, option?: {
    borderColor?: ColorsPropertyDefine;
    lineWidth?: number;
  }): void;
  buildCheckBoxInline(check: boolean, context: CellContext, option?: Parameters<GridCanvasHelperAPI["buildCheckBoxInline"]>[2]): InlineDrawer;
  checkbox(check: boolean, context: CellContext, {
    padding,
    animElapsedTime,
    offset,
    uncheckBgColor,
    checkBgColor,
    borderColor,
    textAlign,
    textBaseline
  }?: Parameters<GridCanvasHelperAPI["checkbox"]>[2]): void;
  radioButton(check: boolean, context: CellContext, {
    padding,
    animElapsedTime,
    offset,
    checkColor,
    uncheckBorderColor,
    checkBorderColor,
    uncheckBgColor,
    checkBgColor,
    textAlign,
    textBaseline
  }?: Parameters<GridCanvasHelperAPI["radioButton"]>[2]): void;
  button(caption: string, context: CellContext, {
    bgColor,
    padding,
    offset,
    color,
    textAlign,
    textBaseline,
    shadow,
    font,
    textOverflow,
    icons
  }?: Parameters<GridCanvasHelperAPI["button"]>[2]): void;
  testFontLoad(font: string | undefined, value: string, context: CellContext): boolean;
}
//#endregion
//#region src/js/header/type/BaseHeader.d.ts
declare abstract class BaseHeader<T> {
  constructor(_options?: {});
  get StyleClass(): typeof BaseStyle$1;
  onDrawCell(cellValue: unknown, info: DrawCellInfo<T>, context: CellContext, grid: ListGridAPI<T>): void;
  convertInternal(value: unknown): unknown;
  abstract drawInternal(value: unknown, context: CellContext, style: BaseStyle$1, helper: GridCanvasHelper<T>, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  bindGridEvent(_grid: ListGridAPI<T>, _cellId: LayoutObjectId): EventListenerId[];
  getCopyCellValue(value: unknown, _grid: ListGridAPI<T>, _cell: CellAddress): unknown;
}
//#endregion
//#region src/js/header/style/StdBaseStyle.d.ts
declare class StdBaseStyle$1 extends BaseStyle$1 {
  private _textAlign;
  private _textBaseline;
  static get DEFAULT(): StdBaseStyle$1;
  constructor(style?: StdBaseStyleOption);
  get textAlign(): CanvasTextAlign;
  set textAlign(textAlign: CanvasTextAlign);
  get textBaseline(): CanvasTextBaseline;
  set textBaseline(textBaseline: CanvasTextBaseline);
  clone(): StdBaseStyle$1;
}
//#endregion
//#region src/js/header/style/StdTextBaseStyle.d.ts
declare class StdTextBaseStyle extends StdBaseStyle$1 {
  private _color?;
  private _font?;
  private _padding;
  private _textOverflow;
  static get DEFAULT(): StdTextBaseStyle;
  constructor(style?: StdTextBaseStyleOption);
  get color(): ColorDef | undefined;
  set color(color: ColorDef | undefined);
  get font(): string | undefined;
  set font(font: string | undefined);
  get padding(): number | string | (number | string)[] | undefined;
  set padding(padding: number | string | (number | string)[] | undefined);
  get textOverflow(): TextOverflow;
  set textOverflow(textOverflow: TextOverflow);
  clone(): StdTextBaseStyle;
}
//#endregion
//#region src/js/header/style/CheckHeaderStyle.d.ts
declare class CheckHeaderStyle extends StdTextBaseStyle {
  private _uncheckBgColor?;
  private _checkBgColor?;
  private _borderColor?;
  static get DEFAULT(): CheckHeaderStyle;
  constructor(style?: CheckHeaderStyleOption);
  get uncheckBgColor(): ColorDef | undefined;
  set uncheckBgColor(uncheckBgColor: ColorDef | undefined);
  get checkBgColor(): ColorDef | undefined;
  set checkBgColor(checkBgColor: ColorDef | undefined);
  get borderColor(): ColorDef | undefined;
  set borderColor(borderColor: ColorDef | undefined);
  clone(): CheckHeaderStyle;
}
//#endregion
//#region src/js/header/type/CheckHeader.d.ts
declare class CheckHeader<T> extends BaseHeader<T> {
  get StyleClass(): typeof CheckHeaderStyle;
  clone(): CheckHeader<T>;
  drawInternal(value: unknown, context: CellContext, style: CheckHeaderStyle, helper: GridCanvasHelper<T>, grid: GridInternal<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/header/style/StdMultilineTextBaseStyle.d.ts
declare class StdMultilineTextBaseStyle extends StdTextBaseStyle {
  private _lineHeight;
  private _autoWrapText;
  private _lineClamp?;
  static get DEFAULT(): StdMultilineTextBaseStyle;
  constructor(style?: StdMultilineTextBaseStyleOption);
  clone(): StdMultilineTextBaseStyle;
  get lineHeight(): string | number;
  set lineHeight(lineHeight: string | number);
  get lineClamp(): LineClamp | undefined;
  set lineClamp(lineClamp: LineClamp | undefined);
  get autoWrapText(): boolean;
  set autoWrapText(autoWrapText: boolean);
}
//#endregion
//#region src/js/header/style/Style.d.ts
declare class Style$1 extends StdMultilineTextBaseStyle {
  private _multiline?;
  static get DEFAULT(): Style$1;
  constructor(style?: HeaderStdStyleOption);
  get multiline(): boolean;
  set multiline(multiline: boolean);
  clone(): Style$1;
}
//#endregion
//#region src/js/header/type/Header.d.ts
declare class Header<T> extends BaseHeader<T> {
  get StyleClass(): typeof Style$1;
  drawInternal(value: unknown, context: CellContext, style: Style$1, helper: GridCanvasHelper<T>, _grid: ListGridAPI<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/header/style/MultilineTextHeaderStyle.d.ts
declare class MultilineTextHeaderStyle extends StdMultilineTextBaseStyle {
  static get DEFAULT(): MultilineTextHeaderStyle;
  constructor(style?: MultilineTextHeaderStyleOption);
  clone(): MultilineTextHeaderStyle;
}
//#endregion
//#region src/js/header/type/MultilineTextHeader.d.ts
declare class MultilineTextHeader<T> extends BaseHeader<T> {
  get StyleClass(): typeof MultilineTextHeaderStyle;
  clone(): MultilineTextHeader<T>;
  drawInternal(value: unknown, context: CellContext, style: MultilineTextHeaderStyle, helper: GridCanvasHelper<T>, _grid: GridInternal<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/header/style/SortHeaderStyle.d.ts
declare class SortHeaderStyle extends StdMultilineTextBaseStyle {
  private _sortArrowColor?;
  private _multiline?;
  static get DEFAULT(): SortHeaderStyle;
  constructor(style?: SortHeaderStyleOption);
  get sortArrowColor(): ColorDef | undefined;
  set sortArrowColor(sortArrowColor: ColorDef | undefined);
  get multiline(): boolean;
  set multiline(multiline: boolean);
  clone(): SortHeaderStyle;
}
//#endregion
//#region src/js/header/type/SortHeader.d.ts
declare class SortHeader<T> extends BaseHeader<T> {
  get StyleClass(): typeof SortHeaderStyle;
  drawInternal(value: unknown, context: CellContext, style: SortHeaderStyle, helper: GridCanvasHelper<T>, grid: ListGridAPI<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
declare namespace type_d_exports {
  export { BaseHeader, CheckHeader, Header, MultilineTextHeader, SortHeader, of$5 as of, ofCell };
}
declare function of$5<T>(headerType: HeaderTypeOption | BaseHeader<T> | null | undefined): BaseHeader<T>;
declare function ofCell<T>(headerCell: BaseHeaderDefine<T>): BaseHeader<T>;
//#endregion
//#region src/js/columns/action/BaseAction.d.ts
type RangePasteContext = {
  reject(): void;
};
declare abstract class BaseAction<T> implements ColumnActionAPI {
  protected _disabled: RecordBoolean;
  constructor(option?: BaseActionOption);
  abstract get editable(): boolean;
  get disabled(): RecordBoolean;
  set disabled(disabled: RecordBoolean);
  abstract clone(): BaseAction<T>;
  abstract bindGridEvent(grid: ListGridAPI<T>, cellId: LayoutObjectId): EventListenerId[];
  protected onChangeDisabledInternal(): void;
  abstract onPasteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress, value: string, context: RangePasteContext): void;
  abstract onDeleteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress): void;
}
//#endregion
//#region src/js/columns/action/Action.d.ts
declare abstract class AbstractAction<T> extends BaseAction<T> {
  private _action;
  constructor(option?: AbstractActionOption);
  get editable(): boolean;
  get action(): ActionListener;
  set action(action: ActionListener);
  abstract get area(): ActionAreaPredicate | undefined;
  abstract set area(_area: ActionAreaPredicate | undefined);
  abstract clone(): AbstractAction<T>;
  abstract getState(_grid: GridInternal<T>): {
    mouseActiveCell?: CellAddress;
  };
  bindGridEvent(grid: ListGridAPI<T>, cellId: LayoutObjectId): EventListenerId[];
  onPasteCellRangeBox(): void;
  onDeleteCellRangeBox(): void;
}
declare class Action<T> extends AbstractAction<T> {
  private _area?;
  constructor(option?: ActionOption);
  get area(): ActionAreaPredicate | undefined;
  set area(area: ActionAreaPredicate | undefined);
  clone(): Action<T>;
  getState(_grid: GridInternal<T>): {
    mouseActiveCell?: CellAddress;
  };
}
//#endregion
//#region src/js/columns/action/ButtonAction.d.ts
declare class ButtonAction<T> extends AbstractAction<T> {
  constructor(option?: ButtonActionOption);
  get area(): ActionAreaPredicate | undefined;
  set area(_area: ActionAreaPredicate | undefined);
  clone(): ButtonAction<T>;
  getState(grid: GridInternal<T>): ButtonColumnState;
}
//#endregion
//#region src/js/columns/action/Editor.d.ts
declare abstract class Editor<T> extends BaseAction<T> {
  protected _readOnly: RecordBoolean;
  constructor(option?: EditorOption);
  get editable(): boolean;
  get readOnly(): RecordBoolean;
  set readOnly(readOnly: RecordBoolean);
  onChangeReadOnlyInternal(): void;
}
//#endregion
//#region src/js/columns/action/CheckEditor.d.ts
declare class CheckEditor<T> extends Editor<T> {
  clone(): CheckEditor<T>;
  bindGridEvent(grid: GridInternal<T>, cellId: LayoutObjectId): EventListenerId[];
  onPasteCellRangeBox(grid: GridInternal<T>, cell: CellAddress, value: string, context: RangePasteContext): void;
  onDeleteCellRangeBox(): void;
}
//#endregion
//#region src/js/columns/action/BaseInputEditor.d.ts
declare abstract class BaseInputEditor<T> extends Editor<T> {
  constructor(option?: EditorOption);
  abstract clone(): BaseInputEditor<T>;
  abstract onInputCellInternal(grid: ListGridAPI<T>, cell: CellAddress, inputValue: string): void;
  abstract onOpenCellInternal(grid: ListGridAPI<T>, cell: CellAddress): void;
  abstract onChangeSelectCellInternal(grid: ListGridAPI<T>, cell: CellAddress, selected: boolean): void;
  abstract onSetInputAttrsInternal(grid: ListGridAPI<T>, cell: CellAddress, input: HTMLInputElement): void;
  abstract onGridScrollInternal(grid: ListGridAPI<T>): void;
  bindGridEvent(grid: ListGridAPI<T>, cellId: LayoutObjectId): EventListenerId[];
  onPasteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress, value: string): void;
  onDeleteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress): void;
  isSupportMultilineValue(): boolean;
}
//#endregion
//#region src/js/columns/action/InlineInputEditor.d.ts
declare class InlineInputEditor<T> extends BaseInputEditor<T> {
  private _classList?;
  private _type?;
  constructor(option?: InlineInputEditorOption);
  get classList(): string[] | undefined;
  set classList(classList: string[] | undefined);
  get type(): string | undefined;
  set type(type: string | undefined);
  clone(): InlineInputEditor<T>;
  onInputCellInternal(grid: ListGridAPI<T>, cell: CellAddress, inputValue: string): void;
  onOpenCellInternal(grid: ListGridAPI<T>, cell: CellAddress): void;
  onChangeSelectCellInternal(grid: ListGridAPI<T>, _cell: CellAddress, _selected: boolean): void;
  onGridScrollInternal(grid: ListGridAPI<T>): void;
  onChangeDisabledInternal(): void;
  onChangeReadOnlyInternal(): void;
  onSetInputAttrsInternal(grid: ListGridAPI<T>, _cell: CellAddress, input: HTMLInputElement): void;
}
//#endregion
//#region src/js/columns/action/InlineMenuEditor.d.ts
declare class InlineMenuEditor<T> extends Editor<T> {
  private _classList?;
  private _options;
  constructor(option?: InlineMenuEditorOption<T>);
  dispose(): void;
  get classList(): string[] | undefined;
  set classList(classList: string[] | undefined);
  get options(): (record: T | undefined) => ColumnMenuItemOption[];
  set options(options: (record: T | undefined) => ColumnMenuItemOption[]);
  clone(): InlineMenuEditor<T>;
  onChangeDisabledInternal(): void;
  onChangeReadOnlyInternal(): void;
  bindGridEvent(grid: GridInternal<T>, cellId: LayoutObjectId): EventListenerId[];
  onPasteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress, value: string, context: RangePasteContext): void;
  onDeleteCellRangeBox(grid: ListGridAPI<T>, cell: CellAddress): void;
  private _pasteDataToOptionValue;
}
//#endregion
//#region src/js/columns/action/RadioEditor.d.ts
declare class RadioEditor<T> extends Editor<T> {
  protected _group: GetRadioEditorGroup<T> | undefined;
  private _checkAction;
  constructor(option?: RadioEditorOption<T>);
  clone(): RadioEditor<T>;
  /** @deprecated Use checkAction instead. */
  get group(): GetRadioEditorGroup<T> | undefined;
  /** @deprecated Use checkAction instead. */
  set group(group: GetRadioEditorGroup<T> | undefined);
  get checkAction(): ActionListener | undefined;
  set checkAction(checkAction: ActionListener | undefined);
  bindGridEvent(grid: GridInternal<T>, cellId: LayoutObjectId): EventListenerId[];
  onPasteCellRangeBox(grid: GridInternal<T>, cell: CellAddress, value: string, context: RangePasteContext): void;
  onDeleteCellRangeBox(): void;
  private _action;
}
//#endregion
//#region src/js/columns/action/SmallDialogInputEditor.d.ts
type GetValueResult$1<T, R> = (value: string, info: {
  grid: ListGridAPI<T>;
  col: number;
  row: number;
}) => R;
declare class SmallDialogInputEditor<T> extends BaseInputEditor<T> {
  private _helperText?;
  private _inputValidator?;
  private _validator?;
  private _classList?;
  private _type?;
  constructor(option?: SmallDialogInputEditorOption<T>);
  dispose(): void;
  get classList(): string[] | undefined;
  set classList(classList: string[] | undefined);
  get type(): string | undefined;
  set type(type: string | undefined);
  get helperText(): string | GetValueResult$1<T, string> | undefined;
  get inputValidator(): GetValueResult$1<T, MaybePromise<string>> | undefined;
  get validator(): GetValueResult$1<T, MaybePromise<string>> | undefined;
  clone(): SmallDialogInputEditor<T>;
  onInputCellInternal(grid: ListGridAPI<T>, cell: CellAddress, inputValue: string): void;
  onOpenCellInternal(grid: ListGridAPI<T>, cell: CellAddress): void;
  onChangeSelectCellInternal(_grid: ListGridAPI<T>, _cell: CellAddress, _selected: boolean): void;
  onGridScrollInternal(_grid: ListGridAPI<T>): void;
  onChangeDisabledInternal(): void;
  onChangeReadOnlyInternal(): void;
  onSetInputAttrsInternal(grid: ListGridAPI<T>, _cell: CellAddress, input: HTMLInputElement): void;
}
declare namespace action_d_exports$1 {
  export { ACTIONS, Action, ActionOption, BaseAction, BaseActionOption, ButtonAction, ButtonActionOption, CheckEditor, Editor, EditorOption, InlineInputEditor, InlineInputEditorOption, InlineMenuEditor, InlineMenuEditorOption, RadioEditor, RangePasteContext, SmallDialogInputEditor, SmallDialogInputEditorOption, of$4 as of };
}
declare class ImmutableCheckEditor extends CheckEditor<any> {
  get disabled(): RecordBoolean;
  get readOnly(): RecordBoolean;
}
declare class ImmutableRadioEditor extends RadioEditor<any> {
  get disabled(): RecordBoolean;
  get readOnly(): RecordBoolean;
}
declare class ImmutableInputEditor extends SmallDialogInputEditor<any> {
  get disabled(): RecordBoolean;
  get readOnly(): RecordBoolean;
}
declare const ACTIONS: {
  CHECK: ImmutableCheckEditor;
  INPUT: ImmutableInputEditor;
  RADIO: ImmutableRadioEditor;
};
/**
 * column actions
 * @namespace cheetahGrid.columns.action
 * @memberof cheetahGrid.columns
 */

declare function of$4<T>(columnAction: ColumnActionOption | BaseAction<T> | null | undefined): BaseAction<T> | undefined;
//#endregion
//#region src/js/columns/style/BaseStyle.d.ts
declare class BaseStyle extends EventTarget$1 implements ColumnStyle {
  private _bgColor?;
  private _visibility?;
  private _indicatorTopLeft?;
  private _indicatorTopRight?;
  private _indicatorBottomRight?;
  private _indicatorBottomLeft?;
  static get EVENT_TYPE(): {
    CHANGE_STYLE: "change_style";
  };
  static get DEFAULT(): BaseStyle;
  constructor({
    bgColor,
    visibility,
    indicatorTopLeft,
    indicatorTopRight,
    indicatorBottomRight,
    indicatorBottomLeft
  }?: BaseStyleOption);
  get bgColor(): ColorDef | undefined;
  set bgColor(bgColor: ColorDef | undefined);
  get visibility(): Visibility | undefined;
  set visibility(visibility: Visibility | undefined);
  get indicatorTopLeft(): IndicatorObject | undefined;
  set indicatorTopLeft(indicatorTopLeft: IndicatorObject | undefined);
  get indicatorTopRight(): IndicatorObject | undefined;
  set indicatorTopRight(indicatorTopRight: IndicatorObject | undefined);
  get indicatorBottomRight(): IndicatorObject | undefined;
  set indicatorBottomRight(indicatorBottomRight: IndicatorObject | undefined);
  get indicatorBottomLeft(): IndicatorObject | undefined;
  set indicatorBottomLeft(indicatorBottomLeft: IndicatorObject | undefined);
  doChangeStyle(): void;
  clone(): BaseStyle;
}
//#endregion
//#region src/js/columns/type/BaseColumn.d.ts
declare abstract class BaseColumn<T> implements ColumnTypeAPI {
  private _fadeinWhenCallbackInPromise?;
  constructor(option?: BaseColumnOption);
  get fadeinWhenCallbackInPromise(): boolean | undefined | null;
  get StyleClass(): typeof BaseStyle;
  onDrawCell(cellValue: MaybePromise<unknown>, info: DrawCellInfo<T>, context: CellContext, grid: ListGridAPI<T>): void | Promise<void>;
  abstract clone(): BaseColumn<T>;
  convertInternal(value: unknown): unknown;
  abstract drawInternal(value: unknown, context: CellContext, style: BaseStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  drawMessageInternal(message: Message, context: CellContext, style: BaseStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  drawIndicatorsInternal(context: CellContext, style: BaseStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  bindGridEvent(_grid: ListGridAPI<T>, _cellId: LayoutObjectId): EventListenerId[];
  getCopyCellValue(value: MaybePromise<unknown>, _grid: ListGridAPI<T>, _cell: CellAddress): unknown;
}
declare namespace style_d_exports {
  export { BaseStyle$1 as BaseStyle, BaseStyleOption, CheckHeaderStyle, CheckHeaderStyleOption, MultilineTextHeaderStyle, SortHeaderStyle, SortHeaderStyleOption, Style$1 as Style, of$3 as of };
}
declare function of$3(headerStyle: HeaderStyleOption | null | undefined, StyleClass: typeof BaseStyle$1): BaseStyle$1;
//#endregion
//#region src/js/list-grid/layout-map/api.d.ts
type OldSortOption<T> = boolean | (string & keyof T) | ((order: "asc" | "desc", col: number, grid: ListGridAPI<T>) => void);
interface BaseHeaderDefine<T> {
  caption?: string | (() => string);
  width?: number | string;
  minWidth?: number | string;
  maxWidth?: number | string;
  headerField?: string;
  headerIcon?: ColumnIconOption<never> | ColumnIconOption<never>[];
  headerStyle?: HeaderStyleOption | BaseStyle$1 | null;
  headerType?: HeaderTypeOption | BaseHeader<T> | null;
  headerAction?: HeaderActionOption | BaseAction$1<T> | null;
  sort?: OldSortOption<T>;
}
interface HeaderDefine<T> extends BaseHeaderDefine<T> {}
interface ColumnDefine<T> extends BaseHeaderDefine<T> {
  field?: FieldDef<T>;
  icon?: ColumnIconOption<T> | ColumnIconOption<T>[];
  message?: Message | ((record: T) => Message | null) | keyof T | (Message | ((record: T) => Message | null) | keyof T)[];
  columnType?: ColumnTypeOption | BaseColumn<T> | null;
  action?: ColumnActionOption | BaseAction<T> | null;
  style?: ColumnStyleOption | null;
}
interface HeaderData<T> {
  id: LayoutObjectId;
  caption?: string | (() => string);
  field?: any;
  headerIcon?: ColumnIconOption<never> | ColumnIconOption<never>[];
  style?: HeaderStyleOption | BaseStyle$1 | null;
  headerType: BaseHeader<T>;
  action?: BaseAction$1<T>;
  define: HeaderDefine<T>;
}
interface WidthData {
  width?: number | string;
  minWidth?: number | string;
  maxWidth?: number | string;
}
interface ColumnData<T> extends WidthData {
  id: LayoutObjectId;
  field?: FieldDef<T>;
  icon?: ColumnIconOption<T> | ColumnIconOption<T>[];
  message?: Message | ((record: T) => Message | null) | keyof T | (Message | ((record: T) => Message | null) | keyof T)[];
  columnType: BaseColumn<T>;
  action?: BaseAction<T>;
  style: ColumnStyleOption | null | undefined;
  define: ColumnDefine<T>;
}
interface GroupHeaderDefine<T> extends HeaderDefine<T> {
  columns: HeadersDefine<T>;
}
type HeadersDefine<T> = (GroupHeaderDefine<T> | ColumnDefine<T>)[];
interface HeaderCellDefine<T> extends HeaderDefine<T> {
  colSpan?: number;
  rowSpan?: number;
}
interface CellDefine<T> extends ColumnDefine<T> {
  colSpan?: number;
  rowSpan?: number;
}
type HeaderBodyLayoutDefine<T> = {
  header: HeaderCellDefine<T>[][];
  body: CellDefine<T>[][];
};
type ArrayLayoutDefine<T> = CellDefine<T>[][];
type LayoutDefine<T> = HeaderBodyLayoutDefine<T> | ArrayLayoutDefine<T>;
/** @internal */
interface LayoutMapAPI<T> {
  readonly headerRowCount: number;
  readonly bodyRowCount: number;
  readonly colCount: number;
  readonly columnWidths: WidthData[];
  readonly headerObjects: HeaderData<T>[];
  readonly columnObjects: ColumnData<T>[];
  getHeader(col: number, row: number): HeaderData<T>;
  getBody(col: number, row: number): ColumnData<T>;
  getCellId(col: number, row: number): LayoutObjectId;
  getCellRange(col: number, row: number): CellRange;
  getBodyLayoutRangeById(id: LayoutObjectId): CellRange;
  getRecordIndexByRow(row: number): number;
  getRecordStartRowByRecordIndex(index: number): number;
}
//#endregion
//#region src/js/columns/message/internal/MessageElement.d.ts
declare class MessageElement {
  private _handler;
  protected _rootElement: HTMLElement;
  protected _messageElement: HTMLElement;
  constructor();
  dispose(): void;
  attach<T>(grid: ListGridAPI<T>, col: number, row: number, message: MessageObject): void;
  move<T>(grid: ListGridAPI<T>, col: number, row: number): void;
  detach(): void;
  _detach(): void;
  _attachCell<T>(grid: ListGridAPI<T>, col: number, row: number): boolean;
  /**
   * If the message is placed outside the Grid, adjust its position.
   */
  _adjustStyle<T>(grid: ListGridAPI<T>, col: number, row: number): void;
}
//#endregion
//#region src/js/columns/message/BaseMessage.d.ts
declare abstract class BaseMessage<T> {
  private _grid;
  private _messageElement;
  constructor(grid: ListGridAPI<T>);
  dispose(): void;
  _getMessageElement(): MessageElement;
  abstract createMessageElementInternal(): MessageElement;
  abstract drawCellMessageInternal(message: MessageObject, context: CellContext, style: ColumnStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  attachMessageElement(col: number, row: number, message: MessageObject): void;
  moveMessageElement(col: number, row: number): void;
  detachMessageElement(): void;
  drawCellMessage(message: MessageObject, context: CellContext, style: ColumnStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/message/MessageHandler.d.ts
declare class MessageHandler$1<T> implements MessageHandler<T> {
  private _grid;
  private _messageInstances;
  private _attachInfo;
  constructor(grid: ListGridAPI<T>, getMessage: (col: number, row: number) => Message);
  dispose(): void;
  drawCellMessage(message: Message, context: CellContext, style: ColumnStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
  _attach(col: number, row: number, message: Message): void;
  _move(col: number, row: number): void;
  _detach(): void;
  _bindGridEvent(grid: ListGridAPI<T>, getMessage: (col: number, row: number) => Message): void;
  _getMessageInstanceOfMessage(message: Message): BaseMessage<T>;
}
//#endregion
//#region src/js/list-grid/LG_EVENT_TYPE.d.ts
interface ListGridEvents extends DrawGridEvents {
  /**
   * Notify before a cell value changes.
   */
  BEFORE_CHANGE_VALUE: "before_change_value";
  /**
   * Indicates when the cell value was changed.
   */
  CHANGED_VALUE: "changed_value";
  /**
   * Indicates when the header cell value was changed.
   */
  CHANGED_HEADER_VALUE: "changed_header_value";
  /**
   * Indicates that the pasted value has been rejected.
   */
  REJECTED_PASTE_VALUES: "rejected_paste_values";
}
declare const LG_EVENT_TYPE: ListGridEvents;
//#endregion
//#region src/js/themes/theme.d.ts
declare const _$1: unique symbol;
declare class Theme implements RequiredThemeDefine {
  private [_$1];
  private _checkbox;
  private _radioButton;
  private _button;
  private _tree;
  private _header;
  private _messages;
  private _indicators;
  constructor(obj: ThemeDefine);
  constructor(obj: PartialThemeDefine, superTheme: ThemeDefine);
  get font(): string;
  get underlayBackgroundColor(): string;
  get color(): ColorPropertyDefine;
  get frozenRowsColor(): ColorPropertyDefine;
  get defaultBgColor(): ColorPropertyDefine;
  get frozenRowsBgColor(): ColorPropertyDefine;
  get selectionBgColor(): ColorPropertyDefine;
  get highlightBgColor(): ColorPropertyDefine;
  get borderColor(): ColorsPropertyDefine;
  get frozenRowsBorderColor(): ColorsPropertyDefine;
  get highlightBorderColor(): ColorsPropertyDefine;
  get checkbox(): RequiredThemeDefine["checkbox"];
  get radioButton(): RequiredThemeDefine["radioButton"];
  get button(): RequiredThemeDefine["button"];
  get tree(): RequiredThemeDefine["tree"];
  get header(): RequiredThemeDefine["header"];
  get messages(): RequiredThemeDefine["messages"];
  get indicators(): RequiredThemeDefine["indicators"];
  hasProperty(names: string[]): boolean;
  extends(obj: PartialThemeDefine): Theme;
}
//#endregion
//#region src/js/tooltip/internal/TooltipElement.d.ts
declare class TooltipElement<T> {
  private _handler;
  private _rootElement;
  private _messageElement;
  constructor();
  dispose(): void;
  attach(grid: ListGridAPI<T>, col: number, row: number, content: string): void;
  move(grid: ListGridAPI<T>, col: number, row: number): void;
  detach(): void;
  _detach(): void;
  _attachCell(grid: ListGridAPI<T>, col: number, row: number): boolean;
}
//#endregion
//#region src/js/tooltip/BaseTooltip.d.ts
declare abstract class BaseTooltip<T> {
  private _grid;
  private _tooltipElement?;
  constructor(grid: ListGridAPI<T>);
  dispose(): void;
  private _getTooltipElement;
  abstract createTooltipElementInternal(): TooltipElement<T>;
  attachTooltipElement(col: number, row: number, content: string): void;
  moveTooltipElement(col: number, row: number): void;
  detachTooltipElement(): void;
}
//#endregion
//#region src/js/tooltip/Tooltip.d.ts
declare class Tooltip<T> extends BaseTooltip<T> {
  createTooltipElementInternal(): TooltipElement<T>;
}
//#endregion
//#region src/js/tooltip/TooltipHandler.d.ts
declare class TooltipHandler<T> {
  private _grid;
  private _tooltipInstances;
  private _attachInfo?;
  constructor(grid: ListGridAPI<T>);
  dispose(): void;
  _attach(col: number, row: number): void;
  _move(col: number, row: number): void;
  _detach(): void;
  _isAttachCell(col: number, row: number): boolean;
  _bindGridEvent(grid: ListGridAPI<T>): void;
  _getTooltipInstanceInfo(col: number, row: number): {
    instance: Tooltip<T>;
    type: string;
    content: string;
  } | null;
}
//#endregion
//#region src/js/ListGrid.d.ts
/** @private */
declare const _: typeof PROTECTED_SYMBOL;
/** @protected */
interface ListGridProtected<T> extends DrawGridProtected {
  dataSourceEventIds?: EventListenerId[];
  headerEvents?: EventListenerId[];
  layoutMap: LayoutMapAPI<T>;
  headerValues?: HeaderValues;
  tooltipHandler: TooltipHandler<T>;
  messageHandler: MessageHandler$1<T>;
  theme: Theme | null;
  headerRowHeight: number[] | number;
  header: HeadersDefine<T>;
  layout: LayoutDefine<T>;
  gridCanvasHelper: GridCanvasHelper<T>;
  sortState: SortState;
  dataSource: DataSource<T>;
  records?: T[] | null;
  allowRangePaste: boolean;
}
interface ListGridConstructorOptions<T> extends DrawGridConstructorOptions {
  /**
   * Simple header property
   */
  header?: HeadersDefine<T>;
  /**
   * Layout property
   */
  layout?: LayoutDefine<T>;
  /**
   * Header row height(s)
   */
  headerRowHeight?: number[] | number;
  /**
   * Records data source
   */
  dataSource?: DataSource<T>;
  /**
   * Simple records data
   */
  records?: T[];
  /**
   * Theme
   */
  theme?: ThemeDefine | string;
  /**
   * If set to true to allow pasting of ranges. default false
   */
  allowRangePaste?: boolean;
  /**
   * @deprecated Cannot be used with ListGrid.
   * @override
   */
  rowCount?: undefined;
  /**
   * @deprecated Cannot be used with ListGrid.
   * @override
   */
  colCount?: undefined;
  /**
   * @deprecated Cannot be used with ListGrid.
   * @override
   */
  frozenRowCount?: undefined;
}
/**
 * ListGrid
 * @classdesc cheetahGrid.ListGrid
 * @memberof cheetahGrid
 */
declare class ListGrid<T> extends DrawGrid implements ListGridAPI<T> {
  protected [_]: ListGridProtected<T>;
  disabled: boolean;
  readOnly: boolean;
  static get EVENT_TYPE(): typeof LG_EVENT_TYPE;
  /**
   * constructor
   *
   * @constructor
   * @param options Constructor options
   */
  constructor(options?: ListGridConstructorOptions<T>);
  /**
   * Dispose the grid instance.
   * @returns {void}
   */
  dispose(): void;
  /**
   * Gets the define of the header.
   */
  get header(): HeadersDefine<T>;
  /**
   * Sets the define of the header with the given data.
   * <pre>
   * column options
   * -----
   * caption: header caption
   * field: field name
   * width: column width
   * minWidth: column min width
   * maxWidth: column max width
   * icon: icon definition
   * message: message key name
   * columnType: column type
   * action: column action
   * style: column style
   * headerType: header type
   * headerStyle: header style
   * headerAction: header action
   * headerField: header field name
   * headerIcon: header icon definition
   * sort: define sort setting
   * -----
   *
   * multiline header
   * -----
   * caption: header caption
   * columns: columns define
   * -----
   * </pre>
   */
  set header(header: HeadersDefine<T>);
  /**
   * Gets the define of the layout.
   */
  get layout(): LayoutDefine<T>;
  /**
   * Sets the define of the layout with the given data.
   */
  set layout(layout: LayoutDefine<T>);
  /**
   * Gets the define of the headerRowHeight.
   */
  get headerRowHeight(): number | number[];
  /**
   * Sets the define of the headerRowHeight with the given data.
   */
  set headerRowHeight(headerRowHeight: number | number[]);
  /**
   * Get the row count per record
   */
  get recordRowCount(): number;
  /**
   * Get the records.
   */
  get records(): T[] | null;
  /**
   * Set the records from given
   */
  set records(records: T[] | null);
  /**
   * Get the data source.
   */
  get dataSource(): DataSource<T>;
  /**
   * Set the data source from given
   */
  set dataSource(dataSource: DataSource<T>);
  /**
   * Get the theme.
   */
  get theme(): Theme | null;
  /**
   * Set the theme from given
   */
  set theme(theme: Theme | null);
  /**
   * If set to true to allow pasting of ranges.
   */
  get allowRangePaste(): boolean;
  set allowRangePaste(allowRangePaste: boolean);
  /**
   * Get the font definition as a string.
   * @override
   */
  get font(): string;
  /**
   * Set the font definition with the given string.
   * @override
   */
  set font(font: string);
  /**
   * Get the background color of the underlay.
   * @override
   */
  get underlayBackgroundColor(): string;
  /**
   * Set the background color of the underlay.
   * @override
   */
  set underlayBackgroundColor(underlayBackgroundColor: string);
  /**
   * Get the sort state.
   */
  get sortState(): SortState;
  /**
   * Sets the sort state.
   * If `null` to set, the sort state is initialized.
   */
  set sortState(sortState: SortState | null);
  /**
   * Get the header values.
   */
  get headerValues(): HeaderValues;
  /**
   * Sets the header values.
   */
  set headerValues(headerValues: HeaderValues);
  /**
   * Get the field of the given column index.
   * @param  {number} col The column index.
   * @param  {number} row The row index.
   * @return {*} The field object.
   */
  getField(col: number, row: number): FieldDef<T> | undefined;
  /**
   * Get the column define of the given column index.
   * @param  {number} col The column index.
   * @param  {number} row The row index.
   * @return {*} The column define object.
   */
  getColumnDefine(col: number, row: number): ColumnDefine<T>;
  getColumnType(col: number, row: number): ColumnTypeAPI;
  getColumnAction(col: number, row: number): ColumnActionAPI | undefined;
  /**
   * Get the header field of the given header cell.
   * @param  {number} col The column index.
   * @param  {number} row The header row index.
   * @return {*} The field object.
   */
  getHeaderField(col: number, row: number): any | undefined;
  /**
   * Get the header define of the given header cell.
   * @param  {number} col The column index.
   * @param  {number} row The header row index.
   * @return {*} The header define object.
   */
  getHeaderDefine(col: number, row: number): HeaderDefine<T>;
  /**
   * Get the record of the given row index.
   * @param  {number} row The row index.
   * @return {object} The record.
   */
  getRowRecord(row: number): MaybePromiseOrUndef<T>;
  /**
   * Get the record index of the given row index.
   * @param  {number} row The row index.
   */
  getRecordIndexByRow(row: number): number;
  /**
   * Gets the row index starting at the given record index.
   * @param  {number} index The record index.
   */
  getRecordStartRowByRecordIndex(index: number): number;
  /**
   * Get the column index of the given field.
   * @param  {*} field The field.
   * @return {number} The column index.
   * @deprecated use `getCellRangeByField` instead
   */
  getColumnIndexByField(field: FieldDef<T>): number | null;
  /**
   * Get the column index of the given field.
   * @param  {*} field The field.
   * @param  {number} index The record index
   * @return {number} The column index.
   */
  getCellRangeByField(field: FieldDef<T>, index: number): CellRange | null;
  /**
   * Focus the cell.
   * @param  {*} field The field.
   * @param  {number} index The record index
   * @return {void}
   */
  focusGridCell(field: FieldDef<T>, index: number): void;
  /**
   * Scroll to where cell is visible.
   * @param  {*} field The field.
   * @param  {number} index The record index
   * @return {void}
   */
  makeVisibleGridCell(field: FieldDef<T>, index: number): void;
  getGridCanvasHelper(): GridCanvasHelper<T>;
  /**
   * Get cell range information for a given cell.
   * @param {number} col column index of the cell
   * @param {number} row row index of the cell
   * @returns {object} cell range info
   */
  getCellRange(col: number, row: number): CellRange;
  /**
   * Get header range information for a given cell.
   * @param {number} col column index of the cell
   * @param {number} row row index of the cell
   * @returns {object} cell range info
   * @deprecated use `getCellRange` instead
   */
  getHeaderCellRange(col: number, row: number): CellRange;
  protected getCopyCellValue(col: number, row: number, range?: CellRange): unknown;
  protected onDrawCell(col: number, row: number, context: CellContext): MaybePromise<void>;
  doGetCellValue(col: number, row: number, valueCallback: (value: any) => void): boolean;
  doChangeValue(col: number, row: number, changeValueCallback: (before: any) => any): MaybePromise<boolean>;
  doSetPasteValue(text: string, test?: (data: SetPasteValueTestData<T>) => boolean): void;
  getHeaderValue(col: number, row: number): any | undefined;
  setHeaderValue(col: number, row: number, newValue: any): void;
  getLayoutCellId(col: number, row: number): LayoutObjectId;
  protected bindEventsInternal(): void;
  protected getMoveLeftColByKeyDownInternal({
    col,
    row
  }: CellAddress): number;
  protected getMoveRightColByKeyDownInternal({
    col,
    row
  }: CellAddress): number;
  protected getMoveUpRowByKeyDownInternal({
    col,
    row
  }: CellAddress): number;
  protected getMoveDownRowByKeyDownInternal({
    col,
    row
  }: CellAddress): number;
  protected getOffsetInvalidateCells(): number;
  protected getCopyRangeInternal(range: CellRange): CellRange;
  fireListeners<TYPE extends keyof ListGridEventHandlersEventMap<T>>(type: TYPE, ...event: ListGridEventHandlersEventMap<T>[TYPE]): ListGridEventHandlersReturnMap[TYPE][];
}
//#endregion
//#region src/js/ts-types/events.d.ts
type KeyboardEventListener = (e: KeyboardEvent) => void;
type AnyListener = AnyFunction;
type EventListenerId = number;
type BeforeSelectedCellEvent = CellAddress & {
  selected: false;
  after: CellAddress;
};
type AfterSelectedCellEvent = CellAddress & {
  selected: true;
  before: CellAddress;
};
type SelectedCellEvent = BeforeSelectedCellEvent | AfterSelectedCellEvent;
type MouseCellEvent = CellAddress & {
  event: MouseEvent;
};
type TouchCellEvent = CellAddress & {
  event: TouchEvent;
};
type KeydownEvent = {
  keyCode: number;
  event: KeyboardEvent;
  stopCellMoving(): void;
};
interface PasteRangeBoxValues {
  readonly colCount: number;
  readonly rowCount: number;
  getCellValue(offsetCol: number, offsetRow: number): string;
}
type PasteCellEvent = CellAddress & {
  value: string;
  normalizeValue: string;
  multi: boolean;
  rangeBoxValues: PasteRangeBoxValues;
  event: ClipboardEvent;
};
type InputCellEvent = CellAddress & {
  value: string;
};
type DeleteCellEvent = CellAddress & {
  event: KeyboardEvent;
};
type ScrollEvent = {
  event: Event;
};
type ModifyStatusEditableinputCellEvent = CellAddress & {
  input: HTMLInputElement;
};
type MousePointerCellEvent = CellAddress & {
  related?: CellAddress;
  event: Pick<MouseEvent, "clientX" | "clientY" | "pageX" | "pageY">;
};
interface DrawGridEventHandlersEventMap {
  selected_cell: [SelectedCellEvent, boolean];
  click_cell: [MouseCellEvent];
  dblclick_cell: [MouseCellEvent];
  mouseenter_cell: [MousePointerCellEvent];
  mouseleave_cell: [MousePointerCellEvent];
  mouseover_cell: [MousePointerCellEvent];
  mouseout_cell: [MousePointerCellEvent];
  mousemove_cell: [MouseCellEvent];
  mousedown_cell: [MouseCellEvent];
  mouseup_cell: [MouseCellEvent];
  contextmenu_cell: [MouseCellEvent];
  touchstart_cell: [TouchCellEvent];
  dbltap_cell: [TouchCellEvent];
  keydown: [KeydownEvent];
  paste_cell: [PasteCellEvent];
  input_cell: [InputCellEvent];
  delete_cell: [DeleteCellEvent];
  scroll: [ScrollEvent];
  editableinput_cell: [CellAddress];
  modify_status_editableinput_cell: [ModifyStatusEditableinputCellEvent];
  focus_grid: [FocusEvent];
  blur_grid: [FocusEvent];
  resize_column: [{
    col: number;
  }];
  copydata: [CellRange];
}
interface DrawGridEventHandlersReturnMap {
  selected_cell: void;
  click_cell: void;
  dblclick_cell: void;
  mouseenter_cell: void;
  mouseleave_cell: void;
  mouseover_cell: void;
  mouseout_cell: void;
  mousemove_cell: void;
  mousedown_cell: boolean;
  mouseup_cell: void;
  contextmenu_cell: void;
  touchstart_cell: void;
  dbltap_cell: void;
  keydown: void;
  paste_cell: void;
  input_cell: void;
  delete_cell: void;
  scroll: void;
  editableinput_cell: boolean | void;
  modify_status_editableinput_cell: void;
  focus_grid: void;
  blur_grid: void;
  resize_column: void;
  copydata: string;
}
type ChangedValueCellEvent<T> = CellAddress & {
  record: T;
  field: FieldDef<T>;
  value: any;
  oldValue: any;
};
type ChangedHeaderValueCellEvent = CellAddress & {
  field: string;
  value: any;
  oldValue: any;
};
type PasteRejectedValuesEvent<T> = {
  detail: (CellAddress & {
    record: T | undefined;
    define: ColumnDefine<T>;
    pasteValue: string;
  })[];
};
interface ListGridEventHandlersEventMap<T> extends DrawGridEventHandlersEventMap {
  before_change_value: [ChangedValueCellEvent<T>];
  changed_value: [ChangedValueCellEvent<T>];
  changed_header_value: [ChangedHeaderValueCellEvent];
  rejected_paste_values: [PasteRejectedValuesEvent<T>];
}
interface ListGridEventHandlersReturnMap extends DrawGridEventHandlersReturnMap {
  before_change_value: void;
  changed_value: void;
  changed_header_value: void;
  rejected_paste_values: void;
}
//#endregion
//#region src/js/ts-types/plugin.d.ts
interface IconDefine {
  d: string;
  width: number;
  height: number;
}
type PartialThemeDefine = Partial<ThemeDefine>;
interface ThemeDefine {
  font?: string;
  underlayBackgroundColor: string;
  color: ColorPropertyDefine;
  frozenRowsColor?: ColorPropertyDefine;
  defaultBgColor?: ColorPropertyDefine;
  frozenRowsBgColor?: ColorPropertyDefine;
  selectionBgColor: ColorPropertyDefine;
  highlightBgColor?: ColorPropertyDefine;
  borderColor: ColorsPropertyDefine;
  frozenRowsBorderColor: ColorsPropertyDefine;
  highlightBorderColor: ColorsPropertyDefine;
  checkbox: {
    uncheckBgColor?: ColorPropertyDefine;
    checkBgColor?: ColorPropertyDefine;
    borderColor?: ColorPropertyDefine;
  };
  radioButton: {
    checkColor?: ColorPropertyDefine;
    uncheckBorderColor?: ColorPropertyDefine;
    checkBorderColor?: ColorPropertyDefine;
    uncheckBgColor?: ColorPropertyDefine;
    checkBgColor?: ColorPropertyDefine;
  };
  button: {
    color?: ColorPropertyDefine;
    bgColor?: ColorPropertyDefine;
  };
  tree: {
    lineStyle?: TreeLineStyle;
    lineColor?: ColorPropertyDefine;
    lineWidth?: number;
    treeIcon?: TreeBranchIconStyleDefine;
  };
  header: {
    sortArrowColor?: ColorPropertyDefine;
  };
  messages: {
    infoBgColor?: ColorPropertyDefine;
    errorBgColor?: ColorPropertyDefine;
    warnBgColor?: ColorPropertyDefine;
    boxWidth?: number;
    markHeight?: number;
  };
  indicators: {
    topLeftColor?: ColorPropertyDefine;
    topLeftSize?: number;
    topRightColor?: ColorPropertyDefine;
    topRightSize?: number;
    bottomRightColor?: ColorPropertyDefine;
    bottomRightSize?: number;
    bottomLeftColor?: ColorPropertyDefine;
    bottomLeftSize?: number;
  };
}
type RequiredThemeDefine = Required<ThemeDefine> & {
  checkbox: Required<ThemeDefine["checkbox"]>;
  radioButton: Required<ThemeDefine["radioButton"]>;
  button: Required<ThemeDefine["button"]>;
  tree: Required<ThemeDefine["tree"]>;
  header: Required<ThemeDefine["header"]>;
  messages: Required<ThemeDefine["messages"]>;
  indicators: Required<ThemeDefine["indicators"]>;
};
//#endregion
//#region src/js/ts-types/data.d.ts
interface MessageObject {
  type: "error" | "info" | "warning";
  message: string | null;
  original?: Message;
}
type Message = MessageObject | string;
//#endregion
//#region src/js/ts-types/grid-engine.d.ts
type LayoutObjectId = number | string | symbol;
type DrawGridKeyboardMoveCellFunction = (context: {
  event: KeyboardEvent;
  cell: CellAddress;
  grid: DrawGridAPI;
}) => CellAddress | null;
interface DrawGridKeyboardOptions {
  moveCellOnTab?: boolean | DrawGridKeyboardMoveCellFunction;
  moveCellOnEnter?: boolean | DrawGridKeyboardMoveCellFunction;
  deleteCellValueOnDel?: boolean;
  selectAllOnCtrlA?: boolean;
}
interface DrawGridAPI {
  font?: string;
  rowCount: number;
  colCount: number;
  frozenRowCount: number;
  frozenColCount: number;
  defaultRowHeight: number;
  defaultColWidth: string | number;
  underlayBackgroundColor?: string;
  trimOnPaste: boolean;
  keyboardOptions: DrawGridKeyboardOptions | null;
  readonly selection: Selection;
  readonly canvas: HTMLCanvasElement;
  readonly visibleRowCount: number;
  readonly visibleColCount: number;
  readonly topRow: number;
  readonly leftCol: number;
  scrollLeft: number;
  scrollTop: number;
  getElement(): HTMLElement;
  focus(): void;
  hasFocusGrid(): boolean;
  listen<TYPE extends keyof DrawGridEventHandlersEventMap>(type: TYPE, listener: (...event: DrawGridEventHandlersEventMap[TYPE]) => DrawGridEventHandlersReturnMap[TYPE]): EventListenerId;
  listen(type: string, listener: AnyListener): EventListenerId;
  configure(name: "fadeinWhenCallbackInPromise", value?: boolean): boolean;
  updateSize(): void;
  updateScroll(): boolean;
  invalidate(): void;
  invalidateCell(col: number, row: number): void;
  invalidateGridRect(startCol: number, startRow: number, endCol?: number, endRow?: number): void;
  invalidateCellRange(cellRange: CellRange): void;
  getRowHeight(row: number): number;
  setRowHeight(row: number, height: number): void;
  getColWidth(col: number): number;
  setColWidth(col: number, width: string | number | null): void;
  getMaxColWidth(col: number): string | number | undefined;
  setMaxColWidth(col: number, maxwidth: string | number): void;
  getMinColWidth(col: number): string | number | undefined;
  setMinColWidth(col: number, minwidth: string | number): void;
  getCellRect(col: number, row: number): RectProps;
  getCellRelativeRect(col: number, row: number): RectProps;
  getCellsRect(startCol: number, startRow: number, endCol: number, endRow: number): RectProps;
  getCellRangeRect(cellRange: CellRange): RectProps;
  isFrozenCell(col: number, row: number): {
    row: boolean;
    col: boolean;
  } | null;
  getRowAt(absoluteY: number): number;
  getColAt(absoluteX: number): number;
  getCellAt(absoluteX: number, absoluteY: number): CellAddress;
  makeVisibleCell(col: number, row: number): void;
  setFocusCursor(col: number, row: number): void;
  focusCell(col: number, row: number): void;
  getCellOverflowText(col: number, row: number): string | null;
  setCellOverflowText(col: number, row: number, overflowText: false | string): void;
  getAttachCellsArea(range: CellRange): {
    element: HTMLElement;
    rect: RectProps;
  };
  onKeyDownMove(evt: KeyboardEvent): void;
  dispose(): void;
  addDisposable(disposable: {
    dispose(): void;
  }): void;
}
interface DataSourceAPI<T> {
  length: number;
  get(index: number): MaybePromiseOrUndef<T>;
  getField<F extends FieldDef<T>>(index: number, field: F): FieldData;
  hasField(index: number, field: FieldDef<T>): boolean;
  setField<F extends FieldDef<T>>(index: number, field: F, value: any): MaybePromise<boolean>;
  sort(field: FieldDef<T>, order: "desc" | "asc"): MaybePromise<void>;
  dataSource: DataSourceAPI<T>;
}
interface SortState {
  col: number;
  row: number;
  order: "asc" | "desc" | undefined;
}
type HeaderValues = Map<any, any>;
interface ListGridAPI<T> extends DrawGridAPI {
  records: T[] | null;
  dataSource: DataSourceAPI<T>;
  theme: RequiredThemeDefine | null;
  allowRangePaste: boolean;
  header: HeadersDefine<T>;
  headerRowHeight: number[] | number;
  sortState: SortState | null;
  headerValues: HeaderValues;
  recordRowCount: number;
  disabled: boolean;
  readOnly: boolean;
  listen<TYPE extends keyof ListGridEventHandlersEventMap<T>>(type: TYPE, listener: (...event: ListGridEventHandlersEventMap<T>[TYPE]) => ListGridEventHandlersReturnMap[TYPE]): EventListenerId;
  getField(col: number, row: number): FieldDef<T> | undefined;
  getRowRecord(row: number): MaybePromiseOrUndef<T>;
  getRecordIndexByRow(row: number): number;
  getRecordStartRowByRecordIndex(index: number): number;
  getHeaderField(col: number, row: number): any | undefined;
  getHeaderValue(col: number, row: number): any | undefined;
  setHeaderValue(col: number, row: number, newValue: any): void;
  getCellRange(col: number, row: number): CellRange;
  getCellRangeByField(field: FieldDef<T>, index: number): CellRange | null;
  focusGridCell(field: FieldDef<T>, index: number): void;
  makeVisibleGridCell(field: FieldDef<T>, index: number): void;
  getGridCanvasHelper(): GridCanvasHelperAPI;
  doChangeValue(col: number, row: number, changeValueCallback: (before: any) => any): MaybePromise<boolean>;
  doGetCellValue(col: number, row: number, valueCallback: (value: any) => void): boolean;
  doSetPasteValue(text: string): void;
  doSetPasteValue(text: string, test: (data: SetPasteValueTestData<T>) => boolean): void;
  getLayoutCellId(col: number, row: number): LayoutObjectId;
  getColumnType(col: number, row: number): ColumnTypeAPI;
  getColumnDefine(col: number, row: number): ColumnDefine<T>;
  getColumnAction(col: number, row: number): ColumnActionAPI | undefined;
  fireListeners<TYPE extends keyof ListGridEventHandlersEventMap<T>>(type: TYPE, ...event: ListGridEventHandlersEventMap<T>[TYPE]): ListGridEventHandlersReturnMap[TYPE][];
}
interface ColumnTypeAPI {}
interface ColumnActionAPI {
  readonly editable: boolean;
  disabled: RecordBoolean;
}
type SetPasteValueTestData<T> = CellAddress & {
  grid: ListGridAPI<T>;
  record: T;
  value: string;
  oldValue: any;
};
interface InlineAPI {
  width(arg: {
    ctx: CanvasRenderingContext2D;
  }): number;
  font(): string | null;
  color(): ColorDef | null;
  canDraw(): boolean;
  onReady(callback: AnyFunction): void;
  draw(opt: any): void;
  canBreak(): boolean;
}
type ColorsDef = ColorDef | (ColorDef | null)[];
interface GridCanvasHelperAPI {
  theme: RequiredThemeDefine;
  text(text: string | (InlineAPI | string)[], context: CellContext, option: {
    padding?: number | string | (number | string)[];
    offset?: number;
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: FontPropertyDefine;
    textOverflow?: TextOverflow;
    icons?: SimpleColumnIconOption[];
  }): void;
  button(caption: string, context: CellContext, option: {
    bgColor?: ColorPropertyDefine;
    padding?: number | string | (number | string)[];
    offset?: number;
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    shadow?: {
      color?: string;
      blur?: number;
      offsetX?: number;
      offsetY?: number;
      offset?: {
        x?: number;
        y?: number;
      };
    };
    font?: FontPropertyDefine;
    textOverflow?: TextOverflow;
    icons?: SimpleColumnIconOption[];
  }): void;
  checkbox(check: boolean, context: CellContext, option: {
    padding?: number | string | (number | string)[];
    animElapsedTime?: number;
    offset?: number;
    uncheckBgColor?: ColorPropertyDefine;
    checkBgColor?: ColorPropertyDefine;
    borderColor?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
  }): void;
  radioButton(check: boolean, context: CellContext, option: {
    padding?: number | string | (number | string)[];
    animElapsedTime?: number;
    offset?: number;
    checkColor?: ColorPropertyDefine;
    uncheckBorderColor?: ColorPropertyDefine;
    checkBorderColor?: ColorPropertyDefine;
    uncheckBgColor?: ColorPropertyDefine;
    checkBgColor?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
  }): void;
  multilineText(lines: string[], context: CellContext, option: {
    padding?: number | string | (number | string)[];
    offset?: number;
    color?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
    font?: FontPropertyDefine;
    lineHeight?: string | number;
    autoWrapText?: boolean;
    lineClamp?: LineClamp;
    textOverflow?: TextOverflow;
    icons?: SimpleColumnIconOption[];
  }): void;
  getColor(color: ColorPropertyDefine, col: number, row: number, ctx: CanvasRenderingContext2D): ColorDef;
  getColor(color: ColorsPropertyDefine, col: number, row: number, ctx: CanvasRenderingContext2D): ColorsDef;
  getStyleProperty<T>(style: T | ((args: StylePropertyFunctionArg) => T), col: number, row: number, ctx: CanvasRenderingContext2D): T;
  toBoxPixelArray(value: number | string | (number | string)[], context: CellContext, font: string | undefined): [number, number, number, number];
  fillRectWithState(rect: RectProps, context: CellContext, option: {
    fillColor?: ColorPropertyDefine;
  }): void;
  drawBorderWithClip(context: CellContext, draw: (ctx: CanvasRenderingContext2D) => void): void;
  drawWithClip(context: CellContext, draw: (ctx: CanvasRenderingContext2D) => void): void;
  testFontLoad(font: string | undefined, value: string, context: CellContext): boolean;
  buildCheckBoxInline(check: boolean, context: CellContext, option: {
    animElapsedTime?: number;
    uncheckBgColor?: ColorPropertyDefine;
    checkBgColor?: ColorPropertyDefine;
    borderColor?: ColorPropertyDefine;
    textAlign?: CanvasTextAlign;
    textBaseline?: CanvasTextBaseline;
  }): InlineAPI;
}
interface CellContext {
  readonly col: number;
  readonly row: number;
  getContext(): CanvasRenderingContext2D;
  toCurrentContext(): CellContext;
  getDrawRect(): RectProps | null;
  getRect(): RectProps;
  getSelection(): {
    select: CellAddress;
    range: CellRange;
  };
  setRectFilter(rectFilter: (base: RectProps) => RectProps): void;
}
interface Selection {
  select: CellAddress;
  range: CellRange;
}
interface DrawCellInfo<T> {
  getRecord(): unknown;
  getIcon(): ColumnIconOption<never> | ColumnIconOption<never>[] | null;
  getMessage(): Message;
  messageHandler: MessageHandler<T>;
  style: ColumnStyleOption | HeaderStyleOption | null | undefined;
  drawCellBase(arg?: {
    bgColor?: ColorPropertyDefine;
  }): void;
  drawCellBg(arg?: {
    bgColor?: ColorPropertyDefine;
  }): void;
  drawCellBorder(): void;
}
interface MessageHandler<T> {
  drawCellMessage(message: Message, context: CellContext, style: ColumnStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/ts-types/define.d.ts
interface FontIcon<T> {
  font?: string;
  content?: T extends object ? keyof T & string : string;
  className?: string;
  tagName?: string;
  isLiga?: boolean;
  width?: number;
  height?: number;
  color?: string;
  offsetTop?: number;
  offsetLeft?: number;
}
interface ImageIcon<T> {
  src: T extends object ? keyof T & string : string;
  width?: number;
  height?: number;
}
interface PathIcon<T> {
  path: T extends object ? keyof T & string : string;
  width: number;
  height: number;
  color?: string;
}
interface SvgIcon<T> {
  svg: T extends object ? keyof T & string : string;
  width?: number;
  height?: number;
}
interface NamedIcon<T> {
  name: T extends object ? keyof T & string : string;
  width?: number;
  height?: number;
}
type ColumnIconOption<T> = FontIcon<T> | ImageIcon<T> | PathIcon<T> | SvgIcon<T> | NamedIcon<T>;
type ColumnMenuItemOptions = ColumnMenuItemOption[] | SimpleColumnMenuItemOption[] | OldSimpleColumnMenuItemOption[] | string | ColumnMenuItemObjectOptions;
interface ColumnMenuItemOption {
  value: any;
  label: string;
  classList?: string[];
  html?: string;
}
interface SimpleColumnMenuItemOption {
  value: any;
  label: string;
}
/** @internal */
interface OldSimpleColumnMenuItemOption {
  value: any;
  caption: string;
}
interface ColumnMenuItemObjectOptions {
  [value: string]: string;
}
type Visibility = "visible" | "hidden";
type TextOverflow = "clip" | "ellipsis" | string;
type LineClamp = number | "auto";
interface StylePropertyFunctionArg {
  row: number;
  col: number;
  grid: ListGridAPI<any>;
  context: CanvasRenderingContext2D;
}
type ColorPropertyDefine = ColorDef | ((args: StylePropertyFunctionArg) => string) | ((args: StylePropertyFunctionArg) => CanvasGradient) | ((args: StylePropertyFunctionArg) => CanvasPattern) | ((args: StylePropertyFunctionArg) => string | CanvasGradient | CanvasPattern | undefined);
type ColorsPropertyDefine = ColorPropertyDefine | (ColorDef | null)[] | ((args: StylePropertyFunctionArg) => (ColorDef | null)[]);
type FontPropertyDefine = string | ((args: StylePropertyFunctionArg) => string);
type IndicatorStyle = "triangle" | "none";
type IndicatorObject = {
  style?: IndicatorStyle;
  color?: ColorDef;
  size?: number | string;
};
type IndicatorDefine = IndicatorObject | IndicatorStyle;
type TreeLineStyle = "none" | "solid";
type TreeBranchIconStyle = "chevron_right" | "expand_more" | "none";
type TreeBranchIconStyleColumnIcon = ColumnIconOption<any>;
type TreeBranchIconStyleDefine = TreeBranchIconStyle | TreeBranchIconStyleColumnIcon | ((args: StylePropertyFunctionArg) => TreeBranchIconStyle) | ((args: StylePropertyFunctionArg) => TreeBranchIconStyleColumnIcon);
//#endregion
//#region src/js/ts-types/column/type.d.ts
interface BaseColumnOption {
  fadeinWhenCallbackInPromise?: boolean | null;
}
interface NumberColumnOption extends BaseColumnOption {
  format?: Intl.NumberFormat;
}
interface ButtonColumnOption extends BaseColumnOption {
  caption?: string;
}
interface MenuColumnOption extends BaseColumnOption {
  options?: ColumnMenuItemOptions;
}
interface IconColumnOption extends BaseColumnOption {
  tagName?: string;
  className?: string;
  content?: string;
  name?: string;
  iconWidth?: number;
}
interface PercentCompleteBarColumnOption extends BaseColumnOption {
  min?: number;
  max?: number;
  formatter?: (value: unknown) => unknown;
}
interface BranchGraphColumnOption extends BaseColumnOption {
  start?: "top" | "bottom";
  cache?: boolean;
}
/** Branches from the branch specified by `branch.from` to the branch specified by `branch.to`. */
type BranchGraphCommandBranch = {
  command: "branch";
  branch: string | {
    from: string;
    to: string;
  };
};
/** Commit the branch specified by `branch`. */
type BranchGraphCommandCommit = {
  command: "commit";
  branch: string;
};
/** Merge the branch specified by `branch.from` into the branch specified by `branch.to`. */
type BranchGraphCommandMerge = {
  command: "merge";
  branch: {
    from: string;
    to: string;
  };
};
/** Creates a tag specified by `tag` from the branch specified by `branch`. */
type BranchGraphCommandTag = {
  command: "tag";
  branch: string;
  tag: string;
};
/** The value to supply to the BranchGraphColumn. */
type BranchGraphCommand = BranchGraphCommandBranch | BranchGraphCommandCommit | BranchGraphCommandMerge | BranchGraphCommandTag;
type BranchGraphCommandValue = BranchGraphCommand | undefined | null | BranchGraphCommand[];
/** The value to supply to the TreeColumn. */
type TreeData = {
  /** The caption of the record */
  caption?: string;
  /** An array of path indicating the hierarchy */
  path: unknown[] | (() => unknown[]);
  nodeType?: "leaf" | "branch";
};
type TreeDataValue = TreeData | unknown[] | undefined | null;
interface TreeColumnOption extends BaseColumnOption {
  cache?: boolean;
}
type ColumnTypeOption = "DEFAULT" | "default" | "NUMBER" | "number" | "CHECK" | "check" | "BUTTON" | "button" | "IMAGE" | "image" | "MULTILINETEXT" | "multilinetext" | "RADIO" | "radio";
type HeaderTypeOption = "DEFAULT" | "default" | "SORT" | "sort" | "CHECK" | "check";
//#endregion
//#region src/js/ts-types/column/style.d.ts
interface ColumnStyle {
  bgColor?: ColorDef;
  visibility?: Visibility;
  indicatorTopLeft?: IndicatorObject;
  indicatorTopRight?: IndicatorObject;
  indicatorBottomRight?: IndicatorObject;
  indicatorBottomLeft?: IndicatorObject;
  doChangeStyle(): void;
  clone(): ColumnStyle;
}
interface BaseStyleOption {
  bgColor?: ColorDef;
  visibility?: Visibility;
  indicatorTopLeft?: IndicatorDefine;
  indicatorTopRight?: IndicatorDefine;
  indicatorBottomRight?: IndicatorDefine;
  indicatorBottomLeft?: IndicatorDefine;
}
interface StdBaseStyleOption extends BaseStyleOption {
  textAlign?: CanvasTextAlign;
  textBaseline?: CanvasTextBaseline;
  padding?: number | string | (number | string)[];
}
interface StdTextBaseStyleOption extends StdBaseStyleOption {
  color?: ColorDef;
  font?: string;
  textOverflow?: TextOverflow;
}
interface StdMultilineTextBaseStyleOption extends StdTextBaseStyleOption {
  lineHeight?: string | number;
  autoWrapText?: boolean;
  lineClamp?: LineClamp;
}
type StyleOption = StdTextBaseStyleOption;
interface HeaderStdStyleOption extends StdMultilineTextBaseStyleOption {
  multiline?: boolean;
}
interface ButtonStyleOption extends StyleOption {
  buttonBgColor?: ColorDef;
}
interface CheckStyleOption extends StdBaseStyleOption {
  uncheckBgColor?: ColorDef;
  checkBgColor?: ColorDef;
  borderColor?: ColorDef;
}
interface RadioStyleOption extends StdBaseStyleOption {
  checkColor?: ColorDef;
  uncheckBorderColor?: ColorDef;
  checkBorderColor?: ColorDef;
  uncheckBgColor?: ColorDef;
  checkBgColor?: ColorDef;
}
interface CheckHeaderStyleOption extends StdTextBaseStyleOption {
  uncheckBgColor?: ColorDef;
  checkBgColor?: ColorDef;
  borderColor?: ColorDef;
}
type NumberStyleOption = StyleOption;
interface MultilineTextStyleOption extends StyleOption {
  lineHeight?: string | number;
  autoWrapText?: boolean;
  lineClamp?: LineClamp;
}
type MultilineTextHeaderStyleOption = StdMultilineTextBaseStyleOption;
interface MenuStyleOption extends StyleOption {
  appearance?: "menulist-button" | "none";
}
interface ImageStyleOption extends StdBaseStyleOption {
  imageSizing?: "keep-aspect-ratio";
  margin?: number;
}
type IconStyleOption = StyleOption;
interface BranchGraphStyleOption extends BaseStyleOption {
  branchColors?: ColorDef | ((name: string, index: number) => ColorDef);
  margin?: number;
  circleSize?: number;
  branchLineWidth?: number;
  mergeStyle?: "straight" | "bezier";
}
interface PercentCompleteBarStyleOption extends StyleOption {
  barColor?: ColorDef | ((num: number) => ColorDef);
  barBgColor?: ColorDef;
  barHeight?: number;
}
interface TreeStyleOption extends StyleOption {
  lineStyle?: TreeLineStyle;
  lineColor?: ColorDef;
  lineWidth?: number;
  treeIcon?: TreeBranchIconStyle | ColumnIconOption<any>;
}
interface SortHeaderStyleOption extends MultilineTextHeaderStyleOption {
  sortArrowColor?: ColorDef;
  multiline?: boolean;
}
type ColumnStyleOption = string | ColumnStyle | BaseStyleOption | StdBaseStyleOption | StyleOption | ButtonStyleOption | CheckStyleOption | NumberStyleOption | MultilineTextStyleOption | MenuStyleOption | ImageStyleOption | IconStyleOption | BranchGraphStyleOption | PercentCompleteBarStyleOption | ((record: any) => string | ColumnStyle | BaseStyleOption | StdBaseStyleOption | StyleOption | ButtonStyleOption | CheckStyleOption | NumberStyleOption | MultilineTextStyleOption | MenuStyleOption | ImageStyleOption | IconStyleOption | BranchGraphStyleOption | PercentCompleteBarStyleOption);
type HeaderStyleOption = ColumnStyle | BaseStyleOption | HeaderStdStyleOption | CheckHeaderStyleOption | MultilineTextHeaderStyleOption | SortHeaderStyleOption | (() => ColumnStyle | BaseStyleOption | HeaderStdStyleOption | CheckHeaderStyleOption | MultilineTextHeaderStyleOption | SortHeaderStyleOption);
//#endregion
//#region src/js/ts-types/column/action.d.ts
type RecordBoolean<T = any> = boolean | ((record: T) => boolean);
interface BaseActionOption {
  disabled?: RecordBoolean;
}
type ActionListener = (record: any, meta: CellAddress & {
  grid: ListGridAPI<any>;
}) => void;
type ActionAreaPredicate = (meta: CellAddress & {
  grid: ListGridAPI<any>;
  /** The mouse position relative to the cell position. */
  pointInCell: {
    x: number;
    y: number;
  };
  /** The mouse position relative to the drawing canvas. */
  pointInDrawingCanvas: {
    x: number;
    y: number;
  };
}) => boolean;
interface AbstractActionOption extends BaseActionOption {
  action?: ActionListener;
}
interface ActionOption extends AbstractActionOption {
  action?: ActionListener;
  /** A function that checks whether the area can be operated with mouse actions. */
  area?: ActionAreaPredicate;
}
interface EditorOption extends BaseActionOption {
  readOnly?: RecordBoolean;
}
interface ButtonActionOption extends AbstractActionOption {
  action?: ActionListener;
}
interface InlineMenuEditorOption<T> extends EditorOption {
  classList?: string | string[];
  options?: ColumnMenuItemOptions | ((record: T | undefined) => ColumnMenuItemOptions);
}
interface InlineInputEditorOption extends EditorOption {
  classList?: string | string[];
  type?: string;
}
type GetValueResult<T, R> = (value: string, info: {
  grid: ListGridAPI<T>;
  col: number;
  row: number;
}) => R;
interface SmallDialogInputEditorOption<T> extends EditorOption {
  classList?: string | string[];
  type?: string;
  helperText?: string | GetValueResult<T, string>;
  inputValidator?: GetValueResult<T, MaybePromise<string>>;
  validator?: GetValueResult<T, MaybePromise<string>>;
}
type GetRadioEditorGroup<T> = (target: {
  grid: ListGridAPI<T>;
  col: number;
  row: number;
}) => CellAddress[];
interface RadioEditorOption<T> extends EditorOption {
  /** @deprecated Use checkAction instead. */
  group?: GetRadioEditorGroup<T>;
  checkAction?: ActionListener;
}
type SortOption<T> = boolean | (string & keyof T) | ((arg: {
  order: "asc" | "desc";
  col: number;
  row: number;
  grid: ListGridAPI<T>;
}) => void);
interface SortHeaderActionOption<T> extends BaseActionOption {
  sort?: SortOption<T>;
}
type ColumnActionOption = "CHECK" | "check" | "INPUT" | "input";
type HeaderActionOption = "CHECK" | "check" | "SORT" | "sort";
declare namespace index_d_exports {
  export { AbstractActionOption, ActionAreaPredicate, ActionListener, ActionOption, AfterSelectedCellEvent, AnyFunction, AnyListener, BaseActionOption, BaseColumnOption, BaseStyleOption, BeforeSelectedCellEvent, BranchGraphColumnOption, BranchGraphCommand, BranchGraphCommandBranch, BranchGraphCommandCommit, BranchGraphCommandMerge, BranchGraphCommandTag, BranchGraphCommandValue, BranchGraphStyleOption, ButtonActionOption, ButtonColumnOption, ButtonStyleOption, CellAddress, CellContext, CellRange, ChangedHeaderValueCellEvent, ChangedValueCellEvent, CheckHeaderStyleOption, CheckStyleOption, ColorDef, ColorPropertyDefine, ColorsPropertyDefine, ColumnActionAPI, ColumnActionOption, ColumnDefine, ColumnIconOption, ColumnMenuItemObjectOptions, ColumnMenuItemOption, ColumnMenuItemOptions, ColumnStyle, ColumnStyleOption, ColumnTypeAPI, ColumnTypeOption, DataSourceAPI, DeleteCellEvent, DrawCellInfo, DrawGridAPI, DrawGridEventHandlersEventMap, DrawGridEventHandlersReturnMap, DrawGridKeyboardMoveCellFunction, DrawGridKeyboardOptions, EditorOption, EventListenerId, FieldAssessor, FieldData, FieldDef, FieldGetter, FieldSetter, FontIcon, FontPropertyDefine, GetRadioEditorGroup, GridCanvasHelperAPI, HeaderActionOption, HeaderStdStyleOption, HeaderStyleOption, HeaderTypeOption, HeaderValues, HeadersDefine, IconColumnOption, IconDefine, IconStyleOption, ImageIcon, ImageStyleOption, IndicatorDefine, IndicatorObject, IndicatorStyle, InlineAPI, InlineInputEditorOption, InlineMenuEditorOption, InputCellEvent, KeyboardEventListener, KeydownEvent, LayoutObjectId, LineClamp, ListGridAPI, ListGridEventHandlersEventMap, ListGridEventHandlersReturnMap, MaybeCall, MaybeCallOrUndef, MaybePromise, MaybePromiseOrCall, MaybePromiseOrCallOrUndef, MaybePromiseOrUndef, MaybeUndef, MenuColumnOption, MenuStyleOption, Message, MessageHandler, MessageObject, ModifyStatusEditableinputCellEvent, MouseCellEvent, MousePointerCellEvent, MultilineTextHeaderStyleOption, MultilineTextStyleOption, NamedIcon, NumberColumnOption, NumberStyleOption, OldSimpleColumnMenuItemOption, OldSortOption, PartialThemeDefine, PasteCellEvent, PasteRangeBoxValues, PasteRejectedValuesEvent, PathIcon, PercentCompleteBarColumnOption, PercentCompleteBarStyleOption, PromiseMaybeCallOrUndef, PromiseMaybeUndef, PromiseMaybeUndefOrCall, PromiseOrUndef, RadioEditorOption, RadioStyleOption, RecordBoolean, RectProps, RequiredThemeDefine, ScrollEvent, SelectedCellEvent, Selection, SetPasteValueTestData, SimpleColumnMenuItemOption, SmallDialogInputEditorOption, SortHeaderActionOption, SortHeaderStyleOption, SortOption, SortState, StdBaseStyleOption, StdMultilineTextBaseStyleOption, StdTextBaseStyleOption, StyleOption, StylePropertyFunctionArg, SvgIcon, TextOverflow, ThemeDefine, TouchCellEvent, TreeBranchIconStyle, TreeBranchIconStyleColumnIcon, TreeBranchIconStyleDefine, TreeColumnOption, TreeData, TreeDataValue, TreeLineStyle, TreeStyleOption, Visibility };
}
//#endregion
//#region src/js/columns/style/StdBaseStyle.d.ts
declare class StdBaseStyle extends BaseStyle {
  private _textAlign;
  private _textBaseline;
  private _padding;
  static get DEFAULT(): StdBaseStyle;
  constructor(style?: StdBaseStyleOption);
  get textAlign(): CanvasTextAlign;
  set textAlign(textAlign: CanvasTextAlign);
  get textBaseline(): CanvasTextBaseline;
  set textBaseline(textBaseline: CanvasTextBaseline);
  get padding(): number | string | (number | string)[] | undefined;
  set padding(padding: number | string | (number | string)[] | undefined);
  clone(): StdBaseStyle;
}
//#endregion
//#region src/js/columns/style/Style.d.ts
declare class Style extends StdBaseStyle {
  private _color?;
  private _font?;
  private _textOverflow;
  static get DEFAULT(): Style;
  constructor(style?: StyleOption);
  get color(): ColorDef | undefined;
  set color(color: ColorDef | undefined);
  get font(): string | undefined;
  set font(font: string | undefined);
  get textOverflow(): TextOverflow;
  set textOverflow(textOverflow: TextOverflow);
  clone(): Style;
}
//#endregion
//#region src/js/columns/style/ButtonStyle.d.ts
declare class ButtonStyle extends Style {
  private _buttonBgColor?;
  static get DEFAULT(): ButtonStyle;
  constructor(style?: ButtonStyleOption);
  get buttonBgColor(): ColorDef | undefined;
  set buttonBgColor(buttonBgColor: ColorDef | undefined);
  clone(): ButtonStyle;
}
//#endregion
//#region src/js/columns/style/CheckStyle.d.ts
declare class CheckStyle extends StdBaseStyle {
  private _uncheckBgColor?;
  private _checkBgColor?;
  private _borderColor?;
  static get DEFAULT(): CheckStyle;
  constructor(style?: CheckStyleOption);
  get uncheckBgColor(): ColorDef | undefined;
  set uncheckBgColor(uncheckBgColor: ColorDef | undefined);
  get checkBgColor(): ColorDef | undefined;
  set checkBgColor(checkBgColor: ColorDef | undefined);
  get borderColor(): ColorDef | undefined;
  set borderColor(borderColor: ColorDef | undefined);
  clone(): CheckStyle;
}
//#endregion
//#region src/js/columns/style/IconStyle.d.ts
declare class IconStyle extends Style {
  static get DEFAULT(): IconStyle;
  constructor(style?: IconStyleOption);
  clone(): IconStyle;
}
//#endregion
//#region src/js/columns/style/ImageStyle.d.ts
declare class ImageStyle extends StdBaseStyle {
  private _imageSizing?;
  private _margin;
  static get DEFAULT(): ImageStyle;
  constructor(style?: ImageStyleOption);
  get imageSizing(): "keep-aspect-ratio" | undefined;
  set imageSizing(imageSizing: "keep-aspect-ratio" | undefined);
  get margin(): number;
  set margin(margin: number);
  clone(): ImageStyle;
}
//#endregion
//#region src/js/columns/style/MenuStyle.d.ts
declare class MenuStyle extends Style {
  private _appearance?;
  static get DEFAULT(): MenuStyle;
  constructor(style?: MenuStyleOption);
  get appearance(): "menulist-button" | "none" | undefined;
  set appearance(appearance: "menulist-button" | "none" | undefined);
  clone(): MenuStyle;
}
//#endregion
//#region src/js/columns/style/MultilineTextStyle.d.ts
declare class MultilineTextStyle extends Style {
  private _lineHeight;
  private _autoWrapText;
  private _lineClamp?;
  static get DEFAULT(): MultilineTextStyle;
  constructor(style?: MultilineTextStyleOption);
  clone(): MultilineTextStyle;
  get lineHeight(): string | number;
  set lineHeight(lineHeight: string | number);
  get lineClamp(): LineClamp | undefined;
  set lineClamp(lineClamp: LineClamp | undefined);
  get autoWrapText(): boolean;
  set autoWrapText(autoWrapText: boolean);
}
//#endregion
//#region src/js/columns/style/NumberStyle.d.ts
declare class NumberStyle extends Style {
  static get DEFAULT(): NumberStyle;
  constructor(style?: NumberStyleOption);
  clone(): NumberStyle;
}
//#endregion
//#region src/js/columns/style/PercentCompleteBarStyle.d.ts
declare class PercentCompleteBarStyle extends Style {
  private _barColor;
  private _barBgColor;
  private _barHeight;
  static get DEFAULT(): PercentCompleteBarStyle;
  constructor(style?: PercentCompleteBarStyleOption);
  get barColor(): ColorDef | ((num: number) => ColorDef);
  set barColor(barColor: ColorDef | ((num: number) => ColorDef));
  get barBgColor(): ColorDef;
  set barBgColor(barBgColor: ColorDef);
  get barHeight(): number;
  set barHeight(barHeight: number);
  clone(): PercentCompleteBarStyle;
}
//#endregion
//#region src/js/columns/style/RadioStyle.d.ts
declare class RadioStyle extends StdBaseStyle {
  private _checkColor?;
  private _uncheckBorderColor?;
  private _checkBorderColor?;
  private _uncheckBgColor?;
  private _checkBgColor?;
  static get DEFAULT(): RadioStyle;
  constructor(style?: RadioStyleOption);
  get checkColor(): ColorDef | undefined;
  set checkColor(checkColor: ColorDef | undefined);
  get uncheckBorderColor(): ColorDef | undefined;
  set uncheckBorderColor(uncheckBorderColor: ColorDef | undefined);
  get checkBorderColor(): ColorDef | undefined;
  set checkBorderColor(checkBorderColor: ColorDef | undefined);
  get uncheckBgColor(): ColorDef | undefined;
  set uncheckBgColor(uncheckBgColor: ColorDef | undefined);
  get checkBgColor(): ColorDef | undefined;
  set checkBgColor(checkBgColor: ColorDef | undefined);
  clone(): RadioStyle;
}
//#endregion
//#region src/js/columns/style/TreeStyle.d.ts
declare class TreeStyle extends Style {
  private _lineStyle?;
  private _lineColor?;
  private _lineWidth?;
  private _treeIcon?;
  static get DEFAULT(): TreeStyle;
  constructor(style?: TreeStyleOption);
  clone(): TreeStyle;
  get lineStyle(): TreeLineStyle | undefined;
  set lineStyle(lineStyle: TreeLineStyle | undefined);
  get lineColor(): ColorDef | undefined;
  set lineColor(lineColor: ColorDef | undefined);
  get lineWidth(): number | undefined;
  set lineWidth(lineWidth: number | undefined);
  get treeIcon(): TreeBranchIconStyle | TreeBranchIconStyleColumnIcon | undefined;
  set treeIcon(treeIcon: TreeBranchIconStyle | TreeBranchIconStyleColumnIcon | undefined);
}
declare namespace style_d_exports$1 {
  export { BaseStyle, BaseStyleOption, ButtonStyle, ButtonStyleOption, CheckStyle, CheckStyleOption, EVENT_TYPE, IconStyle, IconStyleOption, ImageStyle, ImageStyleOption, MenuStyle, MenuStyleOption, MultilineTextStyle, MultilineTextStyleOption, NumberStyle, NumberStyleOption, PercentCompleteBarStyle, PercentCompleteBarStyleOption, RadioStyle, Style, StyleOption, TreeStyle, TreeStyleOption, of$2 as of };
}
declare const EVENT_TYPE: {
  CHANGE_STYLE: "change_style";
};
declare function of$2(columnStyle: ColumnStyleOption | null | undefined, record: any, StyleClassDef?: typeof BaseStyle): BaseStyle;
//#endregion
//#region src/js/columns/style/BranchGraphStyle.d.ts
declare class BranchGraphStyle extends BaseStyle {
  private _branchColors;
  private _margin;
  private _circleSize;
  private _branchLineWidth;
  private _mergeStyle;
  static get DEFAULT(): BranchGraphStyle;
  constructor(style?: BranchGraphStyleOption);
  get branchColors(): ColorDef | ((name: string, index: number) => ColorDef);
  set branchColors(branchColors: ColorDef | ((name: string, index: number) => ColorDef));
  get margin(): number;
  set margin(margin: number);
  get circleSize(): number;
  set circleSize(circleSize: number);
  get branchLineWidth(): number;
  set branchLineWidth(branchLineWidth: number);
  get mergeStyle(): "straight" | "bezier";
  set mergeStyle(mergeStyle: "straight" | "bezier");
  clone(): BranchGraphStyle;
}
//#endregion
//#region src/js/columns/type/BranchGraphColumn.d.ts
/**
 * BranchGraphColumn
 *
 * Data commands
 * - master branch or orphan branch
 *
 * ```js
 * {
 * 	command: 'branch',
 * 	branch: 'branch name A',
 * }
 * ```
 *
 * - commit
 *
 * ```js
 * {
 * 	command: 'commit',
 * 	branch: 'branch name A'
 * }
 * ```
 *
 * - branch
 *
 * ```js
 * {
 * 	command: 'branch',
 * 	branch: {
 * 		from: 'branch name A',
 * 		to: 'branch name B'
 * 	}
 * }
 * ```
 *
 * - merge
 *
 * ```js
 * {
 * 	command: 'merge',
 * 	branch: {
 * 		from: 'branch name B',
 * 		to: 'branch name A'
 * 	}
 * }
 * ```
 *
 * - tag
 *
 * ```js
 * {
 * 	command: 'tag',
 * 	branch: 'branch name A',
 * 	tag: 'tag name'
 * }
 * ```
 *
 * @memberof cheetahGrid.columns.type
 */
declare class BranchGraphColumn<T> extends BaseColumn<T> {
  private _start;
  private _cache;
  constructor(option?: BranchGraphColumnOption);
  get StyleClass(): typeof BranchGraphStyle;
  clearCache(grid: ListGridAPI<T>): void;
  onDrawCell(cellValue: MaybePromise<unknown>, info: DrawCellInfo<T>, context: CellContext, grid: GridInternal<T>): void | Promise<void>;
  clone(): BranchGraphColumn<T>;
  get start(): "top" | "bottom";
  get cache(): boolean;
  drawInternal(_value: unknown, context: CellContext, style: BranchGraphStyle, helper: GridCanvasHelperAPI, grid: GridInternal<T>, {
    drawCellBase
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/Column.d.ts
declare class Column<T> extends BaseColumn<T> {
  get StyleClass(): typeof Style;
  clone(): Column<T>;
  drawInternal(value: unknown, context: CellContext, style: Style, helper: GridCanvasHelperAPI, _grid: ListGridAPI<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/ButtonColumn.d.ts
declare class ButtonColumn<T> extends Column<T> {
  private _caption?;
  constructor(option?: ButtonColumnOption);
  get StyleClass(): typeof ButtonStyle;
  get caption(): string | undefined;
  withCaption(caption: string): ButtonColumn<T>;
  clone(): ButtonColumn<T>;
  convertInternal(value: unknown): unknown;
  getCopyCellValue(value: MaybePromise<unknown>): unknown;
  drawInternal(value: unknown, context: CellContext, style: ButtonStyle, helper: GridCanvasHelperAPI, grid: GridInternal<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/CheckColumn.d.ts
declare class CheckColumn<T> extends BaseColumn<T> {
  get StyleClass(): typeof CheckStyle;
  clone(): CheckColumn<T>;
  convertInternal(value: unknown): boolean;
  drawInternal(value: boolean, context: CellContext, style: CheckStyle, helper: GridCanvasHelperAPI, grid: GridInternal<T>, {
    drawCellBase
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/IconColumn.d.ts
declare class IconColumn<T> extends Column<T> {
  private _tagName;
  private _className?;
  private _content?;
  private _name?;
  private _iconWidth?;
  constructor(option?: IconColumnOption);
  get StyleClass(): typeof IconStyle;
  clone(): IconColumn<T>;
  get tagName(): string;
  get className(): string | undefined;
  get content(): string | undefined;
  get name(): string | undefined;
  get iconWidth(): number | undefined;
  drawInternal(value: unknown, context: CellContext, style: IconStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/ImageColumn.d.ts
declare class ImageColumn<T> extends BaseColumn<T> {
  get StyleClass(): typeof ImageStyle;
  onDrawCell(cellValue: MaybePromise<string>, info: DrawCellInfo<T>, context: CellContext, grid: ListGridAPI<T>): void | Promise<void>;
  clone(): ImageColumn<T>;
  drawInternal(value: HTMLImageElement, context: CellContext, style: ImageStyle, helper: GridCanvasHelperAPI, _grid: ListGridAPI<T>, {
    drawCellBase
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/MenuColumn.d.ts
declare class MenuColumn<T> extends BaseColumn<T> {
  private _options;
  constructor(option?: MenuColumnOption);
  get StyleClass(): typeof MenuStyle;
  clone(): MenuColumn<T>;
  get options(): SimpleColumnMenuItemOption[];
  withOptions(options: ColumnMenuItemOptions): MenuColumn<T>;
  drawInternal(value: unknown, context: CellContext, style: MenuStyle, helper: GridCanvasHelperAPI, _grid: ListGridAPI<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
  convertInternal(value: unknown): unknown;
  _convertInternal(value: unknown): unknown;
  getCopyCellValue(value: unknown): unknown;
}
//#endregion
//#region src/js/columns/type/MultilineTextColumn.d.ts
declare class MultilineTextColumn<T> extends BaseColumn<T> {
  constructor(option?: {});
  get StyleClass(): typeof MultilineTextStyle;
  clone(): MultilineTextColumn<T>;
  drawInternal(value: unknown, context: CellContext, style: MultilineTextStyle, helper: GridCanvasHelperAPI, _grid: ListGridAPI<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/NumberColumn.d.ts
declare class NumberColumn<T> extends Column<T> {
  private _format?;
  static get defaultFormat(): Intl.NumberFormat;
  static set defaultFormat(fmt: Intl.NumberFormat);
  /**
   * @deprecated Use defaultFormat instead
   */
  static get defaultFotmat(): Intl.NumberFormat;
  /**
   * @deprecated Use defaultFormat instead
   */
  static set defaultFotmat(fmt: Intl.NumberFormat);
  constructor(option?: NumberColumnOption);
  get StyleClass(): typeof NumberStyle;
  clone(): NumberColumn<T>;
  get format(): Intl.NumberFormat | undefined;
  withFormat(format: Intl.NumberFormat): NumberColumn<T>;
  convertInternal(value: unknown): string;
}
//#endregion
//#region src/js/columns/type/PercentCompleteBarColumn.d.ts
declare class PercentCompleteBarColumn<T> extends Column<T> {
  private _min;
  private _max;
  private _formatter;
  constructor(option?: PercentCompleteBarColumnOption);
  get StyleClass(): typeof PercentCompleteBarStyle;
  clone(): PercentCompleteBarColumn<T>;
  get min(): number;
  get max(): number;
  get formatter(): (value: unknown) => unknown;
  drawInternal(value: unknown, context: CellContext, style: PercentCompleteBarStyle, helper: GridCanvasHelperAPI, grid: ListGridAPI<T>, info: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/RadioColumn.d.ts
declare class RadioColumn<T> extends BaseColumn<T> {
  get StyleClass(): typeof RadioStyle;
  clone(): RadioColumn<T>;
  convertInternal(value: unknown): boolean;
  drawInternal(value: boolean, context: CellContext, style: RadioStyle, helper: GridCanvasHelperAPI, grid: GridInternal<T>, {
    drawCellBase
  }: DrawCellInfo<T>): void;
}
//#endregion
//#region src/js/columns/type/TreeColumn.d.ts
declare class TreeColumn<T> extends Column<T> {
  private _cache;
  constructor(option?: TreeColumnOption);
  get StyleClass(): typeof TreeStyle;
  clearCache(grid: ListGridAPI<T>): void;
  get drawnIconActionArea(): ActionAreaPredicate;
  onDrawCell(cellValue: MaybePromise<unknown>, info: DrawCellInfo<T>, context: CellContext, grid: GridInternal<T>): void | Promise<void>;
  clone(): TreeColumn<T>;
  get cache(): boolean;
  getCopyCellValue(value: unknown): unknown;
  drawInternal(value: unknown, context: CellContext, style: TreeStyle, helper: GridCanvasHelperAPI, grid: GridInternal<T>, {
    drawCellBase,
    getIcon
  }: DrawCellInfo<T>): void;
}
/**
 * If the cell is a TreeColumn, gets the tree node information from the given cell.
 */
declare namespace type_d_exports$1 {
  export { BaseColumnOption, BranchGraphColumn, BranchGraphColumnOption, ButtonColumn, ButtonColumnOption, CheckColumn, Column, IconColumn, IconColumnOption, ImageColumn, MenuColumn, MenuColumnOption, MultilineTextColumn, NumberColumn, NumberColumnOption, PercentCompleteBarColumn, PercentCompleteBarColumnOption, RadioColumn, TreeColumn, TreeColumnOption, of$1 as of };
}
declare function of$1<T>(columnType: ColumnTypeOption | BaseColumn<T> | null | undefined): BaseColumn<T>;
declare namespace columns_d_exports {
  export { action_d_exports$1 as action, style_d_exports$1 as style, type_d_exports$1 as type };
}
declare namespace core_d_exports {
  export { DrawGrid, DG_EVENT_TYPE as EVENT_TYPE };
}
declare namespace headers_d_exports {
  export { action_d_exports as action, style_d_exports as style, type_d_exports as type };
}
declare namespace register_d_exports {
  export { icon, icons$1 as icons, theme$1 as theme };
}
declare function theme$1(name: string, theme?: Theme): Theme;
declare function icon(name: string, icon?: IconDefine): IconDefine;
declare function icons$1(icons: {
  [key: string]: IconDefine;
}): void;
declare namespace themes_d_exports {
  export { BASIC, MATERIAL_DESIGN, Theme, getChoices, getDefault, of, setDefault, theme };
}
declare const BASIC: Theme;
declare const MATERIAL_DESIGN: Theme;
declare const theme: {
  Theme: typeof Theme;
};
declare function of(value: ThemeDefine | string | undefined | null): Theme | null;
declare function getDefault(): Theme;
declare function setDefault(defaultTheme: Theme): void;
declare function getChoices(): {
  [key: string]: Theme;
};
declare namespace tools_d_exports {
  export { canvashelper_d_exports as canvashelper };
}
//#endregion
//#region src/js/get-internal.d.ts
declare function getInternal(): unknown;
//#endregion
//#region src/js/main.d.ts
/** @private */
declare function getIcons(): {
  [key: string]: IconDefine;
};
declare const _default: {
  core: typeof core_d_exports;
  tools: typeof tools_d_exports;
  ListGrid: typeof ListGrid;
  columns: typeof columns_d_exports;
  headers: typeof headers_d_exports;
  themes: typeof themes_d_exports;
  data: typeof data_d_exports;
  GridCanvasHelper: typeof GridCanvasHelper;
  register: typeof register_d_exports;
  readonly icons: {
    [key: string]: IconDefine;
  };
};
//#endregion
export { type ColumnDefine, GridCanvasHelper, type GroupHeaderDefine, type HeaderDefine, type HeadersDefine, ListGrid, ListGridConstructorOptions, type index_d_exports as TYPES, getInternal as _getInternal, columns_d_exports as columns, core_d_exports as core, data_d_exports as data, _default as default, getIcons, headers_d_exports as headers, register_d_exports as register, themes_d_exports as themes, tools_d_exports as tools };