import { Request as ExpressRequest, Response as ExpressResponse } from 'express';
import { Request as OneRequest, OneRequestStore } from '@skava/request';
/**
 * @todo !!!!!!! this needs updating...............
 */
import { DataSources } from 'apollo-server-core/dist/graphqlOptions';
import { ApolloError } from 'apollo-server';
import { GraphQLResponse as ApolloGraphQLResponse } from 'apollo-server-core/src/requestpipelineapi';
export { OneRequestContextBase } from '@skava/request';
export declare type GraphQLResponse<Response extends object> = ApolloGraphQLResponse & {
    error?: ApolloError;
    data?: Response;
};
export declare type AsyncGraphQLResponse<Response extends object> = Promise<GraphQLResponse<Response>>;
export { OneRequest as OneRequestType, OneRequestStore };
export interface EndpointGroup {
    [key: string]: OneRequest;
}
export interface EndpointsTemporary {
    cartAndCheckout: EndpointGroup;
    categories: EndpointGroup;
    list: EndpointGroup;
    oms: EndpointGroup;
    review: EndpointGroup;
    catalog: EndpointGroup;
    store: EndpointGroup;
    user: EndpointGroup;
    studio: EndpointGroup;
}
export interface ModuleConfig {
    api?: 'stream' | 'orchestration' | 'fixture' | 'test';
}
import { GraphQLModule as GraphQLCoreModule } from '@graphql-modules/core';
export { GraphQLCoreModule as GraphQLModule };
export interface ExpressRequest extends ExpressRequest {
    isSafe: boolean;
}
export interface ExpressResponse extends ExpressResponse {
}
export interface ResolverObj {
    self: any;
}
export interface ResolverArgs<Args = any> {
    [key: string]: string | number | boolean | ResolverArgs<Args> | ResolverArgs[] | undefined | any;
}
export interface ResolverInfo {
    cacheControl: any;
    directives: any;
}
export declare type Context = EndpointsTemporary & {
    req: ExpressRequest;
    res: ExpressResponse;
    request: Request;
    dataSources: DataSources<Context>;
};
export declare type ResolverFunction<Type = any> = (obj: ResolverObj, args: ResolverArgs, context: Context, info: ResolverInfo) => Promise<Type> | Type;
export interface ResolverType<Type = any> {
    [key: string]: ResolverFunction;
}
export interface ResolverExport<Type = any> {
    Query?: ResolverType<Type>;
    Mutation?: ResolverType<Type>;
}
export interface AnyObj {
    [key: string]: any;
}
export interface DefaultOneResponseError {
    code?: number | string;
    message?: string;
    errors?: AnyObj[];
    timestamp?: number;
}
export declare type DefaultOneResponseData = DefaultOneResponseError;
export interface OneResponse<Data = AnyObj & DefaultOneResponseData> extends Body, Response {
    readonly 'Symbol(Body internals)': {
        readonly headers: Headers;
        readonly status: number;
        readonly statusText: string;
        readonly url: string;
        readonly type?: ResponseType;
    };
    readonly prettyError?: DefaultOneResponseError;
    readonly data?: Data;
}
export interface OrchestrationResponse {
    responseMessage?: string;
    errors?: any[];
    message?: string;
    errorCode?: number;
}