import { AsyncEventEmitter, type EventConfigByName } from '@prismamedia/async-event-emitter';
import * as core from '@prismamedia/graphql-platform';
import * as utils from '@prismamedia/graphql-platform-utils';
import * as mariadb from 'mariadb';
import * as semver from 'semver';
import type { Except } from 'type-fest';
import { MariaDBBroker, type MariaDBBrokerOptions } from './broker.js';
import { Schema, type ForeignKeyIndexConfig, type LeafColumnConfig, type ReferenceColumnTreeConfig, type SchemaConfig, type TableConfig, type UniqueIndexConfig } from './schema.js';
import { StatementKind, type Statement } from './statement.js';
export * as mariadb from 'mariadb';
export * from './broker.js';
export * from './escaping.js';
export * from './schema.js';
export * from './statement.js';
export type PoolConnection<TKind extends StatementKind = any> = mariadb.PoolConnection & {
    kind: TKind;
} & AsyncDisposable;
/**
 * @see https://mariadb.com/kb/en/ok_packet/
 */
export type OkPacket = {
    affectedRows: number;
    insertId: bigint;
    warningStatus: number;
};
export type MariaDBConnectorEventDataByName = {
    'executed-statement': {
        statement: Statement;
        result: any;
        durationInSeconds: number;
    };
    'failed-statement': {
        statement: Statement;
        error: mariadb.SqlError;
        durationInSeconds: number;
    };
};
export interface MariaDBConnectorConfig<TRequestContext extends object = any> {
    useCommonTableExpression?: boolean;
    charset?: string;
    collation?: string;
    version?: string;
    schema?: SchemaConfig;
    pool?: Except<mariadb.PoolConfig, 'logger'>;
    on?: EventConfigByName<MariaDBConnectorEventDataByName>;
    broker?: MariaDBBrokerOptions<TRequestContext> | MariaDBBrokerOptions['enabled'];
}
/**
 * @see https://mariadb.com/kb/en/nodejs-connector/
 */
export declare class MariaDBConnector<TRequestContext extends object = any> extends AsyncEventEmitter<MariaDBConnectorEventDataByName> implements core.ConnectorInterface {
    #private;
    readonly gp: core.GraphQLPlatform<TRequestContext>;
    readonly config: MariaDBConnectorConfig<TRequestContext>;
    readonly configPath: utils.Path;
    readonly configOverrides?: {
        [core.ConnectorConfigOverrideKind.NODE]: {
            /**
             * Optional, customize the node's table
             */
            table?: TableConfig;
        };
        [core.ConnectorConfigOverrideKind.FEATURE]: {
            /**
             * Optional, customize the node's table
             */
            table?: Pick<TableConfig, 'indexes'>;
        };
        [core.ConnectorConfigOverrideKind.LEAF]: {
            /**
             * Optional, customize the leaf's column
             */
            column?: LeafColumnConfig;
        };
        [core.ConnectorConfigOverrideKind.EDGE]: {
            /**
             * Optional, customize the edge's columns' name
             */
            columns?: ReferenceColumnTreeConfig;
            /**
             * Optional, customize the edge's foreign-key
             */
            foreignKey?: ForeignKeyIndexConfig;
        };
        [core.ConnectorConfigOverrideKind.UNIQUE_CONSTRAINT]: {
            /**
             * Optional, customize the unique-constraint's index
             */
            index?: UniqueIndexConfig;
        };
    };
    readonly useCommonTableExpression: boolean;
    readonly poolConfig?: Except<mariadb.PoolConfig, 'logger'>;
    readonly poolConfigPath: utils.Path;
    readonly charset: string;
    readonly collation: string;
    readonly version?: semver.SemVer;
    readonly schema: Schema;
    constructor(gp: core.GraphQLPlatform<TRequestContext>, config: MariaDBConnectorConfig<TRequestContext>, configPath?: utils.Path);
    get broker(): MariaDBBroker | undefined;
    getPool(kind?: StatementKind): mariadb.Pool & {
        kind: StatementKind;
    };
    disconnect(): Promise<void>;
    getConnection<TKind extends StatementKind = any>(kind?: TKind): Promise<PoolConnection<TKind>>;
    withConnection<TResult = unknown, TKind extends StatementKind = any>(task: (connection: PoolConnection<TKind>) => Promise<TResult>, kind?: TKind, maybeConnection?: PoolConnection<TKind>): Promise<TResult>;
    withConnectionInTransaction<TResult = unknown, TKind extends StatementKind = any>(task: (connection: PoolConnection<TKind>) => Promise<TResult>, kind?: TKind): Promise<TResult>;
    executeQuery<TResult extends OkPacket | utils.PlainObject[]>(query: string | mariadb.QueryOptions, values?: any, kind?: StatementKind): Promise<TResult>;
    /**
     * Returns the first row, if any
     */
    getRowIfExists<TRow extends utils.PlainObject>(query: string | mariadb.QueryOptions, values?: any, kind?: StatementKind): Promise<TRow | undefined>;
    /**
     * Returns the first row
     */
    getRow<TRow extends utils.PlainObject>(query: string | mariadb.QueryOptions, values?: any, kind?: StatementKind): Promise<TRow>;
    /**
     * Returns the first column of the first row
     */
    getColumn<TValue>(query: string | mariadb.QueryOptions, values?: any, kind?: StatementKind): Promise<TValue>;
    executeStatement<TResult extends OkPacket | utils.PlainObject[]>(statement: Statement, connection?: PoolConnection, path?: utils.Path): Promise<TResult>;
    ensureEventSchedulerIsEnabled(connection?: PoolConnection<StatementKind.DATA_DEFINITION>): Promise<void>;
    /**
     * WARNING: For test-use only!
     *
     * It will DESTROY all the schema's structure & data
     */
    setup(): Promise<void>;
    /**
     * WARNING: For test-use only!
     *
     * It will DESTROY all the schema's structure & data
     */
    teardown(): Promise<void>;
    preMutation(context: core.MutationContext): Promise<void>;
    /**
     * Gets the current mutation's transactional connection
     */
    getConnectionForMutation(context: core.MutationContext): PoolConnection;
    postSuccessfulMutation(context: core.MutationContext): Promise<void>;
    postFailedMutation(context: core.MutationContext, _cause: Error): Promise<void>;
    postMutation(context: core.MutationContext): Promise<void>;
    count(context: core.OperationContext, { node, ...statement }: core.ConnectorCountStatement, path?: utils.Path): Promise<number>;
    find<TValue extends core.NodeSelectedValue>(context: core.OperationContext, { node, ...statement }: core.ConnectorFindStatement<TValue>, path?: utils.Path): Promise<TValue[]>;
    create(context: core.MutationContext, { node, ...statement }: core.ConnectorCreateStatement, path?: utils.Path): Promise<core.NodeValue[]>;
    update(context: core.MutationContext, { node, ...statement }: core.ConnectorUpdateStatement, path?: utils.Path): Promise<number>;
    delete(context: core.MutationContext, { node, ...statement }: core.ConnectorDeleteStatement, path?: utils.Path): Promise<number>;
}
//# sourceMappingURL=index.d.ts.map