import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractGroupByArgs, JsonProjectionResult } from "../model-types.js";
import { ContractCacheArgs, ContractCacheInspection, ContractCacheResult, QueryClient } from "../query-client.js";
import { QuerySource } from "../query-source.js";
import { PqsSchemaProfileV1 } from "./pqs-schema-profile.js";
export interface PqsQueryExecutor {
    query(text: string, values: readonly unknown[]): Promise<{
        readonly rows: readonly Record<string, unknown>[];
    }>;
}
export declare class PqsQueryClient implements QueryClient {
    private readonly executor;
    private readonly profile;
    readonly source = QuerySource.pqs;
    readonly contracts: {
        findMany: <TArgs extends ContractFindManyArgs>(args?: TArgs) => Promise<readonly (import("../model-types.js").ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>)[]>;
        findUnique: <TArgs extends ContractFindUniqueArgs>(args: TArgs) => Promise<(import("../model-types.js").ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>) | undefined>;
        count: (args?: ContractCountArgs) => Promise<number>;
        aggregate: (args: Parameters<QueryClient["contracts"]["aggregate"]>[0]) => Promise<{
            readonly count?: number;
            readonly min?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
            readonly max?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
            readonly sum?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
        }>;
        groupBy: (args: ContractGroupByArgs) => Promise<readonly Readonly<Record<string, string | number | boolean | Date | null>>[]>;
    };
    readonly contractTypes: QueryClient["contractTypes"];
    readonly events: QueryClient["events"];
    readonly exercises: QueryClient["exercises"];
    readonly exerciseTypes: QueryClient["exerciseTypes"];
    readonly packages: QueryClient["packages"];
    readonly transactions: QueryClient["transactions"];
    readonly watermark: QueryClient["watermark"];
    private readonly checkReadyAsync;
    private readyPromise?;
    constructor(executor: PqsQueryExecutor, profile: PqsSchemaProfileV1, readiness?: Promise<void> | (() => Promise<void>));
    /**
     * Awaits the readiness check, memoizing success so validation runs once,
     * but clearing the memo on rejection so a transiently unreachable PQS is
     * revalidated on the next query instead of pinning the first failure.
     */
    private ready;
    $queryRaw<TRow>(sql: string, values?: readonly unknown[]): Promise<readonly TRow[]>;
    cacheContracts(_args?: ContractCacheArgs): Promise<ContractCacheResult>;
    invalidateContractsCache(_args?: ContractCacheArgs): Promise<void>;
    inspectContractsCache(_args?: ContractCacheArgs): Promise<ContractCacheInspection | undefined>;
    private createPhysicalDelegate;
    private readPhysicalAsync;
    private countPhysicalAsync;
    private aggregatePhysicalAsync;
    private groupPhysicalAsync;
    private mapPhysicalRow;
    private mapIncludedPhysicalValue;
    private findContractsAsync;
    private countContractsAsync;
    private aggregateContractsAsync;
    private groupContractsAsync;
    private wrap;
}