import * as t from "io-ts";
import { MappedAssociation } from "./MappedAssociation";
import { MappedDataSource } from "./MappedDataSource";
import { MappedSingleSourceOperation } from "./MappedSingleSourceOperation";
import { MappedSingleSourceQueryOperation } from "./MappedSingleSourceQueryOperation";
import { SingleSourceQueryOperationResolver } from "./SingleSourceQueryOperationResolver";
import { PaginationConfig } from "./PaginationConfig";
import { JoinBuilder } from "./utils/JoinBuilder";
import { PartialDeep } from "./utils/util-types";
import { SourceAwareResolverContext } from "./SourceAwareResolverContext";
/**
 * In a composite multi-step operations, we can resolve operations over associations as mapped foreign operation in another data source
 *
 * Internally there is not much difference between a directly exposed data source and an operation which happens as a part of another multi-step composite operation
 *
 * MappedForeignOperation couples an operation as well as the arguments needed to invoke that operation.
 *
 * @api-category ConfigType
 */
export interface MappedForeignOperation<M extends MappedSingleSourceOperation<any, any>> {
    operation: M;
    args: M["ArgsType"];
}
/**
 * Runtime type representing union of constants representing different join types
 *
 * @api-category ConfigType
 */
export declare const JoinRT: t.UnionC<[t.LiteralC<"innerJoin">, t.LiteralC<"leftJoin">, t.LiteralC<"leftOuterJoin">, t.LiteralC<"rightOuterJoin">, t.LiteralC<"rightJoin">, t.LiteralC<"outerJoin">, t.LiteralC<"fullOuterJoin">, t.LiteralC<"crossJoin">]>;
/**
 * @api-category ConfigType
 */
export declare type JoinTypeId = t.TypeOf<typeof JoinRT>;
/**
 * @api-category ConfigType
 */
export declare const AssociationJoinConfigRT: t.TypeC<{
    join: t.UnionC<[t.UnionC<[t.LiteralC<"innerJoin">, t.LiteralC<"leftJoin">, t.LiteralC<"leftOuterJoin">, t.LiteralC<"rightOuterJoin">, t.LiteralC<"rightJoin">, t.LiteralC<"outerJoin">, t.LiteralC<"fullOuterJoin">, t.LiteralC<"crossJoin">]>, t.FunctionC]>;
}>;
/**
 * @api-category ConfigType
 */
export interface AssociationJoinConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource> extends t.TypeOf<typeof AssociationJoinConfigRT> {
    join: JoinTypeId | ((joinBuilder: JoinBuilder) => JoinBuilder);
}
/**
 * @api-category ConfigType
 */
export declare const AssociationPreFetchConfigRT: t.IntersectionC<[t.TypeC<{
    preFetch: t.FunctionC;
}>, t.PartialC<{
    associateResultsWithParents: t.FunctionC;
}>]>;
/**
 * @api-category ConfigType
 */
export interface AssociationPreFetchConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource> extends t.TypeOf<typeof AssociationPreFetchConfigRT> {
    preFetch: <TCtx extends SourceAwareResolverContext<TMappedOperation, TRootSrc, TGQLArgs, TGQLSource, TGQLContext>, TRootSrc extends MappedDataSource<any>, TMappedOperation extends MappedSingleSourceQueryOperation<TRootSrc, TGQLArgs>, TGQLArgs extends {}, TGQLSource = any, TGQLContext = any, TResolved = any>(this: MappedAssociation<TSrc, TTgt>, operation: SingleSourceQueryOperationResolver<TCtx, TRootSrc, TMappedOperation, TGQLArgs, TResolved>) => MappedForeignOperation<MappedSingleSourceOperation<TTgt, any>>;
    associateResultsWithParents?: (this: MappedAssociation<TSrc, TTgt>, parents: PartialDeep<TSrc["EntityType"]>[], results: PartialDeep<TTgt["EntityType"]>[]) => void;
}
/**
 * @api-category ConfigType
 */
export declare const AssociationPostFetchConfigRT: t.IntersectionC<[t.TypeC<{
    postFetch: t.FunctionC;
}>, t.PartialC<{
    associateResultsWithParents: t.FunctionC;
}>]>;
/**
 * @api-category ConfigType
 */
export interface AssociationPostFetchConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource> extends t.TypeOf<typeof AssociationPostFetchConfigRT> {
    postFetch: <TCtx extends SourceAwareResolverContext<TMappedOperation, TRootSrc, TGQLArgs, TGQLSource, TGQLContext>, TRootSrc extends MappedDataSource<any>, TMappedOperation extends MappedSingleSourceQueryOperation<TRootSrc, TGQLArgs>, TGQLArgs extends {}, TGQLSource = any, TGQLContext = any, TResolved = any>(this: MappedAssociation<TSrc, TTgt>, operation: SingleSourceQueryOperationResolver<TCtx, TRootSrc, TMappedOperation, TGQLArgs, TResolved>, parents: PartialDeep<TSrc["EntityType"]>[]) => MappedForeignOperation<MappedSingleSourceOperation<TTgt, any>>;
    associateResultsWithParents?: (this: MappedAssociation<TSrc, TTgt>, parents: PartialDeep<TSrc["EntityType"]>[], results: PartialDeep<TTgt["EntityType"]>[]) => void;
}
/**
 * @api-category ConfigType
 */
