import * as fp_ts_lib_Either from 'fp-ts/lib/Either';
import postgres from 'postgres';
import { R as RuleOptionConnection, a as ConnectionTarget } from '../shared/eslint-plugin.D35Y7FT8.js';
import 'zod';

declare class DuplicateColumnsError extends Error {
    _tag: "DuplicateColumnsError";
    columns: string[];
    queryText: string;
    position: number;
    sourcemaps: QuerySourceMapEntry$1[];
    constructor(params: {
        columns: string[];
        queryText: string;
        position: number;
        sourcemaps: QuerySourceMapEntry$1[];
    });
    static of(params: {
        columns: string[];
        queryText: string;
        position: number;
        sourcemaps: QuerySourceMapEntry$1[];
    }): DuplicateColumnsError;
    toJSON(): {
        _tag: "DuplicateColumnsError";
        message: string;
        columns: string[];
        queryText: string;
        position: number;
        sourcemaps: QuerySourceMapEntry$1[];
    };
}
interface QuerySourceMapEntry$1 {
    original: {
        start: number;
        end: number;
        text: string;
    };
    generated: {
        start: number;
        end: number;
        text: string;
    };
    offset: number;
}
declare class PostgresError extends Error {
    _tag: "PostgresError";
    queryText: string;
    message: string;
    line: string;
    position: number;
    sourcemaps: QuerySourceMapEntry$1[];
    constructor(params: {
        queryText: string;
        message: string;
        line: string;
        position: number | string;
        sourcemaps: QuerySourceMapEntry$1[];
    });
    static of(params: {
        queryText: string;
        message: string;
        line: string;
        position: number | string;
        sourcemaps: QuerySourceMapEntry$1[];
    }): PostgresError;
    static to(query: string, error: unknown, sourcemaps: QuerySourceMapEntry$1[]): PostgresError;
    toJSON(): {
        _tag: "PostgresError";
        queryText: string;
        message: string;
        line: string;
        position: number;
        sourcemaps: QuerySourceMapEntry$1[];
    };
}
type ResolvedTarget = {
    kind: "type";
    value: string;
    type: string;
    base?: string;
} | {
    kind: "literal";
    value: string;
    base: ResolvedTarget;
} | {
    kind: "union";
    value: ResolvedTarget[];
} | {
    kind: "array";
    value: ResolvedTarget;
    syntax?: "array-type" | "type-reference";
} | {
    kind: "object";
    value: ResolvedTargetEntry[];
};
type ResolvedTargetEntry = [string, ResolvedTarget];
type GenerateResult = {
    output: Extract<ResolvedTarget, {
        kind: "object";
    }> | null;
    unknownColumns: string[];
    stmt: postgres.Statement;
    query: {
        text: string;
        sourcemaps: QuerySourceMapEntry$1[];
    };
};
type GenerateError = DuplicateColumnsError | PostgresError;

declare class DatabaseInitializationError extends Error {
    _tag: "DatabaseInitializationError";
    constructor(message: string);
    static of(pgError: string): DatabaseInitializationError;
    static to(error: unknown): DatabaseInitializationError;
    toJSON(): {
        _tag: "DatabaseInitializationError";
        message: string;
    };
}
declare class InvalidMigrationsPathError extends Error {
    _tag: "InvalidMigrationsPathError";
    migrationsPath: string;
    constructor(migrationsPath: string, message: string);
    static of(filePath: string, pgError: string): InvalidMigrationsPathError;
    static fromErrorC(migrationsPath: string): (error: Error) => InvalidMigrationsPathError;
    toJSON(): {
        _tag: "InvalidMigrationsPathError";
        migrationsPath: string;
        message: string;
    };
}
declare class InvalidMigrationError extends Error {
    _tag: "InvalidMigrationError";
    filePath: string;
    constructor(filePath: string, message: string);
    static of(filePath: string, pgError: string): InvalidMigrationError;
    static fromErrorC(migrationsPath: string): (error: Error) => InvalidMigrationError;
    toJSON(): {
        _tag: "InvalidMigrationError";
        filePath: string;
        message: string;
    };
}
declare class InternalError extends Error {
    _tag: "InternalError";
    constructor(error: string);
    static of(error: string): InternalError;
    static to(error: unknown): InternalError;
    toJSON(): {
        _tag: "InternalError";
        stack: string | undefined;
        message: string;
    };
}
declare class PluginError extends Error {
    _tag: "PluginError";
    constructor(pluginName: string, error: string);
    static from(pluginName: string): (error: unknown) => PluginError;
    toJSON(): {
        _tag: "PluginError";
        message: string;
    };
}
interface QuerySourceMapEntry {
    original: {
        start: number;
        end: number;
        text: string;
    };
    generated: {
        start: number;
        end: number;
        text: string;
    };
    offset: number;
}

interface CheckSQLWorkerParams {
    connection: RuleOptionConnection;
    target: ConnectionTarget;
    query: {
        text: string;
        sourcemaps: QuerySourceMapEntry[];
    };
    projectDir: string;
}
type CheckSQLWorkerHandler = typeof handler;
declare function handler(params: CheckSQLWorkerParams): Promise<fp_ts_lib_Either.Either<unknown, string>>;
type WorkerError = InvalidMigrationsPathError | InvalidMigrationError | InternalError | PluginError | DatabaseInitializationError | GenerateError;
type WorkerResult = GenerateResult;

export { handler };
export type { CheckSQLWorkerHandler, CheckSQLWorkerParams, WorkerError, WorkerResult };