import type { ExtraOptions, IdValue, Querier, Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, QuerySelect, QueryUpdateResult, RawRow, RelationKey, Type, UpdatePayload } from '../type/index.js';
import { LoggerWrapper } from '../util/index.js';
/**
 * Base class for all database queriers.
 * It provides a standardized way to execute tasks serially to prevent race conditions on database connections.
 */
export declare abstract class AbstractQuerier implements Querier {
    readonly extra?: ExtraOptions | undefined;
    /**
     * Internal promise used to queue database operations.
     * This ensures that each operation is executed serially, preventing race conditions
     * and ensuring that the database connection is used safely across concurrent calls.
     */
    private taskQueue;
    protected readonly logger: LoggerWrapper;
    constructor(extra?: ExtraOptions | undefined);
    /**
     * Resolves entity from either a separate argument or from $entity field in query.
     * @param entityOrQuery - Entity class or query object with $entity
     * @param maybeQuery - Query object if entity was passed separately
     * @returns Tuple of [entity, query]
     */
    protected resolveEntityAndQuery<E extends object>(entityOrQuery: Type<E> | (QuerySearch<E> & {
        $entity: Type<E>;
    }), maybeQuery?: QuerySearch<E>): [Type<E>, QuerySearch<E>];
    findOneById<E extends object>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>): Promise<E | undefined>;
    /**
     * Find a single record matching the query.
     * Supports both entity-as-argument and entity-as-field patterns.
     */
    findOne<E extends object>(entity: Type<E>, q: QueryOne<E>): Promise<E | undefined>;
    findOne<E extends object>(q: QueryOne<E> & {
        $entity: Type<E>;
    }): Promise<E | undefined>;
    /**
     * Find multiple records matching the query.
     * Supports both entity-as-argument and entity-as-field patterns.
     */
    findMany<E extends object>(entity: Type<E>, q: Query<E>): Promise<E[]>;
    findMany<E extends object>(q: Query<E> & {
        $entity: Type<E>;
    }): Promise<E[]>;
    protected abstract internalFindMany<E extends object>(entity: Type<E>, q: Query<E>): Promise<E[]>;
    /**
     * Find multiple records and return both the records and total count.
     * Supports both entity-as-argument and entity-as-field patterns.
     */
    findManyAndCount<E extends object>(entity: Type<E>, q: Query<E>): Promise<[E[], number]>;
    findManyAndCount<E extends object>(q: Query<E> & {
        $entity: Type<E>;
    }): Promise<[E[], number]>;
    /**
     * Count records matching the query.
     * Supports both entity-as-argument and entity-as-field patterns.
     */
    count<E extends object>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
    count<E extends object>(q: QuerySearch<E> & {
        $entity: Type<E>;
    }): Promise<number>;
    protected abstract internalCount<E extends object>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
    insertOne<E extends object>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
    insertMany<E extends object>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
    protected abstract internalInsertMany<E extends object>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
    updateOneById<E extends object>(entity: Type<E>, id: IdValue<E>, payload: UpdatePayload<E>): Promise<number>;
    updateMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>): Promise<number>;
    protected abstract internalUpdateMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>): Promise<number>;
    abstract upsertOne<E extends object>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
    abstract upsertMany<E extends object>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E[]): Promise<QueryUpdateResult>;
    deleteOneById<E extends object>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions): Promise<number>;
    /**
     * Delete records matching the query.
     * Supports both entity-as-argument and entity-as-field patterns.
     */
    deleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
    deleteMany<E extends object>(q: QuerySearch<E> & {
        $entity: Type<E>;
    }, opts?: QueryOptions): Promise<number>;
    protected abstract internalDeleteMany<E extends object>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
    saveOne<E extends object>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
    saveMany<E extends object>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
    protected fillToManyRelations<E>(entity: Type<E>, payload: E[], select: QuerySelect<E>): Promise<void>;
    protected putChildrenInParents<E>(parents: E[], children: RawRow[], parentIdKey: keyof E & string, referenceKey: string, relKey: keyof E & string): void;
    protected insertRelations<E extends object>(entity: Type<E>, payload: E[]): Promise<void>;
    protected updateRelations<E extends object>(entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>): Promise<void>;
    protected deleteRelations<E extends object>(entity: Type<E>, ids: IdValue<E>[], opts?: QueryOptions): Promise<void>;
    protected saveRelation<E extends object>(entity: Type<E>, payload: E, relKey: RelationKey<E>, isUpdate?: boolean): Promise<void>;
    abstract readonly hasOpenTransaction: boolean;
    transaction<T>(callback: () => Promise<T>): Promise<T>;
    /**
     * Emit a lifecycle hook event for the given entity.
     * Fires global listeners first, then entity-level hooks.
     */
    private emitHook;
    releaseIfFree(): Promise<void>;
    /**
     * Schedules a task to be executed serially in the querier instance.
     * This is used by the @Serialized decorator to protect database-level operations.
     *
     * @param task - The async task to execute.
     * @returns A promise that resolves with the task's result.
     */
    protected serialize<T>(task: () => Promise<T>): Promise<T>;
    abstract beginTransaction(): Promise<void>;
    abstract commitTransaction(): Promise<void>;
    abstract rollbackTransaction(): Promise<void>;
    protected abstract internalRelease(): Promise<void>;
    release(): Promise<void>;
}
//# sourceMappingURL=abstractQuerier.d.ts.map