@nmarks/graphql-codegen-per-operation-file-preset 1.0.0

package/esm/fragment-resolver.js

@@ -0,0 +1,146 @@
+import { Kind, print } from 'graphql';
+import { BaseVisitor, buildScalarsFromConfig, getConfigValue, getPossibleTypes, } from '@graphql-codegen/visitor-plugin-common';
+import { analyzeFragmentUsage, generateOperationFilePath } from './utils.js';
+/**
+ * Creates fragment imports based on possible types and usage
+ */
+function createFragmentImports(baseVisitor, fragmentName, possibleTypes, usedTypes) {
+    const fragmentImports = [];
+    // Always include the document import
+    fragmentImports.push({
+        name: baseVisitor.getFragmentVariableName(fragmentName),
+        kind: 'document',
+    });
+    const fragmentSuffix = baseVisitor.getFragmentSuffix(fragmentName);
+    if (possibleTypes.length === 1) {
+        fragmentImports.push({
+            name: baseVisitor.convertName(fragmentName, {
+                useTypesPrefix: true,
+                suffix: fragmentSuffix,
+            }),
+            kind: 'type',
+        });
+    }
+    else if (possibleTypes.length > 0) {
+        const typesToImport = usedTypes && usedTypes.length > 0 ? usedTypes : possibleTypes;
+        typesToImport.forEach(typeName => {
+            fragmentImports.push({
+                name: baseVisitor.convertName(fragmentName, {
+                    useTypesPrefix: true,
+                    suffix: `_${typeName}` + (fragmentSuffix.length > 0 ? `_${fragmentSuffix}` : ''),
+                }),
+                kind: 'type',
+            });
+        });
+    }
+    return fragmentImports;
+}
+/**
+ * Used by `buildFragmentResolver` to build a mapping of fragmentNames to paths, importNames, and other useful info
+ *
+ * KEY DIFFERENCE from near-operation-file:
+ * The filePath is generated based on the fragment NAME, not the source file location
+ */
+function buildFragmentRegistry(baseVisitor, { folder, extension }, { documents }, schemaObject) {
+    const duplicateFragmentNames = [];
+    const registry = documents.reduce((prev, documentRecord) => {
+        const fragments = documentRecord.document.definitions.filter(d => d.kind === Kind.FRAGMENT_DEFINITION);
+        for (const fragment of fragments) {
+            const schemaType = schemaObject.getType(fragment.typeCondition.name.value);
+            if (!schemaType) {
+                throw new Error(`Fragment "${fragment.name.value}" is set on non-existing type "${fragment.typeCondition.name.value}"!`);
+            }
+            const fragmentName = fragment.name.value;
+            // KEY CHANGE: Generate path based on fragment name, not source file
+            const filePath = generateOperationFilePath(documentRecord.location, fragmentName, folder, extension);
+            const possibleTypes = getPossibleTypes(schemaObject, schemaType);
+            const possibleTypeNames = possibleTypes.map(t => t.name);
+            const imports = createFragmentImports(baseVisitor, fragment.name.value, possibleTypeNames);
+            if (prev[fragmentName] && print(fragment) !== print(prev[fragmentName].node)) {
+                duplicateFragmentNames.push(fragmentName);
+            }
+            prev[fragmentName] = {
+                filePath,
+                imports,
+                onType: fragment.typeCondition.name.value,
+                node: fragment,
+                possibleTypes: possibleTypeNames,
+            };
+        }
+        return prev;
+    }, {});
+    if (duplicateFragmentNames.length) {
+        throw new Error(`Multiple fragments with the name(s) "${duplicateFragmentNames.join(', ')}" were found.`);
+    }
+    return registry;
+}
+/**
+ * Creates a BaseVisitor with standard configuration
+ */
+function createBaseVisitor(config, schemaObject) {
+    return new BaseVisitor(config, {
+        scalars: buildScalarsFromConfig(schemaObject, config),
+        dedupeOperationSuffix: getConfigValue(config.dedupeOperationSuffix, false),
+        omitOperationSuffix: getConfigValue(config.omitOperationSuffix, false),
+        fragmentVariablePrefix: getConfigValue(config.fragmentVariablePrefix, ''),
+        fragmentVariableSuffix: getConfigValue(config.fragmentVariableSuffix, 'FragmentDoc'),
+    });
+}
+/**
+ * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
+ */
+export default function buildFragmentResolver(collectorOptions, presetOptions, schemaObject, dedupeFragments = false) {
+    const { config } = presetOptions;
+    const baseVisitor = createBaseVisitor(config, schemaObject);
+    const fragmentRegistry = buildFragmentRegistry(baseVisitor, collectorOptions, presetOptions, schemaObject);
+    const { baseOutputDir } = presetOptions;
+    const { baseDir, typesImport } = collectorOptions;
+    function resolveFragments(generatedFilePath, documentFileContent) {
+        const { fragmentsInUse, usedFragmentTypes } = analyzeFragmentUsage(documentFileContent, fragmentRegistry, schemaObject);
+        const externalFragments = [];
+        const fragmentFileImports = {};
+        for (const [fragmentName, level] of Object.entries(fragmentsInUse)) {
+            const fragmentDetails = fragmentRegistry[fragmentName];
+            if (!fragmentDetails)
+                continue;
+            // add top level references to the import object
+            // we don't check or global namespace because the calling config can do so
+            if (level === 0 ||
+                (dedupeFragments &&
+                    ['OperationDefinition', 'FragmentDefinition'].includes(documentFileContent.definitions[0].kind))) {
+                if (fragmentDetails.filePath !== generatedFilePath) {
+                    // don't emit imports to same location
+                    const usedTypesForFragment = usedFragmentTypes[fragmentName] || [];
+                    const filteredImports = createFragmentImports(baseVisitor, fragmentName, fragmentDetails.possibleTypes, usedTypesForFragment);
+                    if (!fragmentFileImports[fragmentDetails.filePath]) {
+                        fragmentFileImports[fragmentDetails.filePath] = [];
+                    }
+                    fragmentFileImports[fragmentDetails.filePath].push(...filteredImports);
+                }
+            }
+            externalFragments.push({
+                level,
+                isExternal: true,
+                name: fragmentName,
+                onType: fragmentDetails.onType,
+                node: fragmentDetails.node,
+            });
+        }
+        return {
+            externalFragments,
+            fragmentImports: Object.entries(fragmentFileImports).map(([fragmentsFilePath, identifiers]) => ({
+                baseDir,
+                baseOutputDir,
+                outputPath: generatedFilePath,
+                importSource: {
+                    path: fragmentsFilePath,
+                    identifiers,
+                },
+                emitLegacyCommonJSImports: presetOptions.config.emitLegacyCommonJSImports,
+                importExtension: presetOptions.config.importExtension,
+                typesImport,
+            })),
+        };
+    }
+    return resolveFragments;
+}

