import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
import type { LogContext, Logger } from '../logging/Logger.js';
import type { MetadataStorage } from '../metadata/MetadataStorage.js';
import type { ConnectionType, Dictionary, MaybePromise, Primary } from '../typings.js';
import type { Platform } from '../platforms/Platform.js';
import type { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
import type { IsolationLevel } from '../enums.js';
/** Abstract base class for database connections, providing transaction and query execution support. */
export declare abstract class Connection {
    #private;
    protected readonly config: Configuration;
    protected readonly type: ConnectionType;
    protected metadata: MetadataStorage;
    protected platform: Platform;
    protected readonly options: ConnectionOptions;
    protected readonly logger: Logger;
    protected connected: boolean;
    constructor(config: Configuration, options?: ConnectionOptions, type?: ConnectionType);
    /**
     * Establishes connection to database
     */
    abstract connect(options?: {
        skipOnConnect?: boolean;
    }): void | Promise<void>;
    /**
     * Are we connected to the database
     */
    abstract isConnected(): Promise<boolean>;
    /**
     * Are we connected to the database
     */
    abstract checkConnection(): Promise<{
        ok: true;
    } | {
        ok: false;
        reason: string;
        error?: Error;
    }>;
    /**
     * Closes the database connection (aka disconnect)
     */
    close(force?: boolean): Promise<void>;
    /**
     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
     */
    ensureConnection(): Promise<void>;
    /**
     * Execute raw SQL queries, handy from running schema dump loaded from a file.
     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
     */
    executeDump(dump: string): Promise<void>;
    protected onConnect(): Promise<void>;
    /** Executes a callback inside a transaction, committing on success and rolling back on failure. */
    transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
        readOnly?: boolean;
        ctx?: Transaction;
        eventBroadcaster?: TransactionEventBroadcaster;
        loggerContext?: LogContext;
    }): Promise<T>;
    /** Begins a new database transaction and returns the transaction context. */
    begin(options?: {
        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
        readOnly?: boolean;
        ctx?: Transaction;
        eventBroadcaster?: TransactionEventBroadcaster;
        loggerContext?: LogContext;
    }): Promise<Transaction>;
    /** Commits the given transaction. */
    commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
    /** Rolls back the given transaction. */
    rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
    /** Executes a raw query and returns the result. */
    abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
    /** Parses and returns the resolved connection configuration (host, port, user, etc.). */
    getConnectionOptions(): ConnectionConfig;
    /** Sets the metadata storage on this connection. */
    setMetadata(metadata: MetadataStorage): void;
    /** Sets the platform abstraction on this connection. */
    setPlatform(platform: Platform): void;
    /** Returns the platform abstraction for this connection. */
    getPlatform(): Platform;
    protected executeQuery<T>(query: string, cb: () => Promise<T>, context?: LogContext): Promise<T>;
    protected logQuery(query: string, context?: LogContext): void;
}
/** Result of a native database query (insert, update, delete). */
export interface QueryResult<T = {
    id: number;
}> {
    affectedRows: number;
    insertId: Primary<T>;
    row?: Dictionary;
    rows?: Dictionary[];
    insertedIds?: Primary<T>[];
}
/** Resolved database connection parameters. */
export interface ConnectionConfig {
    host?: string;
    port?: number;
    user?: string;
    password?: string | (() => MaybePromise<string>);
    database?: string;
    schema?: string;
}
/** Opaque transaction context type, wrapping the driver-specific transaction object. */
export type Transaction<T = any> = T & {};