import { AliasHierarchyVisitor } from "./AliasHierarchyVisitor";
import { MappedDataSource } from "./MappedDataSource";
import { MappedField } from "./MappedField";
import { MappedSingleSourceQueryOperation } from "./MappedSingleSourceQueryOperation";
import { ResolveInfoVisitor } from "./ResolveInfoVisitor";
import { Dict } from "./utils/util-types";
import { MappedAssociation } from "./MappedAssociation";
import { SourceAwareOperationResolver, BaseStoreParams } from "./SourceAwareOperationResolver";
import { SourceAwareResolverContext } from "./SourceAwareResolverContext";
/**
 * @api-category ConfigType
 */
export interface PrimaryRowMapper {
    readonly field: MappedField;
    readonly tablePath: string[];
    readonly columnAlias?: string;
}
/**
 * @api-category ConfigType
 */
export interface PreFetchedRowMapper<TResult, TParent> {
    readonly propertyPath: string[];
    readonly result: Promise<TResult[]>;
    readonly reverseAssociate: (parents: TParent[], results: TResult[]) => void;
}
/**
 * @api-category ConfigType
 */
export interface PostFetchedRowMapper<TResult, TParent> {
    readonly propertyPath: string[];
    readonly run: (parents: TParent[]) => Promise<TResult[]>;
    readonly reverseAssociate: (parents: TParent[], results: TResult[]) => void;
}
export declare type ColumnSelection = {
    [k: string]: string;
}[];
/**
 * @api-category ConfigType
 */
export interface StoreQueryParams<T extends MappedDataSource> extends BaseStoreParams {
    readonly whereParams: Dict;
    readonly columns: ColumnSelection;
    readonly primaryMappers: PrimaryRowMapper[];
    readonly secondaryMappers: {
        readonly preFetched: PreFetchedRowMapper<any, Partial<T["ShallowEntityType"]>>[];
        readonly postFetched: PostFetchedRowMapper<any, Partial<T["ShallowEntityType"]>>[];
    };
}
/**
 * Implements query operation resolution on a single data source
 *
 * @api-category CRUDResolvers
 */
export declare class SingleSourceQueryOperationResolver<TCtx extends SourceAwareResolverContext<TMappedOperation, TSrc, TArgs>, TSrc extends MappedDataSource, TMappedOperation extends MappedSingleSourceQueryOperation<TSrc, TArgs>, TArgs extends {}, TResolved> extends SourceAwareOperationResolver<TCtx, TSrc, TArgs, TResolved> {
    resolverContext: TCtx;
    resultRows?: Dict[];
    aliasColumnsToTableScope: boolean;
    private paginator?;
    constructor(resolverContext: TCtx);
    get aliasHierarchyVisitor(): AliasHierarchyVisitor;
    get storeParams(): StoreQueryParams<TCtx["DataSourceType"]>;
    resolve(): Promise<TResolved>;
    getQueryBuilder(): import("knex").QueryBuilder<any, any>;
    runQuery(): Promise<any>;
    resolveFields<TCurSrc extends MappedDataSource>(tablePath: string[] | undefined, aliasHierarchyVisitor: AliasHierarchyVisitor, dataSource: TCurSrc, resolveInfoVisitor: ResolveInfoVisitor<TCurSrc>, typeName?: string, ignoreMissing?: boolean): void;
    private resolveFieldName;
    private resolveAssociation;
    private deriveJoinedQuery;
    private invokeSideLoader;
    associateResultsWithParents<TCurSrc extends MappedDataSource>(association: MappedAssociation<TCurSrc>): (parents: Dict<any>[], results: Dict<any>[]) => void;
    private deriveColumnsForField;
    get primaryFieldMappers(): PrimaryRowMapper[];
}