package/esm/index.js

@@ -0,0 +1,107 @@
+import { join } from 'path';
+import { buildASTSchema, Kind } from 'graphql';
+import addPlugin from '@graphql-codegen/add';
+import { getConfigValue, } from '@graphql-codegen/visitor-plugin-common';
+import { resolveDocumentImports } from './resolve-document-imports.js';
+import { generateOperationFilePath } from './utils.js';
+/**
+ * Extract operation and fragment names from a document
+ */
+function extractDefinitions(document) {
+    const definitions = [];
+    for (const def of document.definitions) {
+        if (def.kind === Kind.OPERATION_DEFINITION && def.name) {
+            definitions.push({ name: def.name.value, definition: def });
+        }
+        else if (def.kind === Kind.FRAGMENT_DEFINITION) {
+            definitions.push({ name: def.name.value, definition: def });
+        }
+    }
+    return definitions;
+}
+export const preset = {
+    buildGeneratesSection: options => {
+        var _a;
+        const schemaObject = options.schemaAst
+            ? options.schemaAst
+            : buildASTSchema(options.schema, options.config);
+        const baseDir = options.presetConfig.cwd || process.cwd();
+        const extension = options.presetConfig.extension || '.ts';
+        const folder = options.presetConfig.folder || '__generated__';
+        const importTypesNamespace = options.presetConfig.importTypesNamespace || 'Types';
+        const { baseTypesPath } = options.presetConfig;
+        if (!baseTypesPath) {
+            throw new Error(`Preset "per-operation-file" requires you to specify "baseTypesPath" configuration!`);
+        }
+        const shouldAbsolute = !baseTypesPath.startsWith('~');
+        const pluginMap = {
+            ...options.pluginMap,
+            add: addPlugin,
+        };
+        // Resolve fragment dependencies using our adapted fragment resolver
+        // Fragment paths will be generated based on fragment names
+        const sources = resolveDocumentImports(options, schemaObject, {
+            baseDir,
+            folder,
+            extension,
+            schemaTypesSource: {
+                path: shouldAbsolute ? join(options.baseOutputDir, baseTypesPath) : baseTypesPath,
+                namespace: importTypesNamespace,
+            },
+            typesImport: (_a = options.config.useTypeImports) !== null && _a !== void 0 ? _a : false,
+        }, getConfigValue(options.config.dedupeFragments, false));
+        const artifacts = [];
+        // Now split each source into separate files per operation/fragment
+        for (const source of sources) {
+            const definitions = extractDefinitions(source.documents[0].document);
+            for (const { name, definition } of definitions) {
+                const filename = generateOperationFilePath(source.documents[0].location, name, folder, extension);
+                // Create a document with just this operation/fragment
+                const singleDefDocument = {
+                    kind: Kind.DOCUMENT,
+                    definitions: [definition],
+                };
+                const singleDefSource = {
+                    rawSDL: source.documents[0].rawSDL, // TODO: might need to filter this
+                    document: singleDefDocument,
+                    location: source.documents[0].location,
+                };
+                // Update fragment imports to use the correct output path for this operation
+                const updatedFragmentImports = source.fragmentImports.map(fragmentImport => ({
+                    ...fragmentImport,
+                    outputPath: filename, // Update to actual output path
+                }));
+                const plugins = [
+                    ...(options.config.globalNamespace
+                        ? []
+                        : source.importStatements.map(importStatement => ({
+                            add: { content: importStatement },
+                        }))),
+                    ...options.plugins,
+                ];
+                const config = {
+                    ...options.config,
+                    exportFragmentSpreadSubTypes: true,
+                    namespacedImportName: importTypesNamespace,
+                    externalFragments: source.externalFragments,
+                    fragmentImports: updatedFragmentImports,
+                };
+                artifacts.push({
+                    ...options,
+                    filename,
+                    documents: [singleDefSource],
+                    plugins,
+                    pluginMap,
+                    config,
+                    schema: options.schema,
+                    schemaAst: schemaObject,
+                    skipDocumentsValidation: typeof options.config.skipDocumentsValidation === 'undefined'
+                        ? { skipDuplicateValidation: true }
+                        : options.config.skipDocumentsValidation,
+                });
+            }
+        }
+        return artifacts;
+    },
+};
+export default preset;

