apollo-utilities

const canUseWeakMap: boolean;

addTypenameToDocument: (doc: DocumentNode) => DocumentNode;

argumentsObjectFromField: (
    field: FieldNode | DirectiveNode,
    variables: Object
) => Object;

assign: {
    <A, B>(a: A, b: B): A & B;
    <A, B, C>(a: A, b: B, c: C): A & B & C;
    <A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
    <A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): A & B & C & D & E;
    (target: any, ...sources: any[]): any;
};

buildQueryFromSelectionSet: (document: DocumentNode) => DocumentNode;

checkDocument: (doc: DocumentNode) => DocumentNode;

cloneDeep: <T>(value: T) => T;

createFragmentMap: (fragments?: FragmentDefinitionNode[]) => FragmentMap;

getDefaultValues: (definition: OperationDefinitionNode | undefined) => {
    [key: string]: JsonValue;
};

getDirectiveInfoFromField: (
    field: FieldNode,
    variables: Object
) => DirectiveInfo;

getDirectiveNames: (doc: DocumentNode) => string[];

getDirectivesFromDocument: (
    directives: GetDirectiveConfig[],
    doc: DocumentNode
) => DocumentNode;

getEnv: () => string | undefined;

getFragmentDefinition: (doc: DocumentNode) => FragmentDefinitionNode;

getFragmentDefinitions: (doc: DocumentNode) => FragmentDefinitionNode[];

getFragmentQueryDocument: (
    document: DocumentNode,
    fragmentName?: string
) => DocumentNode;

getInclusionDirectives: (
    directives: ReadonlyArray<DirectiveNode>
) => InclusionDirectives;

getMainDefinition: (
    queryDoc: DocumentNode
) => OperationDefinitionNode | FragmentDefinitionNode;

getMutationDefinition: (doc: DocumentNode) => OperationDefinitionNode;

getOperationDefinition: (
    doc: DocumentNode
) => OperationDefinitionNode | undefined;

getOperationDefinitionOrDie: (document: DocumentNode) => OperationDefinitionNode;

getOperationName: (doc: DocumentNode) => string | null;

getQueryDefinition: (doc: DocumentNode) => OperationDefinitionNode;

getStoreKeyName: (
    fieldName: string,
    args?: Object,
    directives?: Directives
) => string;

graphQLResultHasError: (result: ExecutionResult) => number;

hasClientExports: (document: DocumentNode) => boolean;

hasDirectives: (names: string[], doc: DocumentNode) => boolean;

isDevelopment: () => boolean;

isEnv: (env: string) => boolean;

isField: (selection: SelectionNode) => selection is FieldNode;

isIdValue: (idObject: StoreValue) => idObject is IdValue;

isInlineFragment: (selection: SelectionNode) => selection is InlineFragmentNode;

isJsonValue: (jsonObject: StoreValue) => jsonObject is JsonValue;

isNumberValue: (value: ValueNode) => value is any;

isProduction: () => boolean;

isScalarValue: (value: ValueNode) => value is any;

isTest: () => boolean;

maybeDeepFreeze: (obj: any) => any;

mergeDeep: <T extends any[]>(...sources: T) => TupleToIntersection<T>;

mergeDeepArray: <T>(sources: T[]) => T;

removeArgumentsFromDocument: (
    config: RemoveArgumentsConfig[],
    doc: DocumentNode
) => DocumentNode;

removeClientSetsFromDocument: (document: DocumentNode) => DocumentNode | null;

removeConnectionDirectiveFromDocument: (doc: DocumentNode) => DocumentNode;

removeDirectivesFromDocument: (
    directives: RemoveDirectiveConfig[],
    doc: DocumentNode
) => DocumentNode | null;

removeFragmentSpreadFromDocument: (
    config: RemoveFragmentSpreadConfig[],
    doc: DocumentNode
) => DocumentNode;

resultKeyNameFromField: (field: FieldNode) => string;

shouldInclude: (
    selection: SelectionNode,
    variables?: { [name: string]: any }
) => boolean;

storeKeyNameFromField: (field: FieldNode, variables?: Object) => string;

stripSymbols: <T>(data: T) => T;

toIdValue: (idConfig: string | IdConfig, generated?: boolean) => IdValue;

tryFunctionOrLogError: (f: Function) => any;

valueFromNode: (node: ValueNode, onVariable?: VariableValue) => any;

valueToObjectRepresentation: (
    argObj: any,
    name: NameNode,
    value: ValueNode,
    variables?: Object
) => void;

variablesInOperation: (operation: OperationDefinitionNode) => Set<string>;

warnOnceInDevelopment: (msg: string, type?: string) => void;

type DirectiveInfo = {
    [fieldName: string]: {
        [argName: string]: any;
    };
};

type Directives = {
    [directiveName: string]: {
        [argName: string]: any;
    };
};

type GetDirectiveConfig = GetNodeConfig<DirectiveNode>;

type GetFragmentSpreadConfig = GetNodeConfig<FragmentSpreadNode>;

type GetNodeConfig<N> = {
    name?: string;
    test?: (node: N) => boolean;
};

type IdConfig = {
    id: string;
    typename: string | undefined;
};

type InclusionDirectives = Array<{
    directive: DirectiveNode;
    ifArgument: ArgumentNode;
}>;

type ListValue = Array<null | IdValue>;

type NumberValue = IntValueNode | FloatValueNode;

type RemoveArgumentsConfig = RemoveNodeConfig<ArgumentNode>;

type RemoveDirectiveConfig = RemoveNodeConfig<DirectiveNode>;

type RemoveFragmentDefinitionConfig = RemoveNodeConfig<FragmentDefinitionNode>;

type RemoveFragmentSpreadConfig = RemoveNodeConfig<FragmentSpreadNode>;

type RemoveNodeConfig<N> = {
    name?: string;
    test?: (node: N) => boolean;
    remove?: boolean;
};

type RemoveVariableDefinitionConfig = RemoveNodeConfig<VariableDefinitionNode>;

type ScalarValue = StringValueNode | BooleanValueNode | EnumValueNode;

type StoreValue =
    | number
    | string
    | string[]
    | IdValue
    | ListValue
    | JsonValue
    | null
    | undefined
    | void
    | Object;

type TupleToIntersection<T extends any[]> = T extends [infer A]
    ? A
    : T extends [infer A, infer B]
    ? A & B
    : T extends [infer A, infer B, infer C]
    ? A & B & C
    : T extends [infer A, infer B, infer C, infer D]
    ? A & B & C & D
    : T extends [infer A, infer B, infer C, infer D, infer E]
    ? A & B & C & D & E
    : T extends (infer U)[]
    ? U
    : any;

type VariableValue = (node: VariableNode) => any;