import type { PoolConnection } from '../../../index.js';
import type { SchemaFix } from '../../diagnosis.js';
import type { Table } from '../../table.js';
import type { Column, ColumnDiagnosis } from '../column.js';
import type { TableDiagnosis } from '../diagnosis.js';
import type { ForeignKey, ForeignKeyDiagnosis } from '../foreign-key.js';
import type { Index, IndexDiagnosis } from '../index.js';
declare abstract class AbstractTableFix {
    readonly parent: SchemaFix;
    readonly table: Table;
    readonly connector: import("../../../index.js").MariaDBConnector<any>;
    constructor(parent: SchemaFix, table: Table);
    abstract get dependencies(): ReadonlyArray<TableFix>;
    prepare(_connection?: PoolConnection): Promise<void>;
    execute(_connection?: PoolConnection): Promise<void>;
    finalize(_connection?: PoolConnection): Promise<void>;
}
export declare class MissingTableFix extends AbstractTableFix {
    readonly dependencies: ReadonlyArray<TableFix>;
    get creatableForeignKeys(): ReadonlyArray<ForeignKey>;
    prepare(connection?: PoolConnection): Promise<void>;
    finalize(connection?: PoolConnection): Promise<void>;
}
declare abstract class AbstractExistingTableFix extends AbstractTableFix {
    readonly diagnosis?: TableDiagnosis | undefined;
    constructor(parent: SchemaFix, table: Table, diagnosis?: TableDiagnosis | undefined);
    /**
     * These foreign-keys will be DROP in order to fix the columns and indexes they're referencing, then re-ADD.
     */
    get existingForeignKeysReferencingInvalidColumnsOrIndexes(): ReadonlyArray<ForeignKey>;
}
export type InvalidTableFixOptions = {
    ignore?: boolean;
    comment?: boolean;
    engine?: boolean;
    collation?: boolean;
    foreignKeys?: boolean | ReadonlyArray<ForeignKey['name']>;
    indexes?: boolean | ReadonlyArray<Index['name']>;
    nullable?: boolean;
    columns?: boolean | ReadonlyArray<Column['name']>;
};
export declare class InvalidTableFix extends AbstractExistingTableFix {
    #private;
    readonly diagnosis: TableDiagnosis;
    readonly ignore: boolean;
    readonly comment: boolean;
    readonly engine: boolean;
    readonly collation: boolean;
    readonly extraForeignKeys: ReadonlyArray<ForeignKey['name']>;
    readonly invalidForeignKeys: ReadonlyArray<ForeignKeyDiagnosis>;
    readonly extraIndexes: ReadonlyArray<Index['name']>;
    readonly missingIndexes: ReadonlyArray<Index>;
    readonly untouchedMissingIndexes: ReadonlyArray<Index>;
    readonly invalidIndexes: ReadonlyArray<IndexDiagnosis>;
    readonly untouchedInvalidIndexes: ReadonlyArray<IndexDiagnosis>;
    readonly nullable: boolean;
    readonly extraColumns: ReadonlyArray<Column['name']>;
    readonly missingColumns: ReadonlyArray<Column>;
    readonly untouchedMissingColumns: ReadonlyArray<Column>;
    readonly invalidColumns: ReadonlyArray<ColumnDiagnosis>;
    readonly untouchedInvalidColumns: ReadonlyArray<ColumnDiagnosis>;
    constructor(parent: SchemaFix, diagnosis: TableDiagnosis, options?: InvalidTableFixOptions);
    get existingForeignKeysReferencingInvalidColumnsOrIndexes(): ReadonlyArray<ForeignKey>;
    get creatableMissingForeignKeys(): ReadonlyArray<ForeignKey>;
    protected get creatableForeignKeys(): ReadonlyArray<ForeignKey>;
    get creatableForeignKeysNotReferencingThisFixableResources(): ReadonlyArray<ForeignKey>;
    get creatableForeignKeysReferencingThisFixableResources(): ReadonlyArray<ForeignKey>;
    get dependencies(): ReadonlyArray<TableFix>;
    prepare(connection?: PoolConnection): Promise<void>;
    execute(connection?: PoolConnection): Promise<void>;
    finalize(connection?: PoolConnection): Promise<void>;
}
export declare class ValidOrUntouchedInvalidTableFix extends AbstractExistingTableFix {
    get dependencies(): ReadonlyArray<TableFix>;
    prepare(connection?: PoolConnection): Promise<void>;
    execute(connection?: PoolConnection): Promise<void>;
}
export type TableFix = MissingTableFix | InvalidTableFix | ValidOrUntouchedInvalidTableFix;
export {};
//# sourceMappingURL=fix.d.ts.map