@kamilkisiela/graphql-tools

const attachConnectorsToContext: Function;

const defaultMergedResolver: GraphQLFieldResolver<any, any>;

addCatchUndefinedToSchema: (schema: GraphQLSchema) => void;

addErrorLoggingToSchema: (schema: GraphQLSchema, logger: ILogger) => void;

addMockFunctionsToSchema: ({
    schema,
    mocks,
    preserveResolvers,
}: IMockOptions) => void;

addResolveFunctionsToSchema: (
    options: IAddResolveFunctionsToSchemaOptions | GraphQLSchema,
    legacyInputResolvers?: IResolvers,
    legacyInputValidationOptions?: IResolverValidationOptions
) => GraphQLSchema;

addSchemaLevelResolveFunction: (
    schema: GraphQLSchema,
    fn: GraphQLFieldResolver<any, any>
) => void;

assertResolveFunctionsPresent: (
    schema: GraphQLSchema,
    resolverValidationOptions?: IResolverValidationOptions
) => void;

attachDirectiveResolvers: (
    schema: GraphQLSchema,
    directiveResolvers: IDirectiveResolvers<any, any>
) => void;

buildSchemaFromTypeDefinitions: (
    typeDefinitions: ITypeDefinitions,
    parseOptions?: GraphQLParseOptions
) => GraphQLSchema;

chainResolvers: (
    resolvers: GraphQLFieldResolver<any, any>[]
) => (
    root: any,
    args: { [argName: string]: any },
    ctx: any,
    info: GraphQLResolveInfo
) => any;

checkForResolveTypeResolver: (
    schema: GraphQLSchema,
    requireResolversForResolveType?: boolean
) => void;

concatenateTypeDefs: (
    typeDefinitionsAry: ITypedef[],
    calledFunctionRefs?: any
) => string;

decorateWithLogger: (
    fn: GraphQLFieldResolver<any, any> | undefined,
    logger: ILogger,
    hint: string
) => GraphQLFieldResolver<any, any>;

defaultCreateRemoteResolver: (
    fetcher: Fetcher
) => GraphQLFieldResolver<any, any>;

delegateToSchema: (
    options: IDelegateToSchemaOptions | GraphQLSchema,
    ...args: any[]
) => Promise<any>;

extendResolversFromInterfaces: (
    schema: GraphQLSchema,
    resolvers: IResolvers
) => IResolvers<any, any>;

extractExtensionDefinitions: (
    ast: DocumentNode
) => DocumentNode & { definitions: DefinitionNode[] };

forEachField: (schema: GraphQLSchema, fn: IFieldIteratorFn) => void;

introspectSchema: (
    fetcher: ApolloLink | Fetcher,
    linkContext?: { [key: string]: any }
) => Promise<GraphQLSchema>;

makeExecutableSchema: <TContext = any>({
    typeDefs,
    resolvers,
    connectors,
    logger,
    allowUndefinedInResolve,
    resolverValidationOptions,
    directiveResolvers,
    schemaDirectives,
    parseOptions,
    inheritResolversFromInterfaces,
}: IExecutableSchemaDefinition<TContext>) => GraphQLSchema;

makeRemoteExecutableSchema: ({
    schema,
    link,
    fetcher,
    createResolver: customCreateResolver,
    buildSchemaOptions,
    printSchemaOptions,
}: {
    schema: GraphQLSchema | string;
    link?: ApolloLink;
    fetcher?: Fetcher;
    createResolver?: (fetcher: Fetcher) => GraphQLFieldResolver<any, any>;
    buildSchemaOptions?: BuildSchemaOptions;
    printSchemaOptions?: PrintSchemaOptions;
}) => GraphQLSchema;

mergeSchemas: ({
    schemas,
    onTypeConflict,
    resolvers,
    schemaDirectives,
    inheritResolversFromInterfaces,
    mergeDirectives,
}: {
    schemas: Array<string | GraphQLSchema | DocumentNode | Array<GraphQLNamedType>>;
    onTypeConflict?: OnTypeConflict;
    resolvers?: IResolversParameter;
    schemaDirectives?: { [name: string]: typeof SchemaDirectiveVisitor };
    inheritResolversFromInterfaces?: boolean;
    mergeDirectives?: boolean;
}) => GraphQLSchema;

