import { DynamicModule } from '@omnitron-dev/titan/nexus';
import { Kysely, Transaction } from 'kysely';
import { DatabaseManager } from '@omnitron-dev/titan-database';
import { MigrationRunner } from '@omnitron-dev/titan-database';
import { type CleanupStrategy, type IsolationLevel } from '@kysera/testing';
export declare const DATABASE_TESTING_SERVICE: unique symbol;
import type { DatabaseModuleOptions } from '@omnitron-dev/titan-database';
export interface DatabaseTestingOptions extends Partial<DatabaseModuleOptions> {
    transactional?: boolean;
    autoMigrate?: boolean;
    autoSeed?: boolean;
    seeds?: any[] | (() => Promise<void>);
    autoClean?: boolean;
    preserveTables?: string[];
    isolatedSchema?: boolean;
    schemaPrefix?: string;
    verbose?: boolean;
}
export declare class DatabaseTestingService {
    private manager;
    private options;
    private migrationRunner?;
    private transactionManager?;
    private currentTransaction?;
    private schemaName?;
    private isInitialized;
    constructor(manager: DatabaseManager, options: DatabaseTestingOptions, migrationRunner?: MigrationRunner | undefined, transactionManager?: unknown | undefined);
    initialize(): Promise<void>;
    beforeEach(): Promise<void>;
    afterEach(): Promise<void>;
    afterAll(): Promise<void>;
    cleanDatabase(): Promise<void>;
    seedDatabase(seeds?: Array<{
        table: string;
        data: unknown;
    }>): Promise<void>;
    private convertBooleansForSqlite;
    private insertSeeds;
    private createIsolatedSchema;
    private dropIsolatedSchema;
    private getAllTables;
    private getDialect;
    createSavepoint(name: string): Promise<void>;
    rollbackToSavepoint(name: string): Promise<void>;
    execute<T>(query: (db: Kysely<Record<string, unknown>>) => Promise<T>): Promise<T>;
    getTestConnection(): Promise<Kysely<Record<string, unknown>> | Transaction<unknown>>;
    factory<T extends Record<string, unknown>>(table: string, generator: () => Partial<T> | Promise<Partial<T>>, count?: number): Promise<T[]>;
    assertDatabaseHas(table: string, data: Record<string, unknown>): Promise<boolean>;
    assertDatabaseMissing(table: string, data: Record<string, unknown>): Promise<boolean>;
    assertDatabaseCount(table: string, count: number): Promise<boolean>;
    runInTransaction<T>(fn: (trx: Transaction<unknown>) => Promise<T>): Promise<void>;
    runWithSavepoints<T>(fn: (trx: Transaction<unknown>) => Promise<T>): Promise<void>;
    runWithIsolation<T>(isolationLevel: IsolationLevel, fn: (trx: Transaction<unknown>) => Promise<T>): Promise<void>;
    cleanWithKysera(strategy?: CleanupStrategy, tables?: string[]): Promise<void>;
    seedWithKysera(fn: (trx: Transaction<unknown>) => Promise<void>): Promise<void>;
    snapshotTable<T = unknown>(table: string): Promise<T[]>;
    countTableRows(table: string): Promise<number>;
    waitForCondition(condition: () => Promise<boolean> | boolean, options?: {
        timeout?: number;
        interval?: number;
        timeoutMessage?: string;
    }): Promise<void>;
    createDataFactory<T extends Record<string, unknown>>(defaults: {
        [K in keyof T]: T[K] | (() => T[K]);
    }): (overrides?: Partial<T>) => T;
    createManyFromFactory<T extends Record<string, unknown>>(table: string, factory: (overrides?: Partial<T>) => T, count: number, overrides?: Partial<T>): Promise<T[]>;
}
export declare class DatabaseTestingModule {
    static forTest(options?: DatabaseTestingOptions): DynamicModule;
    static createIsolatedModule(options?: DatabaseTestingOptions): Promise<{
        module: DynamicModule;
        service?: DatabaseTestingService;
        cleanup: () => Promise<void>;
    }>;
    static injectServiceIntoIsolatedModule(isolatedModuleResult: {
        module: DynamicModule;
        service?: DatabaseTestingService;
        cleanup: () => Promise<void>;
    }, container: {
        resolveAsync: (token: any) => Promise<any>;
    }): Promise<void>;
}