export declare const AssociationFetchConfigRT: t.IntersectionC<[t.UnionC<[t.IntersectionC<[t.TypeC<{
    preFetch: t.FunctionC;
}>, t.PartialC<{
    associateResultsWithParents: t.FunctionC;
}>]>, t.IntersectionC<[t.TypeC<{
    postFetch: t.FunctionC;
}>, t.PartialC<{
    associateResultsWithParents: t.FunctionC;
}>]>, t.TypeC<{
    join: t.UnionC<[t.UnionC<[t.LiteralC<"innerJoin">, t.LiteralC<"leftJoin">, t.LiteralC<"leftOuterJoin">, t.LiteralC<"rightOuterJoin">, t.LiteralC<"rightJoin">, t.LiteralC<"outerJoin">, t.LiteralC<"fullOuterJoin">, t.LiteralC<"crossJoin">]>, t.FunctionC]>;
}>]>, t.PartialC<{
    useIf: t.FunctionC;
}>]>;
/**
 * @api-category ConfigType
 */
export declare type AssociationFetchConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource> = (AssociationJoinConfig<TSrc, TTgt> | AssociationPreFetchConfig<TSrc, TTgt> | AssociationPostFetchConfig<TSrc, TTgt>) & {
    useIf?: <TCtx extends SourceAwareResolverContext<TMappedOperation, TRootSrc, TGQLArgs, TGQLSource, TGQLContext>, TRootSrc extends MappedDataSource<any>, TMappedOperation extends MappedSingleSourceQueryOperation<TRootSrc, TGQLArgs>, TGQLArgs extends {}, TGQLSource = any, TGQLContext = any, TResolved = any>(this: MappedAssociation<TSrc, TTgt>, operation: SingleSourceQueryOperationResolver<TCtx, TRootSrc, TMappedOperation, TGQLArgs, TResolved>) => boolean;
};
export declare function isPreFetchConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource>(config: any): config is AssociationPreFetchConfig<TSrc, TTgt>;
export declare function isPostFetchConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource>(config: any): config is AssociationPostFetchConfig<TSrc, TTgt>;
export declare function isJoinConfig<TSrc extends MappedDataSource, TTgt extends MappedDataSource>(config: any): config is AssociationJoinConfig<TSrc, TTgt>;
/**
 * @api-category ConfigType
 */
export declare const AssociationMappingRT: t.IntersectionC<[t.TypeC<{
    target: t.FunctionC;
    fetchThrough: t.ArrayC<t.IntersectionC<[t.UnionC<[t.IntersectionC<[t.TypeC<{
        preFetch: t.FunctionC;
    }>, t.PartialC<{
        associateResultsWithParents: t.FunctionC;
    }>]>, t.IntersectionC<[t.TypeC<{
        postFetch: t.FunctionC;
    }>, t.PartialC<{
        associateResultsWithParents: t.FunctionC;
    }>]>, t.TypeC<{
        join: t.UnionC<[t.UnionC<[t.LiteralC<"innerJoin">, t.LiteralC<"leftJoin">, t.LiteralC<"leftOuterJoin">, t.LiteralC<"rightOuterJoin">, t.LiteralC<"rightJoin">, t.LiteralC<"outerJoin">, t.LiteralC<"fullOuterJoin">, t.LiteralC<"crossJoin">]>, t.FunctionC]>;
    }>]>, t.PartialC<{
        useIf: t.FunctionC;
    }>]>>;
}>, t.PartialC<{
    description: t.StringC;
    singular: t.BooleanC;
    exposed: t.BooleanC;
    associatorColumns: t.TypeC<{
        inSource: t.StringC;
        inRelated: t.StringC;
    }>;
    paginate: t.UnionC<[t.IntersectionC<[t.TypeC<{
        cursorColumn: t.StringC;
    }>, t.PartialC<{
        pageSize: t.UnionC<[t.NumberC, t.PartialC<{
            max: t.NumberC;
            default: t.NumberC;
        }>]>;
    }>]>, t.IntersectionC<[t.PartialC<{
        pageSize: t.UnionC<[t.NumberC, t.PartialC<{
            max: t.NumberC;
            default: t.NumberC;
        }>]>;
    }>, t.TypeC<{
        interceptQuery: t.FunctionC;
        getNextCursor: t.FunctionC;
        getPrevCursor: t.FunctionC;
        getTotalCount: t.FunctionC;
    }>]>]>;
}>]>;
/**
 * Configuration used to map an association.
 *
 * Association mapping determines how two data sources can be linked (through joins, or auxiliary queries) so
 * that operations can be performed over multiple data sources.
 *
 * @api-category ConfigType
 */
export interface AssociationMapping<TSrc extends MappedDataSource = any, TTgt extends MappedDataSource = any> extends t.TypeOf<typeof AssociationMappingRT> {
    target: (this: MappedAssociation<TSrc, TTgt>) => TTgt;
    description?: string;
    singular?: boolean;
    associatorColumns?: {
        inSource: string;
        inRelated: string;
    };
    fetchThrough: AssociationFetchConfig<TSrc, TTgt>[];
    paginate?: PaginationConfig;
}