graphql-data-generator 0.1.0

package/esm/codegen.js

@@ -0,0 +1,474 @@
+import { readFile } from "node:fs/promises";
+import { Kind, parse } from "graphql";
+import fg from "fast-glob";
+import { join } from "node:path";
+import { raise } from "./util.js";
+const getType = ({ type, ...props }) => {
+    if (type.kind === "NamedType") {
+        if (props.selections) {
+            const def = props.definitions[type.name.value];
+            const implementations = def?.[0].kind === "InterfaceTypeDefinition"
+                ? Object.values(props.definitions)
+                    .filter((v) => v?.[0].kind === "ObjectTypeDefinition" &&
+                    v[0].interfaces?.some((i) => i.name.value === def[0].name.value) ||
+                    false)
+                : def?.[0].kind === "UnionTypeDefinition"
+                    ? Object.values(props.definitions)
+                        .filter((v) => "types" in def[0] &&
+                        def[0].types?.some((t) => v && t.name.value === v[0].name.value) ||
+                        false)
+                    : [];
+            const groupedValues = getSelectionsType(type.name.value, props.selections, props.definitions, props.fragments, props.references, props.includeTypenames).reduce((union, [name, value, group]) => {
+                group ??= type.name.value;
+                if (!union[group]) {
+                    union[group] = {};
+                    Object.defineProperty(union[group], "__typename", {
+                        enumerable: props.includeTypenames &&
+                            props.definitions[group]?.[0].kind === "ObjectTypeDefinition",
+                        value: { kind: "StringLiteral", value: group, optional: false },
+                    });
+                }
+                union[group][name] = value;
+                const def = props.definitions[group];
+                if (def) {
+                    if (implementations.length) {
+                        for (const implementation of implementations) {
+                            implementation[1].add(name);
+                        }
+                    }
+                    else
+                        def[1].add(name);
+                }
+                return union;
+            }, {});
+            const value = groupedValues[type.name.value] ?? {};
+            delete groupedValues[type.name.value];
+            const nonExhaustive = implementations
+                .filter((o) => !(o[0].name.value in groupedValues)).map((o) => o[0].name.value);
+            return {
+                kind: "Object",
+                value,
+                conditionals: Object.values(groupedValues).map((value) => ({
+                    kind: "Object",
+                    value,
+                    optional: false,
+                })),
+                nonExhaustive,
+                optional: props.optional ?? true,
+            };
+        }
+        const reference = props.references[type.name.value];
+        if (reference)
+            reference[1] = true;
+        return {
+            kind: "Name",
+            value: type.name.value,
+            optional: props.optional ?? true,
+        };
+    }
+    else if (type.kind === "NonNullType") {
+        return getType({ ...props, type: type.type, optional: false });
+    }
+    else if (type.kind === "ListType") {
+        return {
+            kind: "List",
+            value: getType({ ...props, type: type.type, optional: true }),
+            optional: props.optional ?? true,
+        };
+    }
+    else
+        throw new Error(`Unhandled type '${type}'`);
+};
+const getSelectionsType = (name, selections, definitions, fragments, references, includeTypenames) => {
+    const selectionTypes = [];
+    for (const selection of selections) {
+        switch (selection.kind) {
+            case "Field": {
+                const selectionType = definitions[name];
+                if (!selectionType) {
+                    throw new Error(`Could not find type '${selection.name.value}'`);
+                }
+                switch (selectionType[0].kind) {
+                    case "ObjectTypeDefinition":
+                    case "InterfaceTypeDefinition": {
+                        const fieldType = selectionType[0].fields?.find((f) => f.name.value === selection.name.value);
+                        if (!fieldType) {
+                            throw new Error(`Could not find field '${selection.name.value}' on type '${name}'`);
+                        }
+                        selectionTypes.push([
+                            selection.alias?.value ?? selection.name.value,
+                            getType({
+                                type: fieldType.type,
+                                selections: selection.selectionSet?.selections,
+                                definitions,
+                                fragments,
+                                references,
+                                includeTypenames,
+                            }),
+                        ]);
+                        break;
+                    }
+                    case "UnionTypeDefinition": {
+                        const types = selectionType[0].types;
+                        if (!types) {
+                            throw new Error(`Expected types to be present on union '${selectionType[0].name.value}'`);
+                        }
+                        selectionTypes.push(...getSelectionsType(types[0].name.value, // Assuming the selection is in all types
+                        [selection], definitions, fragments, references, includeTypenames));
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unhandled selection type '${selectionType[0].kind}'`);
+                }
+                break;
+            }
+            case "InlineFragment": {
+                const subSelection = getSelectionsType(selection.typeCondition?.name.value ?? name, selection.selectionSet.selections, definitions, fragments, references, includeTypenames);
+                const group = selection.typeCondition?.name.value ??
+                    selection.directives?.map((d) => d.name).join(",");
+                selectionTypes.push(...(group
+                    ? subSelection.map(([n, t, g]) => [n, t, g ? `${group}:${g}` : group])
+                    : subSelection));
+                break;
+            }
+            case "FragmentSpread": {
+                const fragment = fragments[selection.name.value];
+                if (!fragment) {
+                    throw new Error(`Could not find fragment '${selection.name.value}' in '${name}'`);
+                }
+                selectionTypes.push(...getSelectionsType(fragment.typeCondition.name.value, fragment.selectionSet.selections, definitions, fragments, references, includeTypenames));
+                break;
+            }
+            default:
+                throw new Error(`Unhandled selection kind '${selection.kind}'`);
+        }
+    }
+    return selectionTypes;
+};
+const getOperationType = (operation, definitions, fragments, root, references, includeTypenames) => ({
+    kind: "Object",
+    value: Object.fromEntries(operation.selectionSet.selections.map((selection) => {
+        if (selection.kind !== "Field") {
+            throw new Error(`Expected top-level selection on operation to be field, got '${selection.kind}'`);
+        }
+        const definition = root[selection.name.value];
+        if (!definition) {
+            throw new Error(`Could not find definition '${selection.name.value}'`);
+        }
+        return [
+            selection.alias?.value ?? selection.name.value,
+            getType({
+                type: definition.type,
+                selections: selection.selectionSet?.selections,
+                definitions,
+                fragments,
+                references,
+                includeTypenames,
+            }),
+        ];
+    })),
+    optional: false,
+});
+const getOperationVariables = (operation, references) => ({
+    kind: "Object",
+    value: Object.fromEntries(operation.variableDefinitions?.map((v) => [
+        v.variable.name.value,
+        getType({
+            type: v.type,
+            references,
+            definitions: {},
+            fragments: {},
+            includeTypenames: false,
+        }),
+    ]) ?? []),
+    optional: false,
+});
+const serializeType = (type, variables = false, depth = 0) => {
+    switch (type.kind) {
+        case "Name":
+            return `${type.value}${type.optional ? " | null" : ""}`;
+        case "List":
+            if (type.value.optional ||
+                (type.value.kind === "Object" &&
+                    ((type.value.conditionals?.length ?? 0) -
+                        (Object.keys(type.value.value).length ? 0 : 1)))) {
+                return `(${serializeType(type.value, variables, depth)})[]${type.optional ? " | null" : ""}`;
+            }
+            return `${serializeType(type.value, variables, depth)}[]${type.optional ? " | null" : ""}`;
+        case "Object": {
+            const content = Object.entries(type.value).map(([key, value]) => `${"  ".repeat(depth + 1)}${key}${value.optional && variables ? "?" : ""}: ${serializeType(value, variables, depth + 1)};`).join("\n");
+            const ands = [
+                `{${content ? `\n${content}\n${"  ".repeat(depth)}` : ""}}`,
+                ...(type.conditionals?.filter((c) => c.kind !== "Object" || !c.value.__typename)?.map((c) => `(${serializeType(c, variables, depth + 1)} | {})`) ??
+                    []),
+            ];
+            const ors = type.conditionals
+                ?.filter((c) => c.kind === "Object" && c.value.__typename)
+                .map((c) => serializeType(c, variables, depth)) ?? [];
+            if (type.nonExhaustive?.length && ors.length) {
+                ors.push(`{ __typename: ${type.nonExhaustive.map((v) => `"${v}"`).join(" | ")} }`);
+            }
+            // TODO: Ideally this would be better formatted, but then I need to track
+            // depth
+            return `${[
+                ands[0] === "{}" ? undefined : ands[0],
+                ors.length > 1 && (ands.length !== 1 || ands[0] !== "{}")
+                    ? `(${ors.join(" | ")})`
+                    : ors.join(" | "),
+                ...ands.slice(1),
+            ].filter(Boolean).join(" & ")}${type.optional ? " | null" : ""}`;
+        }
+        case "StringLiteral":
+            return `"${type.value}"`;
+    }
+};
+const serializeInput = (fields, optional, inputs, references) => ({
+    kind: "Object",
+    value: Object.fromEntries(fields.map((f) => [
+        f.name.value,
+        fillOutInput(getType({
+            type: f.type,
+            references,
+            definitions: {},
+            fragments: {},
+            includeTypenames: false,
+        }), inputs, references),
+    ])),
+    optional,
+});
+const fillOutInput = (input, inputs, references) => {
+    switch (input.kind) {
+        case "List":
+            return { ...input, value: fillOutInput(input.value, inputs, references) };
+        case "Object":
+            return {
+                ...input,
+                value: Object.fromEntries(Object.entries(input.value).map(([k, v]) => [k, fillOutInput(v, inputs, references)])),
+            };
+        case "Name": {
+            const def = inputs[input.value];
+            if (!def)
+                return input;
+            return serializeInput(def[0].fields ?? [], input.optional, inputs, references);
+        }
+        case "StringLiteral":
+            return input;
+    }
+};
+const operationNames = {
+    query: { types: "Query", list: "queries" },
+    mutation: { types: "Mutation", list: "mutations" },
+    subscription: { types: "Subscription", list: "subscriptions" },
+};
+const simpleType = (type, types, optional = true) => {
+    switch (type.kind) {
+        case Kind.NON_NULL_TYPE:
+            return simpleType(type.type, types, false);
+        case Kind.LIST_TYPE:
+            return {
+                kind: "List",
+                value: simpleType(type.type, types),
+                optional,
+            };
+        case Kind.NAMED_TYPE:
+            return {
+                kind: "Name",
+                value: type.name.value,
+                optional,
+            };
+    }
+};
+export const codegen = (schema, files, { useEnums = true, scalars = {}, includeTypenames = true } = {}) => {
+    const schemaDoc = parse(schema);
+    const types = {};
+    const inputs = {};
+    const fragments = {};
+    const references = Object.fromEntries(["Int", "Float", "String", "Boolean", "ID"].map((name) => [name, [{
+                kind: Kind.SCALAR_TYPE_DEFINITION,
+                name: { kind: Kind.NAME, value: name },
+            }, false]]));
+    let query = {};
+    let mutation = {};
+    let subscription = {};
+    for (const definition of schemaDoc.definitions) {
+        switch (definition.kind) {
+            case "ObjectTypeDefinition":
+                if (definition.name.value === "Query") {
+                    query = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
+                }
+                else if (definition.name.value === "Mutation") {
+                    mutation = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
+                }
+                else if (definition.name.value === "Subscription") {
+                    subscription = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
+                }
+                else
+                    types[definition.name.value] = [definition, new Set()];
+                break;
+            case "InputObjectTypeDefinition":
+                inputs[definition.name.value] = [definition, new Set()];
+                break;
+            case "InterfaceTypeDefinition":
+                types[definition.name.value] = [definition, new Set()];
+                break;
+            case "UnionTypeDefinition": {
+                const prev = types[definition.name.value];
+                if (prev?.[0].kind === "UnionTypeDefinition") {
+                    types[definition.name.value] = [{
+                            ...prev[0],
+                            types: [...(prev[0].types ?? []), ...(definition.types ?? [])],
+                        }, prev[1]];
+                }
+                else
+                    types[definition.name.value] = [definition, new Set()];
+                break;
+            }
+            case "EnumTypeDefinition":
+                if (!references[definition.name.value]) {
+                    references[definition.name.value] = [definition, false];
+                }
+                else {
+                    const prev = references[definition.name.value][0];
+                    references[definition.name.value][0] = {
+                        ...prev,
+                        values: [
+                            ...(prev.values ?? []),
+                            ...(definition.values ?? []),
+                        ],
+                    };
+                }
+                break;
+            case "ScalarTypeDefinition":
+                references[definition.name.value] = [definition, false];
+                break;
+            default:
+                throw new Error(`Unhandled definition type '${definition.kind}'`);
+        }
+    }
+    const roots = { query, mutation, subscription };
+    const operations = {
+        query: [],
+        mutation: [],
+        subscription: [],
+    };
+    for (const { path, content } of files) {
+        const dom = parse(content);
+        for (const definition of dom.definitions) {
+            switch (definition.kind) {
+                case "OperationDefinition": {
+                    const name = definition.name?.value;
+                    if (!name) {
+                        console.warn(`Skipping unnamed operation in '${path}'`);
+                        continue;
+                    }
+                    operations[definition.operation].push({
+                        name,
+                        path,
+                        definition: definition,
+                    });
+                    break;
+                }
+                case "FragmentDefinition":
+                    fragments[definition.name.value] = definition;
+                    break;
+                default:
+                    throw new Error(`Unhandled definition kind '${definition.kind}' in operation file '${path}'`);
+            }
+        }
+    }
+    const handledInputs = new Set();
+    const serializedTypes = Object.entries(operations).filter(([, v]) => v.length)
+        .flatMap(([name, collection]) => [
+        ...collection.flatMap((c) => c.definition.variableDefinitions?.map((v) => {
+            let type = getType({
+                type: v.type,
+                definitions: inputs,
+                references,
+                fragments: {},
+                includeTypenames: false,
+            });
+            let inputType = fillOutInput(type, inputs, references);
+            if (JSON.stringify(type) === JSON.stringify(inputType))
+                return;
+            if (type.kind === "List")
+                type = type.value;
+            if (inputType.kind === "List")
+                inputType = inputType.value;
+            if (type.kind !== "Name") {
+                throw new Error(`Could not find type for variable '${v.variable.name.value}'`);
+            }
+            if (handledInputs.has(type.value))
+                return;
+            handledInputs.add(type.value);
+            // return `type ${type.value} = ${serializeType(inputType)};`;
+        }).filter(Boolean)),
+        `export type ${operationNames[name].types} = {
+${collection.map((o) => {
+            const data = serializeType(getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames), false, 2);
+            const variables = getOperationVariables(o.definition, references);
+            return `  ${o.name}: {
+    data: ${data};${variables.kind === "Object" && Object.keys(variables.value).length
+                ? `
+    variables: ${serializeType(variables, true, 2)};`
+                : ""}
+  };`;
+        }).join("\n")}
+};
+
+export const ${operationNames[name].list} = {
+${collection.map((o) => `  ${o.name}: "${o.path}",`).join("\n")}
+};`,
+    ]);
+    if (handledInputs.size) {
+        serializedTypes.unshift(...Array.from(handledInputs).map((i) => {
+            const def = inputs[i]?.[0];
+            if (!def)
+                throw new Error(`Could not find input '${i}'`);
+            return `type ${i} = ${serializeType(serializeInput(def.fields ?? [], false, {}, references))};`;
+        }), `export type Inputs = {
+${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
+};`, `export const inputs = [${Array.from(handledInputs).map((i) => `"${i}"`).join(", ")}] as const;`);
+    }
+    const usedTypes = Object.entries(types)
+        .map(([name, info]) => [name, ...info])
+        .filter((data) => data[1].kind === "ObjectTypeDefinition" && data[2].size > 0);
+    if (usedTypes.length) {
+        serializedTypes.unshift(...usedTypes.map(([name, type, usage]) => `type ${name} = {
+${includeTypenames ? `  __typename: "${name}";\n` : ""}${type.fields?.filter((f) => usage.has(f.name.value)).map((v) => `  ${v.name.value}: ${serializeType(simpleType(v.type, types))};`).join("\n")}
+};`), `export type Types = {
+${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
+};`, `export const types = [${usedTypes.map(([name]) => `"${name}"`).join(", ")}] as const;`);
+    }
+    const usedReferences = Object.values(references).filter((r) => r[1]).map((r) => r[0]);
+    serializedTypes.unshift(...usedReferences.map((r) => {
+        // TODO: warn if missing and use unknown instead
+        if (r.kind === "ScalarTypeDefinition") {
+            return `type ${r.name.value} = ${scalars[r.name.value] ??
+                raise(`Could not find scalar '${r.name.value}'`)};`;
+        }
+        if (useEnums) {
+            return `enum ${r.name.value} {
+  ${r.values?.map((r) => r.name.value).join(",\n  ")}
+}`;
+        }
+        else {
+            return `type ${r.name.value} = ${r.values?.map((r) => `"${r.name.value}"`).join(" | ")};`;
+        }
+    }));
+    return serializedTypes.join("\n\n") + "\n";
+};
+export const loadFiles = async (schemaPath, operationDirs) => {
+    const operationPromises = [];
+    for (const dir of operationDirs) {
+        for await (const path of fg.stream(join(dir, "**/*.gql"))) {
+            operationPromises.push(readFile(path.toString(), "utf-8").then((content) => ({
+                path: path.toString(),
+                content,
+            })));
+        }
+    }
+    return [
+        await readFile(schemaPath, "utf-8"),
+        await Promise.all(operationPromises),
+    ];
+};

package/esm/extendedTypes.d.ts

@@ -0,0 +1,65 @@
+import type { ContravariantEmpty, OperationMock, Patch, SimpleOperationMock } from "./types.js";
+type DefaultObjectTransformSwitch<T, U> = T extends (infer G)[] ? DefaultObjectTransformSwitch<G, U>[] : DefaultObjectTransform<T, U>;
+type DefaultObjectTransform<T, U = T> = {
+    [K in keyof T]?: T[K] extends object ? DefaultObjectTransformSwitch<T[K], U> | ((host: U) => DefaultObjectTransformSwitch<T[K], U>) : T[K] | ((host: U) => T[K]);
+};
+export type Shift<T extends unknown[]> = T extends [infer _First, ...infer Rest] ? Rest : [];
+type OperationBuilder<Data extends Record<string, unknown> = Record<string, unknown>, Variables = unknown, Transforms = unknown, Extra = ContravariantEmpty> = ((...patches: ((Patch<SimpleOperationMock<Data, Variables>> & Partial<Extra>) | ((prev: SimpleOperationMock<Data, Variables>) => Patch<SimpleOperationMock<Data, Variables>>))[]) => OperationBuilderWithMock<Data, Variables, Transforms, Extra>) & {
+    variables: (variables: Patch<Variables> | ((data: Data, variables: Variables) => Patch<Variables>)) => OperationBuilderWithMock<Data, Variables, Transforms, Extra>;
+    data: (data: Patch<Data> | ((variables: Variables, data: Data) => Patch<Data>)) => OperationBuilderWithMock<Data, Variables, Transforms, Extra>;
+    patch: (patch: Patch<{
+        data: Data;
+        variables: Variables;
+    }>) => OperationBuilderWithMock<Data, Variables, Transforms, Extra>;
+} & {
+    [Transform in keyof Transforms]: Transforms[Transform] extends (...args: any[]) => unknown ? (...params: Shift<Parameters<Transforms[Transform]>>) => OperationBuilderWithMock<Data, Variables, Transforms, Extra> : () => OperationBuilderWithMock<Data, Variables, Transforms, Extra>;
+};
+type OperationBuilderWithMock<Data extends Record<string, unknown>, Variables, Transforms, Extra> = OperationBuilder<Data, Variables, Transforms> & OperationMock<Data, Variables> & Partial<Extra>;
+type ObjectTransforms<T, Transforms> = {
+    [Transform in keyof Transforms]: Transforms[Transform] extends (...args: any[]) => any ? (...args: Shift<Parameters<Transforms[Transform]>>) => T & ObjectTransforms<T, Transforms> : () => T & ObjectTransforms<T, Transforms>;
+} & {
+    patch: (patch: Patch<T> | ((prev: T) => Patch<T>)) => T & ObjectTransforms<T, Transforms>;
+};
+type ObjectBuilder<T, Transforms> = ((...patches: (Patch<T> | ((previous: T) => Patch<T>))[]) => T & ObjectTransforms<T, Transforms>) & ObjectTransforms<T, Transforms>;
+type CapitalizeFirst<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+type PrefixKeys<T, Prefix extends string> = {
+    [K in keyof T as `${Prefix}${CapitalizeFirst<string & K>}`]: T[K];
+};
+type MapObjectsToBuilders<T, Transforms> = {
+    [K in keyof T]: ObjectBuilder<T[K], K extends keyof Transforms ? Transforms[K] : ContravariantEmpty>;
+};
+export type MapObjectsToTransforms<Objects extends Record<string, Record<string, unknown>>> = {
+    [Object in keyof Objects]?: Record<string, DefaultObjectTransform<Objects[Object], Objects[Object]> | ((prev: Objects[Object], ...args: any[]) => Patch<Objects[Object]>)>;
+};
+type InnerMapOperationsToTransforms<Operations> = {
+    [Operation in keyof Operations]?: Record<string, InferOperationTransforms<Operations[Operation]>>;
+};
+export type MapOperationsToTransforms<Queries, Mutations, Subscriptions, Types, Inputs> = InnerMapOperationsToTransforms<ResolveConflicts<Queries, Mutations, Subscriptions, Types, Inputs>>;
+type MapOperationsToBuilders<T, Transforms, Extra> = {
+    [K in keyof T]: OperationBuilder<T[K] extends {
+        data: infer U;
+    } ? U extends Record<string, unknown> ? U : Record<string, unknown> : Record<string, unknown>, T[K] extends {
+        variables: infer U;
+    } ? U : unknown, K extends keyof Transforms ? Transforms[K] : ContravariantEmpty, Extra>;
+};
+type ResolveOperationConflicts<T, Name extends string, A, B, C, D> = Omit<T, keyof A | keyof B | keyof C | keyof D> & PrefixKeys<Pick<T, keyof T & (keyof A | keyof B | keyof C | keyof D)>, Name>;
+type ResolveConflicts<Queries, Mutations, Subscriptions, Types, Inputs> = ResolveOperationConflicts<Queries, "queries", Mutations, Subscriptions, Types, Inputs> & ResolveOperationConflicts<Mutations, "mutations", Queries, Subscriptions, Types, Inputs> & ResolveOperationConflicts<Subscriptions, "subscriptions", Queries, Mutations, Types, Inputs>;
+type DefaultOperationTransform<T> = {
+    data?: T extends {
+        data: infer D;
+    } ? Patch<D> : never;
+    variables?: T extends {
+        variables: infer V;
+    } ? Patch<V> : never;
+};
+type OperationTransform<T> = (b: {
+    data: T extends {
+        data: infer U;
+    } ? U : never;
+    variables: T extends {
+        variables: infer U;
+    } ? U : never;
+}, ...args: any[]) => Patch<T>;
+type InferOperationTransforms<T> = DefaultOperationTransform<T> | OperationTransform<T>;
+export type Build<Queries, Mutations, Subscriptions, Types, Inputs, Transforms, Extra> = MapObjectsToBuilders<Types & Inputs, Transforms> & MapOperationsToBuilders<ResolveConflicts<Queries, Mutations, Subscriptions, Types, Inputs>, Transforms, Extra>;
+export {};

package/esm/extendedTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export { init } from "./init.js";
+export type { DeepPartial, Patch } from "./types.js";
+export { codegen } from "./codegen.js";
+export { proxy } from "./proxy.js";
+export { formatCode, toObject } from "./util.js";

package/esm/index.js

@@ -0,0 +1,4 @@
+export { init } from "./init.js";
+export { codegen } from "./codegen.js";
+export { proxy } from "./proxy.js";
+export { formatCode, toObject } from "./util.js";

package/esm/init.d.ts

@@ -0,0 +1,16 @@
+import type { Build, MapObjectsToTransforms, MapOperationsToTransforms } from "./extendedTypes.js";
+import type { ContravariantEmpty, OperationMock } from "./types.js";
+export declare const init: <Query extends Record<string, {
+    data: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+}>, Mutation extends Record<string, {
+    data: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+}>, Subscription extends Record<string, {
+    data: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+}>, Types extends Record<string, Record<string, unknown>>, Inputs extends Record<string, Record<string, unknown>>, Extra = object>(schema: string, queries: { [operation in keyof Query]: string; }, mutations: { [operation in keyof Mutation]: string; }, subscriptions: { [operation in keyof Subscription]: string; }, types: readonly (keyof Types & string)[], inputs: readonly (keyof Inputs & string)[], scalars: {
+    [name: string]: ((typeName: string, fieldName: string) => unknown) | string | number | boolean | null;
+}, options?: {
+    finalizeOperation: <T extends OperationMock & Partial<Extra>>(operation: T) => T;
+}) => <Transforms extends MapObjectsToTransforms<Types & Inputs> & MapOperationsToTransforms<Query, Mutation, Subscription, Types, Inputs>>(fn: (b: Build<Query, Mutation, Subscription, Types, Inputs, ContravariantEmpty, Extra>) => Transforms) => Build<Query, Mutation, Subscription, Types, Inputs, Transforms, Extra>;