import type { NamedBean } from '../context/bean';
import { BeanStub } from '../context/beanStub';
import type { AgColumn } from '../entities/agColumn';
import type { AgEventType } from '../eventTypes';
import type { CellFocusedEvent } from '../events';
import type { CellRange } from '../interfaces/IRangeService';
import type { EditingCellPosition, ICellEditorParams } from '../interfaces/iCellEditor';
import type { Column } from '../interfaces/iColumn';
import type { EditMap } from '../interfaces/iEditModelService';
import type { CellValueResolveFrom, EditNavOnValidationResult, EditPosition, EditSource, IsEditingParams, StartEditParams, StopEditParams, _SetEditingCellsParams } from '../interfaces/iEditService';
import type { IRowNode } from '../interfaces/iRowNode';
import type { UserCompDetails } from '../interfaces/iUserCompDetails';
import { CellCtrl } from '../rendering/cell/cellCtrl';
import type { RowCtrl } from '../rendering/row/rowCtrl';
import { PopupEditorWrapper } from './cellEditors/popupEditorWrapper';
type BatchPrepDetails = {
    compDetails?: UserCompDetails;
    valueToDisplay?: any;
};
export declare class EditService extends BeanStub implements NamedBean {
    beanName: "editSvc";
    committing: boolean;
    private csrm;
    private batch;
    private batchStartDispatched;
    private model;
    private valueSvc;
    private rangeSvc;
    private strategy?;
    private stopping;
    private rangeSelectionWhileEditing;
    /**
     * Whether the last stop was rejected by block mode holding an invalid value. `res === false` can't
     * stand in for this: a consumed mid-batch key also reports false but is a real stop that must still
     * navigate and must still be able to end the batch.
     */
    private stopBlockRejected;
    /** Memo for hasConfiguredValidation, keyed on colModel.colDefsVersion. -1 never matches a real version. */
    private validationConfigVersion;
    private validationConfigResult;
    /** Memo for editorsRequireValidation; undefined means "not scanned yet". */
    private editorsValidation;
    /** Cell whose editor takes focus as it attaches, and whether the cell itself must be focused first. */
    private pendingEditorFocus;
    private pendingEditorFocusCell;
    private bulkWriteDepth;
    private bulkWriteTouched;
    postConstruct(): void;
    isBatchEditing(): boolean;
    startBatchEditing(): void;
    stopBatchEditing(params?: StopEditParams): void;
    /**
     * Closes a batch's open editors, staging their values, without ending the batch. Block mode holds
     * instead: an invalid edit keeps its editor open so it can be corrected, as on every other stop path.
     */
    stopBatchEditors(cancel: boolean): void;
    /** Lazily dispatch batchEditingStarted when the first write or editor open occurs during a batch session. */
    private ensureBatchStarted;
    private createStrategy;
    private destroyStrategy;
    shouldStartEditing(position: Required<EditPosition>, event?: KeyboardEvent | MouseEvent | null, cellStartedEdit?: boolean | null, source?: EditSource): boolean;
    shouldStopEditing(position?: EditPosition, event?: KeyboardEvent | MouseEvent | null | undefined, source?: EditSource): boolean | null;
    shouldCancelEditing(position?: EditPosition, event?: KeyboardEvent | MouseEvent | null | undefined, source?: EditSource): boolean | null;
    isEditing(position?: EditPosition | null, params?: IsEditingParams): boolean;
    isRowEditing(rowNode?: IRowNode, params?: IsEditingParams): boolean;
    enableRangeSelectionWhileEditing(): void;
    disableRangeSelectionWhileEditing(): void;
    isRangeSelectionEnabledWhileEditing(): boolean;
    /** @returns whether to prevent default on event */
    startEditing(position: Required<EditPosition>, params: StartEditParams): void;
    stopEditing(position?: EditPosition, params?: StopEditParams): boolean;
    private prepareStopContext;
    private processStopRequest;
    private handleStopOrCancel;
    private shouldHandleMidBatchKey;
    private handleMidBatchKey;
    private finishStopEditing;
    /** Dispatch batchEditingStopped if batchEditingStarted was (or should have been) dispatched. */
    private dispatchBatchStopped;
    private clearValidationIfNoOpenEditors;
    private navigateAfterEdit;
    /**
     * Reverts each invalid cell to its previous pending value, so a revert-mode batch commit still
     * writes an earlier valid edit and drops cells that never held one. A row error invalidates the row.
     */
    private revertInvalidEdits;
    /** Closes one cell's editor while its row keeps editing, so the edit and its pending value survive. */
    closeCellEditor(position: Required<EditPosition>): void;
    /**
     * Drops a cell's in-flight editor attempt, keeping any earlier pending value (per-cell Escape
     * semantics), leaving any surrounding row or batch edit untouched. Callers that must revert one
     * cell without a key event go through here.
     */
    revertCellEdit(position: Required<EditPosition>): void;
    private processEdits;
    /**
     * Commits a value to the row node's data via `rowNode.setDataValue`.
     *
     * This is a low-level helper that only writes to data; it does NOT update the
     * edit model. Callers are responsible for any model reconciliation — see
     * `syncEditAfterCommit` for the non-batch case and `processEdits` for the
     * batch-finalisation case (where edits are removed immediately after commit).
     */
    private setNodeDataValue;
    /**
     * Syncs the edit model after a non-batch commit so sourceValue never becomes stale.
     * On success, re-reads the actual committed value from data (via getValue) because
     * a custom valueSetter may transform or store it differently than the passed value.
     * On failure, reverts the pending edit back to sourceValue.
     *
     * Skipped when an editor is open (state === 'editing'), because the upcoming
     * stopEditing flow will call _syncFromEditors which reads from the editor widget;
     * updating sourceValue here would cause that flow to re-commit stale editor content.
     *
     * NOTE: The re-read via `getValue` happens after `setNodeDataValue` has dispatched
     * `cellValueChanged`. If a `cellValueChanged` listener synchronously mutates the
     * same data field, the re-read will pick up that mutation. This is acceptable because
     * the listener intentionally transformed the value and the model should track the
     * actual committed state.
     */
    private syncEditAfterCommit;
    setEditMap(edits: EditMap, params?: _SetEditingCellsParams): void;
    private dispatchEditValuesChanged;
    beginBulkWrite(): void;
    endBulkWrite(): void;
    private flushBulkWrite;
    private bulkRefreshCell;
    private bulkRefreshMap;
    private refCell;
    stopAllEditing(cancel?: boolean, source?: 'api' | 'ui'): void;
    isCellEditable(position: Required<EditPosition>, source?: 'api' | 'ui'): boolean;
    /**
     * Whether anything can report a validation error: a configured rule, or an open editor that validates
     * itself. Both halves are memoised — every probe would otherwise rescan the colDefs and the cell ctrls.
     */
    hasValidationRules(): boolean;
    /** Configured validation: a row-level callback or a colDef rule, so it changes only with the colDefs. */
    private hasConfiguredValidation;
    /** Editor-supplied validation: the scan materialises every rendered cell ctrl, hence the memo. */
    private editorsRequireValidation;
    /** Called wherever an editor comes or goes: created, attached (React mounts late) or gone with its cell. */
    invalidateEditorsValidation(): void;
    /** Rows whose edits were purged without a stop: the strategy still holds them, so let it release. */
    releasePurgedRows(rowNodes: Set<IRowNode>): void;
    /** Ends a row's edits as it is torn down; its position can never be reached again. */
    releaseRowEdits(rowNode: IRowNode): void;
    /** Ends edits on every column dropping out of colsList, destroyed or merely parked. */
    releaseColumnsLeaving(newCols: AgColumn[]): void;
    cellEditingInvalidCommitBlocks(): boolean;
    checkNavWithValidation(position?: EditPosition, event?: Event | CellFocusedEvent, focus?: boolean): EditNavOnValidationResult;
    /** Calls through to standalone method for treeshaking via the editService */
    populateModelValidationErrors(): void;
    /**
     * A cell component has attached: opens its editor if the cell is (or is starting) editing.
     * @returns whether the cell is editing, so the caller renders its value only when it is not.
     */
    onCompAttached(cellCtrl: CellCtrl, startEdit?: boolean): boolean;
    /** Replays a start that was waiting for a component — React mounts one a turn late. Called after the
     *  cell has rendered, so the editor takes over a cell that is already showing its value. */
    replayPendingStart(cellCtrl: CellCtrl): void;
    /** A cell leaving takes its validation, and the focus it was owed, with it. */
    onCellDestroyed(cellCtrl: CellCtrl): void;
    /** Focus can only be in one place, so a later request replaces an earlier one. */
    focusEditorOnAttach(cellCtrl: CellCtrl, focusCell: boolean): void;
    /** An editor has attached to its cell — both view layers route here once the editor is live. */
    onEditorAttached(cellCtrl: CellCtrl): void;
    /** Calls through to standalone method for treeshaking via the editService */
    onPopupEditorClosed(cellCtrl: CellCtrl, event?: MouseEvent | TouchEvent | KeyboardEvent): void;
    revertSingleCellEdit(cellPosition: Required<EditPosition>, focus?: boolean): void;
    /**
     * Brings the validation state up to date, then reports it. Not a plain query: use the model's
     * {@link EditModelService.hasValidationErrors} when the state is known to be current.
     */
    revalidateAndCheck(position?: EditPosition): boolean;
    /** The read half of {@link revalidateAndCheck}, for a caller that has just revalidated. */
    checkValidated(position?: EditPosition): boolean;
    moveToNextCell(prev: CellCtrl | RowCtrl, backwards: boolean, event?: KeyboardEvent, source?: 'api' | 'ui'): boolean | null;
    /**
     * Gets the pending edit value for a cell (used by ValueService).
     * Returns undefined to fallback to committed data/valueGetter.
     */
    getPendingEditValue(rowNode: IRowNode, column: Column, from: Exclude<CellValueResolveFrom, 'data'>): any;
    getCellDataValue(position: Required<EditPosition>): any;
    addStopEditingWhenGridLosesFocus(viewports: HTMLElement[]): void;
    createPopupEditorWrapper(params: ICellEditorParams): PopupEditorWrapper;
    batchResetToSourceValue(position: Required<EditPosition>): boolean;
    /**
     * Applies a data value change to a cell, handling batch editing, undo/redo, paste, and range operations.
     */
    setDataValue(position: Required<EditPosition>, newValue: any, eventSource?: string): boolean | undefined;
    /** Handles setDataValue when an edit already exists for the cell. */
    private applyExistingEdit;
    /**
     * Pushes a value into an open cell editor without closing it or committing.
     * Updates editorValue and pendingValue in the edit model, then refreshes the editor DOM.
     * Returns true if an editor was open and updated, false otherwise.
     */
    private applyEditorValue;
    /** editApi or undoRedoApi apply change without involving the editor. */
    private applyDirectValue;
    handleColDefChanged(cellCtrl: CellCtrl): void;
    destroy(): void;
    prepDetailsDuringBatch(position: Required<EditPosition>, params: BatchPrepDetails): BatchPrepDetails | undefined;
    cleanupEditors(): void;
    dispatchCellEvent<T extends AgEventType>(position: Required<EditPosition>, event?: Event | null, type?: T, payload?: any): void;
    dispatchBatchEvent(type: 'batchEditingStarted' | 'batchEditingStopped', edits: EditMap): void;
    private toEventChangeList;
    applyBulkEdit({ rowNode, column }: Required<EditPosition>, ranges: CellRange[]): void;
    applyCellEditStyles(cellCtrl: CellCtrl): void;
    applyRowEditStyles(rowCtrl: RowCtrl): void;
    setEditingCells(cells: EditingCellPosition[], params?: _SetEditingCellsParams): void;
    onCellFocused(event: CellFocusedEvent): void;
    allowedFocusTargetOnValidation(cellPosition: EditPosition): CellCtrl | undefined;
}
export {};