package/esm/resolve-document-imports.js

@@ -0,0 +1,54 @@
+import { isUsingTypes } from '@graphql-codegen/plugin-helpers';
+import { generateImportStatement, resolveImportSource, } from '@graphql-codegen/visitor-plugin-common';
+import buildFragmentResolver from './fragment-resolver.js';
+/**
+ * Transform the preset's provided documents into single-file generator sources, while resolving fragment and user-defined imports
+ *
+ * Resolves user provided imports and fragment imports using the `DocumentImportResolverOptions`.
+ * Does not define specific plugins, but rather returns a string[] of `importStatements` for the calling plugin to make use of
+ */
+export function resolveDocumentImports(presetOptions, schemaObject, importResolverOptions, dedupeFragments = false) {
+    const resolveFragments = buildFragmentResolver(importResolverOptions, presetOptions, schemaObject, dedupeFragments);
+    const { baseOutputDir, documents } = presetOptions;
+    const { schemaTypesSource, baseDir, typesImport } = importResolverOptions;
+    return documents.map(documentFile => {
+        try {
+            // NOTE: We pass a placeholder filename here since we'll generate proper filenames per-operation later
+            // The important part is that fragment resolution will use the correct paths from the registry
+            const placeholderFilePath = documentFile.location;
+            const importStatements = [];
+            const { externalFragments, fragmentImports } = resolveFragments(placeholderFilePath, documentFile.document);
+            const externalFragmentsInjectedDocument = {
+                ...documentFile.document,
+                definitions: [
+                    ...documentFile.document.definitions,
+                    ...externalFragments.map(fragment => fragment.node),
+                ],
+            };
+            if (isUsingTypes(externalFragmentsInjectedDocument, [], schemaObject)) {
+                const schemaTypesImportStatement = generateImportStatement({
+                    baseDir,
+                    emitLegacyCommonJSImports: presetOptions.config.emitLegacyCommonJSImports,
+                    importExtension: presetOptions.config.importExtension,
+                    importSource: resolveImportSource(schemaTypesSource),
+                    baseOutputDir,
+                    outputPath: placeholderFilePath,
+                    typesImport,
+                });
+                importStatements.unshift(schemaTypesImportStatement);
+            }
+            return {
+                filename: placeholderFilePath,
+                documents: [documentFile],
+                importStatements,
+                fragmentImports,
+                externalFragments,
+            };
+        }
+        catch (e) {
+            throw new Error(`Unable to validate GraphQL document! \n
+         File ${documentFile.location} caused error:
+         ${e.message || e.toString()}`);
+        }
+    });
+}

