import { ListTable } from '../ListTable';
import { CellAddress, TableEventHandlersEventArgumentMap } from '@visactor/vtable/es/ts-types';
import { RecordResult, RecordType } from '../const';
import { HistoryEditOptions, WholeRow } from './types';
import { CellEditStyle } from './style';
type TableModifyInfo = ReturnType<HistoryEdit<WholeRow>['getTableModifyInfo']>;
type ModifyRecord = TableEventHandlersEventArgumentMap['change_cell_value'];
type ModifyRecordKeys = keyof ModifyRecord;
type ChangePositionInfo = TableEventHandlersEventArgumentMap['change_header_position'];
declare enum ChangeMode {
    Set = 0,
    Drag = 1,
    Update = 2
}
/**
 * @description 单元格数据管理
 * @date 2024-08-09 09:46:55
 * @class BasicsCellModify
 */
export declare class BasicsCellModify<Row extends WholeRow> {
    tableInstance: ListTable<Row>;
    /** 这个数据和 history 是同一份数据 */
    private readonly record;
    private readonly original;
    /** 数据状态是否为空 */
    private empty;
    /** 单元格数据是否复原 */
    private initial;
    /** 数据变化类型 */
    changeMode: ChangeMode;
    isModifyMark: boolean;
    constructor(record: ModifyRecord, { tableInstance, changeMode, isModifyMark, }: {
        tableInstance: ListTable<Row>;
        isModifyMark: boolean;
        changeMode?: ChangeMode;
    });
    /** 创建一个新的单元格数据 */
    static createCellModifyRecord(param: Partial<ModifyRecord>): ModifyRecord;
    /** 记录类型 */
    get type(): RecordType;
    /** 单元格修改信息 */
    get modify(): Readonly<ModifyRecord>;
    /** 是否为空记录 */
    get isEmpty(): boolean;
    /** 初始状态 */
    get isInitial(): boolean;
    get isInsertion(): boolean;
    /** 全局使用的修改记录，避免调用重置单元格渲染，导致拿不到全局使用的修改记录 */
    get globallyUnique(): any;
    /** 替换记录 */
    private replace;
    /** 添加记录 */
    set(record: ModifyRecord): void;
    setModifyAttr<T extends ModifyRecordKeys>(key: T, value: ModifyRecord[T]): void;
    getModifyAttr<T extends ModifyRecordKeys>(key: T): TableEventHandlersEventArgumentMap;
    /** 移除记录 */
    remove(): void;
    /** 保存修改 */
    saveModify(): void;
    /** 更新单元格渲染 */
    updateCellRender(record: ModifyRecord): void;
    /** 重置单元格渲染 */
    resetCellRender(): void;
    /** 撤回单元格修改*/
    revocation(): void;
    /** 销毁 */
    destroy(): void;
}
type ModifyManageStorageType = 'row' | 'col';
/**
 * @description Table 数据修改管理
 * @date 2024-08-09 09:47:16
 * @class ModifyManage
 */
declare class ModifyManage<Row extends WholeRow> {
    readonly tableInstance: ListTable<Row>;
    readonly isModifyMark: boolean;
    /** 单行 存储的 列 数据 */
    readonly row: Map<number, Map<number, BasicsCellModify<Row>>>;
    /** 单列 存储的 行 数据 */
    readonly col: Map<number, Map<number, BasicsCellModify<Row>>>;
    readonly dataBinding: {
        row: Map<string, Map<number, BasicsCellModify<Row>>>;
        col: Map<string, Map<number, BasicsCellModify<Row>>>;
    };
    readonly basicsCellRecords: Set<BasicsCellModify<Row>>;
    constructor(tableInstance: ListTable<Row>, { isModifyMark }: {
        isModifyMark: boolean;
    });
    set(param: ModifyRecord): this;
    get(): [Row | null, BasicsCellModify<Row>[] | null][];
    delete(param: {
        type: ModifyManageStorageType;
        count: number;
    }): BasicsCellModify<Row>[];
    save(): void;
    /** 历史数据发生变化 */
    historyRecordChange({ recover, update }: {
        recover?: Set<ModifyRecord>;
        update?: Set<ModifyRecord>;
    }): void;
    /** 单元格位置发生变化 */
    positionChange(param: ChangePositionInfo): void;
    /** 获取单元格修改 */
    getModifiedRecord(): BasicsCellModify<Row>[];
    /** 清除记录数据 */
    clear(): void;
    /** 重置单元格数据 */
    resetCellRender(): void;
    /** 销毁记录数据 */
    destroy(): void;
    private generateCellModifyRecord;
    getTableSourceData({ type }: {
        type: Parameters<ModifyManage<Row>['generateCellModifyRecord']>[0]['type'];
    }): {
        data: (string | null)[];
        oppositeData: (string | null)[];
    };
    private getCachePath;
    positionChangeSort({ type }: {
        type: 'row' | 'col';
    }): void;
    /**
     * 因为 VTable 样式绑定单元格行号或者列号，所以排序发生变化后，需要更新样式
     * 旧的单元格有更新标记，排序后的新单元格没有更新标记时，需要为新单元格生成一个为 RecordType.Raw 的修改记录
     */
    private antitheticComplete;
}
declare class BasicsSpecialHistoryEdit<Row extends WholeRow> {
    readonly historyEdit: HistoryEdit<Row>;
    get tableInstance(): ListTable<Row>;
    get modifyManage(): ModifyManage<Row>;
    constructor(param: {
        historyEdit: HistoryEdit<Row>;
    });
}
interface InsertInfo {
    row: number;
    dataList: any[];
}
/**
 * @description 管理动态添加（插入）数据
 * @date 2024-08-09 09:47:40
 * @class InsertRowRecord
 * @implements {InsertInfo}
 */