mockServer: (
    schema: GraphQLSchema | ITypeDefinitions,
    mocks: IMocks,
    preserveResolvers?: boolean
) => IMockServer;

transformSchema: (
    targetSchema: GraphQLSchema,
    transforms: Array<Transform>
) => GraphQLSchema & { transforms: Array<Transform> };

type DirectiveResolverFn<TSource = any, TContext = any> = (
    next: NextResolverFn,
    source: TSource,
    args: {
        [argName: string]: any;
    },
    context: TContext,
    info: GraphQLResolveInfo
) => any;

type GraphQLParseOptions = {
    noLocation?: boolean;
    allowLegacySDLEmptyFields?: boolean;
    allowLegacySDLImplementsInterfaces?: boolean;
    experimentalFragmentVariables?: boolean;
};

type IConnector<TContext = any> = IConnectorCls<TContext> | IConnectorFn<TContext>;

type IConnectorFn<TContext = any> = (context?: TContext) => any;

type IConnectors<TContext = any> = {
    [key: string]: IConnector<TContext>;
};

type IEnumResolver = {
    [key: string]: string | number;
};

type IFieldIteratorFn = (
    fieldDef: GraphQLField<any, any>,
    typeName: string,
    fieldName: string
) => void;

type IFieldResolver<TSource, TContext, TArgs = Record<string, any>> = (
    source: TSource,
    args: TArgs,
    context: TContext,
    info: GraphQLResolveInfo & {
        mergeInfo: MergeInfo;
    }
) => any;

type IMockFn = GraphQLFieldResolver<any, any>;

type IMocks = {
    [key: string]: IMockFn;
};

type IMockTypeFn = (
    type: GraphQLType,
    typeName?: string,
    fieldName?: string
) => GraphQLFieldResolver<any, any>;

type IResolverObject<TSource = any, TContext = any, TArgs = any> = {
    [key: string]:
        | IFieldResolver<TSource, TContext, TArgs>
        | IResolverOptions<TSource, TContext>
        | IResolverObject<TSource, TContext>;
};

type IResolversParameter =
    | Array<IResolvers | ((mergeInfo: MergeInfo) => IResolvers)>
    | IResolvers
    | ((mergeInfo: MergeInfo) => IResolvers);

type ITypedef = (() => ITypedef[]) | string | DocumentNode;

type ITypeDefinitions = ITypedef | ITypedef[];

type MergeInfo = {
    delegate: (
        type: 'query' | 'mutation' | 'subscription',
        fieldName: string,
        args: {
            [key: string]: any;
        },
        context: {
            [key: string]: any;
        },
        info: GraphQLResolveInfo,
        transforms?: Array<Transform>
    ) => any;
    delegateToSchema<TContext>(options: IDelegateToSchemaOptions<TContext>): any;
    fragments: Array<{
        field: string;
        fragment: string;
    }>;
};

type MergeTypeCandidate = {
    schema?: GraphQLSchema;
    type: GraphQLNamedType;
};

type NextResolverFn = () => Promise<any>;

type Operation = 'query' | 'mutation' | 'subscription';

type Request = {
    document: DocumentNode;
    variables: Record<string, any>;
    extensions?: Record<string, any>;
};

type ResolveType<T extends GraphQLType> = (type: T) => T;

type Result = ExecutionResult & {
    extensions?: Record<string, any>;
};

type Transform = {
    transformSchema?: (schema: GraphQLSchema) => GraphQLSchema;
    transformRequest?: (originalRequest: Request) => Request;
    transformResult?: (result: Result) => Result;
};

type TypeWithResolvers = {
    type: GraphQLNamedType;
    resolvers?: IResolvers;
};

type UnitOrList<Type> = Type | Array<Type>;

type VisitType = (
    name: string,
    candidates: Array<MergeTypeCandidate>
) => VisitTypeResult;

type VisitTypeResult = GraphQLNamedType | TypeWithResolvers | null;