import { Table } from 'drizzle-orm';

interface RecordedCall {
    sql: string;
    params: unknown[];
    timestamp: number;
}
type MockMatcher = {
    type: "sql-exact";
    sql: string;
    params?: unknown[];
} | {
    type: "sql-starts-with";
    sql: string;
    params?: unknown[];
} | {
    type: "sql-pattern";
    pattern: RegExp;
    params?: unknown[];
} | {
    type: "sql-contains";
    substring: string;
    params?: unknown[];
} | {
    type: "structural";
    operation: string;
    tableName: string;
    tableSchema: string | undefined;
    columnKeys?: string[];
    sqlFragments?: SqlFragment[];
};
interface SqlFragment {
    normalizedSql: string;
    params: unknown[];
}
interface CapturedConfig {
    operation: string;
    tableName: string;
    tableSchema: string | undefined;
    columnKeys: string[];
}
type MockResponse = {
    type: "data";
    data: unknown;
} | {
    type: "function";
    fn: (sql: string, params: unknown[]) => unknown;
};
interface MockHandle {
    mock: {
        calls: [sql: string, params: unknown[]][];
    };
}
interface MockEntry {
    matcher: MockMatcher;
    response: MockResponse;
    responseQueue?: MockResponse[];
    error?: Error;
    once: boolean;
    consumed: boolean;
    handle: MockHandle;
}

declare class MockHandler {
    private mocks;
    private recordedCalls;
    get calls(): RecordedCall[];
    register(entry: MockEntry): void;
    handle(sql: string, params: unknown[], capturedConfig?: CapturedConfig): Promise<unknown>;
    private matches;
    private resolveResponse;
    reset(): void;
    resetCalls(): void;
    resetMocks(): void;
}

interface QueryLike {
    toSQL(): {
        sql: string;
        params: unknown[];
    };
}
declare class MockController<TDb = any> {
    private handler;
    private db;
    private dialect;
    constructor(handler: MockHandler, db: TDb);
    get calls(): RecordedCall[];
    on(callback: (db: TDb) => any): MockBuilder;
    on(queryBuilder: QueryLike): MockBuilder;
    onInsert<TTable extends Table>(table: TTable): MockInsertBuilder<TTable>;
    onUpdate<TTable extends Table>(table: TTable): MockUpdateBuilder<TTable>;
    onDelete(table: Table): MockBuilder;
    onSelect(table: Table): MockBuilder;
    onFindFirst(table: Table): MockBuilder;
    onFindMany(table: Table): MockBuilder;
    private structuralMatcherForTable;
    onSql(pattern: RegExp): MockBuilder;
    onSqlContaining(substring: string): MockBuilder;
    reset(): void;
    resetCalls(): void;
    resetMocks(): void;
}
declare class MockBuilder {
    private handler;
    protected matcher: MockMatcher;
    private dialect;
    private matchParams;
    private isOnce;
    private isPartial;
    private fragments;
    private registeredEntry?;
    constructor(handler: MockHandler, matcher: MockMatcher, dialect: any);
    partial(): this;
    withExactParams(): this;
    containingSql(expr: any): this;
    once(): this;
    handle(): MockHandle;
    respondOnce(data: unknown): this;
    respond(data: unknown): MockHandle;
    respondWith(fn: (sql: string, params: unknown[]) => unknown): MockHandle;
    throw(error: Error): MockHandle;
    private buildMatcher;
}
declare class MockInsertBuilder<TTable extends Table> extends MockBuilder {
    values(value: {
        [K in keyof TTable['$inferInsert']]?: any;
    }): this;
}
declare class MockUpdateBuilder<TTable extends Table> extends MockBuilder {
    set(values: {
        [K in keyof TTable['$inferInsert']]?: any;
    }): this;
}

declare function mockDatabase<TDb>(db: TDb): MockController<TDb>;

declare function anything(): any;
declare function partial<T extends Record<string, unknown>>(values: T): any;

export { type CapturedConfig, MockBuilder, MockController, type MockEntry, type MockHandle, MockInsertBuilder, type MockMatcher, type MockResponse, MockUpdateBuilder, type RecordedCall, anything, mockDatabase, partial };