declare class InsertRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> implements InsertInfo {
    readonly row: number;
    readonly dataList: Row[];
    readonly copyDataMap: Map<Row, Row>;
    /** 当前步骤管理的cell修改 (historyEdit.current) */
    affiliationStack: Set<ModifyRecord> | null;
    protected inserted: boolean;
    /** 全部插入的单元格 */
    readonly cellRecords: Set<TableEventHandlersEventArgumentMap>;
    /** [行数据, Array<单元格>] */
    readonly rowRecordMap: Map<Row, Set<TableEventHandlersEventArgumentMap>>;
    /** 有生成 ChildInsertRowRecord 的单元格 */
    readonly autonomyCells: Set<TableEventHandlersEventArgumentMap>;
    /** 插入数据，第一个的位置 */
    get insertStartRow(): number;
    get IsInserted(): boolean;
    constructor(param: InsertInfo & {
        historyEdit: HistoryEdit<Row>;
        isInitialize?: boolean;
    });
    /** 最新的插入位置（序号会发生变化） */
    getLatestRowNumber(rowData: any): any;
    insert(): void;
    /** 恢复插入行为 */
    recover(): void;
    /** 添加单元格数据 ()*/
    recoverCellData(): void;
    /** 移除插入行为 */
    remove(): void;
    /** 移除单元格数据 返回移除单元格行所在数据的索引 */
    removeCellData(): any[];
    /** 设置插入数据的状态 */
    setInserted(value: boolean): void;
    /** 批量恢复插入行为 */
    static recovers<Row extends WholeRow>({ insertHistory, tableInstance, modifyManage, }: {
        insertHistory: (InsertRowRecord<Row> | ChildInsertRowRecord<Row> | null)[];
        modifyManage: ModifyManage<Row>;
        tableInstance: ListTable<Row>;
    }): void;
    /** 批量移除插入行为 */
    static removes<Row extends WholeRow>({ insertHistory, tableInstance, modifyManage, }: {
        insertHistory: (InsertRowRecord<Row> | ChildInsertRowRecord<Row> | null)[];
        modifyManage: ModifyManage<Row>;
        tableInstance: ListTable<Row>;
    }): void;
    static group<T extends {
        row: number;
    }>(array: T[]): Generator<T[], void, unknown>;
}
declare class ChildInsertRowRecord<Row extends WholeRow> extends InsertRowRecord<Row> {
    parent: InsertRowRecord<Row>;
    constructor(param: InsertInfo & {
        historyEdit: HistoryEdit<Row>;
        parent: InsertRowRecord<Row>;
        appointCellRecords?: {
            row: number;
            originalModifyRecord: Set<ModifyRecord>;
        }[];
    });
    insert(): void;
    /** 删除自我管理，表示可以被其他数据接管 */
    deleteAutonomyCells(): void;
    /** 添加自我管理，表示不可被其他数据接管 */
    addAutonomyCells(): void;
    /** 恢复插入行为 */
    recover(): void;
    /** 移除插入行为 */
    remove(): void;
}
declare class DeleteRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> {
    insertMap: Map<InsertRowRecord<Row>, {
        deleteInfos: Record<number, Set<ModifyRecord>>;
        deleteCellSize: number;
    }>;
    /** 实际需要执行删除的 插入对象 */
    needDelete: InsertRowRecord<Row>[];
    /** 额外删除的单元格 */
    needDeleteStyleCells: ModifyRecord[];
    deleted: boolean;
    constructor(param: {
        historyEdit: HistoryEdit<Row>;
        rows: number[];
        needDeleteStyleCells?: ModifyRecord[];
    });
    delete(): void;
    /** 初始化插入实例集合 */
    initializeExpurgated(): void;
    /** 恢复删除行为 */
    recover(): void;
    /** 移除删除行为 */
    remove(): void;
}
/**
 * @description 直接删除行数
 * @date 2024-08-13 17:04:17
 * @class DeleteDirectRow
 * @extends {DeleteRowRecord}
 */