package/esm/utils.js

@@ -0,0 +1,115 @@
+import { join, dirname } from 'path';
+import { isInterfaceType, isObjectType, isUnionType, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { getPossibleTypes, separateSelectionSet } from '@graphql-codegen/visitor-plugin-common';
+/**
+ * Generate output file path for a specific operation/fragment
+ */
+export function generateOperationFilePath(sourceLocation, operationName, folder, extension) {
+    const dir = dirname(sourceLocation);
+    return join(dir, folder, `${operationName}${extension}`).replace(/\\/g, '/');
+}
+/**
+ * Analyzes fragment usage in a GraphQL document.
+ * Returns information about which fragments are used and which specific types they're used with.
+ */
+export function analyzeFragmentUsage(documentNode, fragmentRegistry, schema) {
+    const localFragments = getLocalFragments(documentNode);
+    const fragmentsInUse = extractExternalFragmentsInUse(documentNode, fragmentRegistry, localFragments);
+    const usedFragmentTypes = analyzeFragmentTypeUsage(documentNode, fragmentRegistry, schema, localFragments, fragmentsInUse);
+    return { fragmentsInUse, usedFragmentTypes };
+}
+/**
+ * Get all fragment definitions that are local to this document
+ */
+function getLocalFragments(documentNode) {
+    const localFragments = new Set();
+    visit(documentNode, {
+        FragmentDefinition: node => {
+            localFragments.add(node.name.value);
+        },
+    });
+    return localFragments;
+}
+export function extractExternalFragmentsInUse(documentNode, fragmentNameToFile, localFragment, result = {}, level = 0) {
+    // Then, look for all used fragments in this document
+    visit(documentNode, {
+        FragmentSpread: node => {
+            if (!localFragment.has(node.name.value) &&
+                (result[node.name.value] === undefined || level < result[node.name.value])) {
+                result[node.name.value] = level;
+                if (fragmentNameToFile[node.name.value]) {
+                    extractExternalFragmentsInUse(fragmentNameToFile[node.name.value].node, fragmentNameToFile, localFragment, result, level + 1);
+                }
+            }
+        },
+    });
+    return result;
+}
+/**
+ * Analyze which specific types each fragment is used with (for polymorphic fragments)
+ */
+function analyzeFragmentTypeUsage(documentNode, fragmentRegistry, schema, localFragments, fragmentsInUse) {
+    const usedFragmentTypes = {};
+    const typeInfo = new TypeInfo(schema);
+    visit(documentNode, visitWithTypeInfo(typeInfo, {
+        Field: (node) => {
+            if (!node.selectionSet)
+                return;
+            const fieldType = typeInfo.getType();
+            if (!fieldType)
+                return;
+            const baseType = getBaseType(fieldType);
+            if (isObjectType(baseType) || isInterfaceType(baseType) || isUnionType(baseType)) {
+                analyzeSelectionSetTypeContext(node.selectionSet, baseType.name, usedFragmentTypes, fragmentRegistry, schema, localFragments);
+            }
+        },
+    }));
+    const result = {};
+    // Fill in missing types for multi-type fragments
+    for (const fragmentName in fragmentsInUse) {
+        const fragment = fragmentRegistry[fragmentName];
+        if (!fragment || fragment.possibleTypes.length <= 1)
+            continue;
+        const usedTypes = usedFragmentTypes[fragmentName];
+        result[fragmentName] = (usedTypes === null || usedTypes === void 0 ? void 0 : usedTypes.size) > 0 ? Array.from(usedTypes) : fragment.possibleTypes;
+    }
+    return result;
+}
+/**
+ * Analyze fragment usage within a specific selection set and type context
+ */
+function analyzeSelectionSetTypeContext(selectionSet, currentTypeName, usedFragmentTypes, fragmentRegistry, schema, localFragments) {
+    var _a, _b;
+    var _c;
+    const { spreads, inlines } = separateSelectionSet(selectionSet.selections);
+    // Process fragment spreads in this type context
+    for (const spread of spreads) {
+        if (localFragments.has(spread.name.value))
+            continue;
+        const fragment = fragmentRegistry[spread.name.value];
+        if (!fragment || fragment.possibleTypes.length <= 1)
+            continue;
+        const currentType = schema.getType(currentTypeName);
+        if (!currentType)
+            continue;
+        const possibleTypes = getPossibleTypes(schema, currentType).map(t => t.name);
+        const matchingTypes = possibleTypes.filter(type => fragment.possibleTypes.includes(type));
+        if (matchingTypes.length > 0) {
+            const typeSet = ((_a = usedFragmentTypes[_c = spread.name.value]) !== null && _a !== void 0 ? _a : (usedFragmentTypes[_c] = new Set()));
+            matchingTypes.forEach(type => typeSet.add(type));
+        }
+    }
+    // Process inline fragments
+    for (const inline of inlines) {
+        if (((_b = inline.typeCondition) === null || _b === void 0 ? void 0 : _b.name.value) && inline.selectionSet) {
+            analyzeSelectionSetTypeContext(inline.selectionSet, inline.typeCondition.name.value, usedFragmentTypes, fragmentRegistry, schema, localFragments);
+        }
+    }
+}
+function getBaseType(type) {
+    let baseType = type;
+    while ('ofType' in baseType && baseType.ofType) {
+        baseType = baseType.ofType;
+    }
+    return baseType;
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@nmarks/graphql-codegen-per-operation-file-preset",
+  "version": "1.0.0",
+  "description": "GraphQL Code Generator preset for generating one file per operation/fragment",
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-codegen/add": "^6.0.0",
+    "@graphql-codegen/plugin-helpers": "^6.1.0",
+    "@graphql-codegen/visitor-plugin-common": "^6.2.1",
+    "@graphql-tools/utils": "^10.0.0",
+    "tslib": "^2.8.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/graphql-code-generator-community.git",
+    "directory": "packages/presets/per-operation-file"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/fragment-resolver.d.cts

@@ -0,0 +1,29 @@
+import { DocumentNode, FragmentDefinitionNode, GraphQLSchema } from 'graphql';
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { FragmentImport, ImportDeclaration, LoadedFragment, ParsedConfig } from '@graphql-codegen/visitor-plugin-common';
+import { DocumentImportResolverOptions } from './resolve-document-imports.cjs';
+export interface PerOperationFileParsedConfig extends ParsedConfig {
+    importTypesNamespace?: string;
+    dedupeOperationSuffix: boolean;
+    omitOperationSuffix: boolean;
+    fragmentVariablePrefix: string;
+    fragmentVariableSuffix: string;
+}
+export type FragmentRegistry = {
+    [fragmentName: string]: {
+        filePath: string;
+        onType: string;
+        node: FragmentDefinitionNode;
+        imports: Array<FragmentImport>;
+        possibleTypes: string[];
+    };
+};
+/**
+ * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
+ */
+export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): (generatedFilePath: string, documentFileContent: DocumentNode) => {
+    externalFragments: LoadedFragment<{
+        level: number;
+    }>[];
+    fragmentImports: ImportDeclaration<FragmentImport>[];
+};

package/typings/fragment-resolver.d.ts

@@ -0,0 +1,29 @@
+import { DocumentNode, FragmentDefinitionNode, GraphQLSchema } from 'graphql';
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { FragmentImport, ImportDeclaration, LoadedFragment, ParsedConfig } from '@graphql-codegen/visitor-plugin-common';
+import { DocumentImportResolverOptions } from './resolve-document-imports.js';
+export interface PerOperationFileParsedConfig extends ParsedConfig {
+    importTypesNamespace?: string;
+    dedupeOperationSuffix: boolean;
+    omitOperationSuffix: boolean;
+    fragmentVariablePrefix: string;
+    fragmentVariableSuffix: string;
+}
+export type FragmentRegistry = {
+    [fragmentName: string]: {
+        filePath: string;
+        onType: string;
+        node: FragmentDefinitionNode;
+        imports: Array<FragmentImport>;
+        possibleTypes: string[];
+    };
+};
+/**
+ * Builds a fragment "resolver" that collects `externalFragments` definitions and `fragmentImportStatements`
+ */
+export default function buildFragmentResolver<T>(collectorOptions: DocumentImportResolverOptions, presetOptions: Types.PresetFnArgs<T>, schemaObject: GraphQLSchema, dedupeFragments?: boolean): (generatedFilePath: string, documentFileContent: DocumentNode) => {
+    externalFragments: LoadedFragment<{
+        level: number;
+    }>[];
+    fragmentImports: ImportDeclaration<FragmentImport>[];
+};

package/typings/index.d.cts

@@ -0,0 +1,131 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export type PerOperationFileConfig = {
+    /**
+     * @description Required, should point to the base schema types file.
+     * The key of the output is used a the base path for this file.
+     *
+     * If you wish to use an NPM package or a local workspace package, make sure to prefix the package name with `~`.
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts'
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    baseTypesPath: string;
+    /**
+     * @description Optional, sets the extension for the generated files.
+     * @default .ts
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          extension: '.generated.ts',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    extension?: string;
+    /**
+     * @description Optional, override the `cwd` of the execution.
+     * @default process.cwd()
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          cwd: '/some/path'
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    cwd?: string;
+    /**
+     * @description Optional, defines a folder where the generated files will be created.
+     * @default '__generated__'
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          folder: '__generated__'
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    folder?: string;
+    /**
+     * @description Optional, override the name of the import namespace used to import from the `baseTypesPath` file.
+     * @default Types
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          importTypesNamespace: 'SchemaTypes'
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    importTypesNamespace?: string;
+};
+export declare const preset: Types.OutputPreset<PerOperationFileConfig>;
+export default preset;