import * as t from "io-ts";
import * as Knex from "knex";
import { OperationMapping } from "./OperationMapping";
import { OperationResolver } from "./OperationResolver";
import { MappedOperation } from "./MappedOperation";
import { ResolverContext } from "./ResolverContext";
import { MappedArgs } from "./MappedArgs";
import { GraphQLOutputType } from "graphql";
import { MaybeMapped } from "./utils/util-types";
export interface BaseInvocationParam {
    name?: string;
    value: any;
}
export interface InInvocationParam extends BaseInvocationParam {
    argMode: "IN";
}
export interface OutInvocationParam extends BaseInvocationParam {
    argMode: "OUT";
}
export interface InOutInvocationParam extends BaseInvocationParam {
    argMode: "INOUT";
}
export declare type InvocationParam = InInvocationParam | OutInvocationParam | InOutInvocationParam;
export declare const InvocationMappingRT: t.IntersectionC<[t.IntersectionC<[t.TypeC<{
    name: t.UnionC<[t.StringC, t.TypeC<{
        stored: t.StringC;
        mapped: t.StringC;
    }>]>;
}>, t.PartialC<{
    description: t.StringC;
    singular: t.BooleanC;
    shallow: t.BooleanC;
}>]>, t.PartialC<{
    type: t.UnionC<[t.LiteralC<"query">, t.LiteralC<"mutation">]>;
    deriveParams: t.FunctionC;
    deriveResult: t.FunctionC;
}>]>;
/**
 * @api-category ConfigType
 */
export interface InvocationMapping<TArgs extends {}> extends t.TypeOf<typeof InvocationMappingRT>, OperationMapping<TArgs> {
    name: MaybeMapped<string>;
    resolver?: <TCtx extends ResolverContext<MappedOperation<TArgs>, TArgs>, TResolved>(ctx: TCtx) => OperationResolver<TCtx, TArgs, TResolved>;
    args: MappedArgs<TArgs>;
    returnType: GraphQLOutputType;
    deriveParams(args: TArgs): InvocationParam[];
    deriveResult?: (output: any) => any;
    connector?: Knex;
}