declare class DirectDeleteRowRecord<Row extends WholeRow> extends DeleteRowRecord<Row> {
    dataList: {
        row: number;
        data: Row;
    }[];
    readonly copyDataMap: Map<Row, Row>;
    readonly deletedIndex: Map<Row, number>;
    constructor(param: {
        dataList: {
            row: number;
            data: Row;
        }[];
        historyEdit: HistoryEdit<Row>;
    });
    delete(): void;
    /** 恢复删除行为 */
    recover(): void;
    /** 移除删除行为 */
    remove(): void;
}
type SortChangeInfo = TableEventHandlersEventArgumentMap['change_header_position'];
declare class SortedRowRecord<Row extends WholeRow> extends BasicsSpecialHistoryEdit<Row> implements SortChangeInfo {
    readonly event: Event;
    readonly source: CellAddress;
    readonly target: CellAddress;
    sorted: boolean;
    constructor(param: {
        historyEdit: HistoryEdit<Row>;
    } & SortChangeInfo);
    private updateCellContent;
    /** 恢复排序行为 */
    recover(): void;
    /** 移除排序行为 */
    remove(): void;
    get isSortCol(): boolean;
    get isSortRow(): boolean;
    get isSortNoChange(): boolean;
}
interface OtherHistory<Row extends WholeRow> {
    sortHistory: (null | SortedRowRecord<Row>)[];
    insertHistory: (null | InsertRowRecord<Row>)[];
    deleteHistory: (null | DeleteRowRecord<Row> | DirectDeleteRowRecord<Row>)[];
}
interface HistoryGather<Row extends WholeRow> extends OtherHistory<Row> {
    history: Set<ModifyRecord>[];
}
type GatherStorage<Row extends WholeRow> = {
    [P in keyof HistoryGather<Row>]?: HistoryGather<Row>[P][0];
};
/**
 * @description 历史数据栈处理基础类
 * @date 2024-08-09 09:48:52
 * @class BasicsHistoryStack
 */
declare class BasicsHistoryStack<Row extends WholeRow> {
    current: Set<ModifyRecord> | null;
    readonly gather: Readonly<HistoryGather<Row>>;
    get history(): Set<TableEventHandlersEventArgumentMap>[];
    getStorage(): GatherStorage<Row>;
    forEach(fn: (key: keyof HistoryGather<Row>) => void): void;
    /** 创建历史记录区块 */
    createHistory(): void;
    /** 创建历史数据失败 */
    createHistoryError(lastHistoryItem: HistoryGather<Row>['history'][0] | null): void;
    historyClear(): void;
}
/**
 * @description 历史修改
 * @date 2024-08-09 09:50:19
 * @export
 * @class HistoryEdit
 * @extends {BasicsHistoryStack}
 */
export declare class HistoryEdit<Row extends WholeRow> extends BasicsHistoryStack<Row> {
    static RecordResult: typeof RecordResult;
    current: Set<ModifyRecord> | null;
    readonly eventIds: number[];
    readonly tableInstance: ListTable<Row>;
    readonly cellEditStyle: CellEditStyle<Row>;
    readonly options?: HistoryEditOptions;
    /** 手动记录中 */
    private manualRecording;
    /** 自动记录 */
    private autoRecording;
    /** 自动记录结束后的结果 */
    private autoRecordEnd;
    /** 初始数据映射 */
    private readonly originalRecords;
    modifyManage: ModifyManage<Row>;
    constructor({ tableInstance, options }: {
        tableInstance: ListTable<Row>;
        options?: HistoryEditOptions;
    });
    get isModifyMark(): boolean;
    setRecords(records: typeof this.tableInstance.records): void;
    /** 记录修改 */
    recording(fn: (param: {
        recordOperation: <T extends keyof OtherHistory<Row>>(key: T, value: OtherHistory<Row>[T][0]) => void;
    }) => RecordResult | void, extra?: {
        isUpdateStyles?: boolean;
    }): void;
    autoRecordChangeValue(args: ModifyRecord): void;
    private switchHistory;
    insertData({ row, dataList }: InsertInfo): void;
    deleteData(param: {
        row: number;
        data: any;
    }[]): void;
    /** 前进 */
    forward(): Set<TableEventHandlersEventArgumentMap> | null;
    /** 后退 */
    backward(): Set<TableEventHandlersEventArgumentMap> | null;
    /** 取消 */
    cancel(): void;
    /** 保存 */
    save(course: (saveData: TableModifyInfo) => Promise<this['tableInstance']['records'] | void>): Promise<void>;
    /** 清除事件 */
    clearEvents(): void;
    /** 清除历史记录 */
    clear(): void;
    /** 获取修改的记录 */
    private getModifiedRecord;
    private modifyMarkAmend;
    getTableModifyInfo(): {
        updateRecords: {
            recordIdx: number;
            id: string;
            data: Partial<Row>;
        }[];
        deleteRecords: string[];
        createRecords: {
            recordIdx: number;
            id: string;
            data: Partial<Row>;
        }[];
        sortedRecords: {
            oldIndex: number;
            index: number;
        }[];
    };
    private updateTableStyle;
}
export { RecordType };