@graphql-codegen/typescript-operations 6.0.0-alpha-20251125123407-8babe46fb9b33e9f9a377cd50c9580282e7981d3 → 6.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f

package/esm/visitor.js

@@ -1,10 +1,12 @@
-import { BaseDocumentsVisitor, generateFragmentImportStatement, getConfigValue, normalizeAvoidOptionals, PreResolveTypesProcessor, SelectionSetToObject, wrapTypeWithModifiers, } from '@graphql-codegen/visitor-plugin-common';
+import { BaseDocumentsVisitor, convertSchemaEnumToDeclarationBlockString, DeclarationBlock, generateFragmentImportStatement, generateImportStatement, getConfigValue, indent, isOneOfInputObjectType, getEnumsImports, isNativeNamedType, normalizeAvoidOptionals, parseEnumValues, PreResolveTypesProcessor, SelectionSetToObject, getNodeComment, wrapTypeWithModifiers, } from '@graphql-codegen/visitor-plugin-common';
 import autoBind from 'auto-bind';
-import { isEnumType, isNonNullType } from 'graphql';
-import { TypeScriptOperationVariablesToObject } from './ts-operation-variables-to-object.js';
+import { getNamedType, GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType, isEnumType, Kind, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { TypeScriptOperationVariablesToObject, SCALARS } from './ts-operation-variables-to-object.js';
 import { TypeScriptSelectionSetProcessor } from './ts-selection-set-processor.js';
 export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor {
-    constructor(schema, config, allFragments) {
+    _usedNamedInputTypes = {};
+    _outputPath;
+    constructor(schema, config, documentNode, outputPath) {
         super(config, {
             arrayInputCoercion: getConfigValue(config.arrayInputCoercion, true),
             noExport: getConfigValue(config.noExport, false),
@@ -14,7 +16,15 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor {
             preResolveTypes: getConfigValue(config.preResolveTypes, true),
             mergeFragmentTypes: getConfigValue(config.mergeFragmentTypes, false),
             allowUndefinedQueryVariables: getConfigValue(config.allowUndefinedQueryVariables, false),
+            enumType: getConfigValue(config.enumType, 'string-literal'),
+            enumValues: parseEnumValues({
+                schema,
+                mapOrStr: config.enumValues,
+                ignoreEnumValuesFromSchema: config.ignoreEnumValuesFromSchema,
+            }),
+            futureProofEnums: getConfigValue(config.futureProofEnums, false),
         }, schema);
+        this._outputPath = outputPath;
         autoBind(this);
         const preResolveTypes = getConfigValue(config.preResolveTypes, true);
         const defaultMaybeValue = 'T | null';
@@ -30,43 +40,348 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor {
             const listModifier = this.config.immutableTypes ? 'ReadonlyArray' : 'Array';
             return `${listModifier}<${type}>`;
         };
-        const formatNamedField = (name, type, isConditional = false, isOptional = false) => {
-            const optional = isOptional || isConditional || (!this.config.avoidOptionals.field && !!type && !isNonNullType(type));
-            return (this.config.immutableTypes ? `readonly ${name}` : name) + (optional ? '?' : '');
-        };
+        const allFragments = [
+            ...documentNode.definitions.filter(d => d.kind === Kind.FRAGMENT_DEFINITION).map(fragmentDef => ({
+                node: fragmentDef,
+                name: fragmentDef.name.value,
+                onType: fragmentDef.typeCondition.name.value,
+                isExternal: false,
+            })),
+            ...(config.externalFragments || []),
+        ];
+        this._usedNamedInputTypes = this.collectUsedInputTypes({ schema, documentNode });
         const processorConfig = {
             namespacedImportName: this.config.namespacedImportName,
             convertName: this.convertName.bind(this),
             enumPrefix: this.config.enumPrefix,
             enumSuffix: this.config.enumSuffix,
             scalars: this.scalars,
-            formatNamedField,
+            formatNamedField: ({ name, isOptional }) => {
+                return (this.config.immutableTypes ? `readonly ${name}` : name) + (isOptional ? '?' : '');
+            },
             wrapTypeWithModifiers(baseType, type) {
                 return wrapTypeWithModifiers(baseType, type, { wrapOptional, wrapArray });
             },
-            avoidOptionals: this.config.avoidOptionals,
             printFieldsOnNewLines: this.config.printFieldsOnNewLines,
         };
         const processor = new (preResolveTypes ? PreResolveTypesProcessor : TypeScriptSelectionSetProcessor)(processorConfig);
         this.setSelectionSetHandler(new SelectionSetToObject(processor, this.scalars, this.schema, this.convertName.bind(this), this.getFragmentSuffix.bind(this), allFragments, this.config));
         const enumsNames = Object.keys(schema.getTypeMap()).filter(typeName => isEnumType(schema.getType(typeName)));
-        this.setVariablesTransformer(new TypeScriptOperationVariablesToObject(this.scalars, this.convertName.bind(this), this.config.avoidOptionals, this.config.immutableTypes, this.config.namespacedImportName, enumsNames, this.config.enumPrefix, this.config.enumSuffix, this.config.enumValues, this.config.arrayInputCoercion, undefined, 'InputMaybe'));
+        this.setVariablesTransformer(new TypeScriptOperationVariablesToObject(this.scalars, this.convertName.bind(this), 
+        // FIXME: this is the legacy avoidOptionals which was used to make Result fields non-optional. This use case is no longer valid.
+        // It's also being used for Variables so people could already be using it.
+        // Maybe it's better to deprecate and remove, to see what users think.
+        this.config.avoidOptionals, this.config.immutableTypes, this.config.namespacedImportName, enumsNames, this.config.enumPrefix, this.config.enumSuffix, this.config.enumValues, this.config.arrayInputCoercion, undefined, undefined));
         this._declarationBlockConfig = {
             ignoreExport: this.config.noExport,
+            enumNameValueSeparator: ' =',
         };
     }
+    EnumTypeDefinition(node) {
+        const enumName = node.name.value;
+        if (!this._usedNamedInputTypes[enumName] || this.config.importSchemaTypesFrom) {
+            return null;
+        }
+        return convertSchemaEnumToDeclarationBlockString({
+            schema: this._schema,
+            node,
+            declarationBlockConfig: this._declarationBlockConfig,
+            enumName,
+            enumValues: this.config.enumValues,
+            futureProofEnums: this.config.futureProofEnums,
+            ignoreEnumValuesFromSchema: this.config.ignoreEnumValuesFromSchema,
+            outputType: this.config.enumType,
+            naming: {
+                convert: this.config.convert,
+                typesPrefix: this.config.typesPrefix,
+                typesSuffix: this.config.typesSuffix,
+                useTypesPrefix: this.config.enumPrefix,
+                useTypesSuffix: this.config.enumSuffix,
+            },
+        });
+    }
+    InputObjectTypeDefinition(node) {
+        const inputTypeName = node.name.value;
+        if (!this._usedNamedInputTypes[inputTypeName]) {
+            return null;
+        }
+        if (isOneOfInputObjectType(this._schema.getType(inputTypeName))) {
+            return new DeclarationBlock(this._declarationBlockConfig)
+                .asKind('type')
+                .withName(this.convertName(node))
+                .withComment(node.description?.value)
+                .withContent(`\n` + (node.fields || []).join('\n  |')).string;
+        }
+        return new DeclarationBlock(this._declarationBlockConfig)
+            .asKind('type')
+            .withName(this.convertName(node))
+            .withComment(node.description?.value)
+            .withBlock((node.fields || []).join('\n')).string;
+    }
+    InputValueDefinition(node, _key, _parent, _path, ancestors) {
+        const oneOfDetails = parseOneOfInputValue({
+            node,
+            schema: this._schema,
+            ancestors,
+        });
+        // 1. Flatten GraphQL type nodes to make it easier to turn into string
+        // GraphQL type nodes may have `NonNullType` type before each `ListType` or `NamedType`
+        // This make it a bit harder to know whether a `ListType` or `Namedtype` is nullable without looking at the node before it.
+        // Flattening it into an array where the nullability is in `ListType` and `NamedType` makes it easier to code,
+        //
+        // So, we recursively call `collectAndFlattenTypeNodes` to handle the following scenarios:
+        // - [Thing]
+        // - [Thing!]
+        // - [Thing]!
+        // - [Thing!]!
+        const typeNodes = [];
+        collectAndFlattenTypeNodes({
+            currentTypeNode: node.type,
+            isPreviousNodeNonNullable: oneOfDetails.isOneOfInputValue, // If the InputValue is part of @oneOf input, we treat it as non-null (even if it must be null in the schema)
+            typeNodes,
+        });
+        // 2. Generate the type of a TypeScript field declaration
+        // e.g. `field?: string`, then the `string` is the `typePart`
+        let typePart = '';
+        // We call `.reverse()` here to get the base type node first
+        for (const typeNode of typeNodes.reverse()) {
+            if (typeNode.type === 'NamedType') {
+                const usedInputType = this._usedNamedInputTypes[typeNode.name];
+                if (!usedInputType) {
+                    continue;
+                }
+                typePart = usedInputType.tsType; // If the schema is correct, when reversing typeNodes, the first node would be `NamedType`, which means we can safely set it as the base for typePart
+                if (usedInputType.tsType !== 'any' && !typeNode.isNonNullable) {
+                    typePart += ' | null | undefined';
+                }
+                continue;
+            }
+            if (typeNode.type === 'ListType') {
+                typePart = `Array<${typePart}>`;
+                if (!typeNode.isNonNullable) {
+                    typePart += ' | null | undefined';
+                }
+            }
+        }
+        // TODO: eddeee888 check if we want to support `directiveArgumentAndInputFieldMappings` for operations
+        // if (node.directives && this.config.directiveArgumentAndInputFieldMappings) {
+        //   typePart =
+        //     getDirectiveOverrideType({
+        //       directives: node.directives,
+        //       directiveArgumentAndInputFieldMappings: this.config.directiveArgumentAndInputFieldMappings,
+        //     }) || typePart;
+        // }
+        const addOptionalSign = !oneOfDetails.isOneOfInputValue &&
+            !this.config.avoidOptionals.inputValue &&
+            (node.type.kind !== Kind.NON_NULL_TYPE ||
+                (!this.config.avoidOptionals.defaultValue && node.defaultValue !== undefined));
+        // 3. Generate the keyPart of the TypeScript field declaration
+        // e.g. `field?: string`, then the `field?` is the `keyPart`
+        const keyPart = `${node.name.value}${addOptionalSign ? '?' : ''}`;
+        // 4. other parts of TypeScript field declaration
+        const commentPart = getNodeComment(node);
+        const readonlyPart = this.config.immutableTypes ? 'readonly ' : '';
+        const currentInputValue = commentPart + indent(`${readonlyPart}${keyPart}: ${typePart};`);
+        // 5. Check if field is part of `@oneOf` input type
+        // If yes, we must generate a union member where the current inputValue must be provieded, and the others are not
+        // e.g.
+        // ```graphql
+        // input UserInput {
+        //   byId: ID
+        //   byEmail: String
+        //   byLegacyId: ID
+        // }
+        // ```
+        //
+        // Then, the generated type is:
+        // ```ts
+        // type UserInput =
+        //   | { byId: string | number; byEmail?: never; byLegacyId?: never }
+        //   | { byId?: never; byEmail: string; byLegacyId?: never }
+        //   | { byId?: never; byEmail?: never; byLegacyId: string | number }
+        // ```
+        if (oneOfDetails.isOneOfInputValue) {
+            const fieldParts = [];
+            for (const fieldName of Object.keys(oneOfDetails.parentType.getFields())) {
+                if (fieldName === node.name.value) {
+                    fieldParts.push(currentInputValue);
+                    continue;
+                }
+                fieldParts.push(`${readonlyPart}${fieldName}?: never;`);
+            }
+            return indent(`{ ${fieldParts.join(' ')} }`);
+        }
+        // If field is not part of @oneOf input type, then it's a input value, just return as-is
+        return currentInputValue;
+    }
     getImports() {
         return !this.config.globalNamespace &&
             (this.config.inlineFragmentTypes === 'combine' || this.config.inlineFragmentTypes === 'mask')
             ? this.config.fragmentImports.map(fragmentImport => generateFragmentImportStatement(fragmentImport, 'type'))
             : [];
     }
+    getExternalSchemaTypeImports() {
+        if (!this.config.importSchemaTypesFrom) {
+            return [];
+        }
+        const hasTypesToImport = Object.keys(this._usedNamedInputTypes).length > 0;
+        if (!hasTypesToImport) {
+            return [];
+        }
+        return [
+            generateImportStatement({
+                baseDir: process.cwd(),
+                baseOutputDir: '',
+                outputPath: this._outputPath,
+                importSource: {
+                    path: this.config.importSchemaTypesFrom,
+                    namespace: this.config.namespacedImportName,
+                    identifiers: [],
+                },
+                typesImport: true,
+                // FIXME: rebase with master for the new extension
+                emitLegacyCommonJSImports: true,
+            }),
+        ];
+    }
     getPunctuation(_declarationKind) {
         return ';';
     }
     applyVariablesWrapper(variablesBlock, operationType) {
-        const prefix = this.config.namespacedImportName ? `${this.config.namespacedImportName}.` : '';
         const extraType = this.config.allowUndefinedQueryVariables && operationType === 'Query' ? ' | undefined' : '';
-        return `${prefix}Exact<${variablesBlock === '{}' ? `{ [key: string]: never; }` : variablesBlock}>${extraType}`;
+        return `Exact<${variablesBlock === '{}' ? `{ [key: string]: never; }` : variablesBlock}>${extraType}`;
+    }
+    collectInnerTypesRecursively(node, usedInputTypes) {
+        if (usedInputTypes[node.name]) {
+            return;
+        }
+        if (node instanceof GraphQLEnumType) {
+            usedInputTypes[node.name] = {
+                type: 'GraphQLEnumType',
+                node,
+                tsType: this.convertName(node.name),
+            };
+            return;
+        }
+        if (node instanceof GraphQLScalarType) {
+            usedInputTypes[node.name] = {
+                type: 'GraphQLScalarType',
+                node,
+                tsType: (SCALARS[node.name] || this.config.scalars?.[node.name]?.input.type) ?? 'any',
+            };
+            return;
+        }
+        // GraphQLInputObjectType
+        usedInputTypes[node.name] = {
+            type: 'GraphQLInputObjectType',
+            node,
+            tsType: this.convertName(node.name),
+        };
+        const fields = node.getFields();
+        for (const field of Object.values(fields)) {
+            const fieldType = getNamedType(field.type);
+            this.collectInnerTypesRecursively(fieldType, usedInputTypes);
+        }
+    }
+    collectUsedInputTypes({ schema, documentNode, }) {
+        const schemaTypes = schema.getTypeMap();
+        const usedInputTypes = {};
+        // Collect input enums and input types
+        visit(documentNode, {
+            VariableDefinition: variableDefinitionNode => {
+                visit(variableDefinitionNode, {
+                    NamedType: namedTypeNode => {
+                        const foundInputType = schemaTypes[namedTypeNode.name.value];
+                        if (foundInputType &&
+                            (foundInputType instanceof GraphQLInputObjectType ||
+                                foundInputType instanceof GraphQLScalarType ||
+                                foundInputType instanceof GraphQLEnumType) &&
+                            !isNativeNamedType(foundInputType)) {
+                            this.collectInnerTypesRecursively(foundInputType, usedInputTypes);
+                        }
+                    },
+                });
+            },
+        });
+        // Collect output enums
+        const typeInfo = new TypeInfo(schema);
+        visit(documentNode, 
+        // AST doesn’t include field types (they are defined in schema) - only names.
+        // TypeInfo is a stateful helper that tracks typing context while walking the AST
+        // visitWithTypeInfo wires that context into a visitor.
+        visitWithTypeInfo(typeInfo, {
+            Field: () => {
+                const fieldType = typeInfo.getType();
+                if (fieldType) {
+                    const namedType = getNamedType(fieldType);
+                    if (namedType instanceof GraphQLEnumType) {
+                        usedInputTypes[namedType.name] = {
+                            type: 'GraphQLEnumType',
+                            node: namedType,
+                            tsType: this.convertName(namedType.name),
+                        };
+                    }
+                }
+            },
+        }));
+        return usedInputTypes;
+    }
+    getEnumsImports() {
+        const usedEnumMap = {};
+        for (const [enumName, enumDetails] of Object.entries(this.config.enumValues)) {
+            if (this._usedNamedInputTypes[enumName]) {
+                usedEnumMap[enumName] = enumDetails;
+            }
+        }
+        return getEnumsImports({
+            enumValues: usedEnumMap,
+            useTypeImports: this.config.useTypeImports,
+        });
+    }
+    getExactUtilityType() {
+        if (!this.config.generatesOperationTypes) {
+            return null;
+        }
+        return 'type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };';
+    }
+    getIncrementalUtilityType() {
+        if (!this.config.generatesOperationTypes) {
+            return null;
+        }
+        // Note: `export` here is important for 2 reasons
+        // 1. It is not always used in the rest of the file, so this is a safe way to avoid lint rules (in tsconfig or eslint) complaining it's not used in the current file.
+        // 2. In Client Preset, it is used by fragment-masking.ts, so it needs `export`
+        return "export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };";
+    }
+}
+function parseOneOfInputValue({ node, schema, ancestors, }) {
+    const realParentDef = ancestors?.[ancestors.length - 1];
+    if (realParentDef) {
+        const parentType = schema.getType(realParentDef.name.value);
+        if (isOneOfInputObjectType(parentType)) {
+            if (node.type.kind === Kind.NON_NULL_TYPE) {
+                throw new Error('Fields on an input object type can not be non-nullable. It seems like the schema was not validated.');
+            }
+            return { isOneOfInputValue: true, realParentDef, parentType };
+        }
+    }
+    return { isOneOfInputValue: false };
+}
+function collectAndFlattenTypeNodes({ currentTypeNode, isPreviousNodeNonNullable, typeNodes, }) {
+    if (currentTypeNode.kind === Kind.NON_NULL_TYPE) {
+        const nextTypeNode = currentTypeNode.type;
+        collectAndFlattenTypeNodes({ currentTypeNode: nextTypeNode, isPreviousNodeNonNullable: true, typeNodes });
+    }
+    else if (currentTypeNode.kind === Kind.LIST_TYPE) {
+        typeNodes.push({ type: 'ListType', isNonNullable: isPreviousNodeNonNullable });
+        const nextTypeNode = currentTypeNode.type;
+        collectAndFlattenTypeNodes({ currentTypeNode: nextTypeNode, isPreviousNodeNonNullable: false, typeNodes });
+    }
+    else if (currentTypeNode.kind === Kind.NAMED_TYPE) {
+        typeNodes.push({
+            type: 'NamedType',
+            isNonNullable: isPreviousNodeNonNullable,
+            name: currentTypeNode.name.value,
+        });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-codegen/typescript-operations",
-  "version": "6.0.0-alpha-20251125123407-8babe46fb9b33e9f9a377cd50c9580282e7981d3",
+  "version": "6.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f",
   "description": "GraphQL Code Generator plugin for generating TypeScript types for GraphQL queries, mutations, subscriptions and fragments",
   "peerDependenciesMeta": {
     "graphql-sock": {
@@ -13,8 +13,9 @@
   },
   "dependencies": {
     "@graphql-codegen/plugin-helpers": "^6.0.0",
-    "@graphql-codegen/typescript": "6.0.0-alpha-20251125123407-8babe46fb9b33e9f9a377cd50c9580282e7981d3",
-    "@graphql-codegen/visitor-plugin-common": "7.0.0-alpha-20251125123407-8babe46fb9b33e9f9a377cd50c9580282e7981d3",
+    "@graphql-codegen/typescript": "6.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f",
+    "@graphql-codegen/schema-ast": "^5.0.0",
+    "@graphql-codegen/visitor-plugin-common": "7.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f",
     "auto-bind": "~4.0.0",
     "tslib": "~2.6.0"
   },

package/typings/config.d.cts

@@ -1,4 +1,4 @@
-import { AvoidOptionalsConfig, RawDocumentsConfig } from '@graphql-codegen/visitor-plugin-common';
+import { AvoidOptionalsConfig, type ConvertSchemaEnumToDeclarationBlockString, type EnumValuesMap, RawDocumentsConfig } from '@graphql-codegen/visitor-plugin-common';
 /**
  * @description This plugin generates TypeScript types based on your GraphQLSchema _and_ your GraphQL operations and fragments.
  * It generates types for your GraphQL documents: Query, Mutation, Subscription and Fragment.
@@ -330,4 +330,118 @@ export interface TypeScriptDocumentsPluginConfig extends RawDocumentsConfig {
     nullability?: {
         errorHandlingClient: boolean;
     };
+    /**
+     * @description Controls the enum output type. Options: `string-literal` | `native-numeric` | `const` | `native-const` | `native`;
+     * @default `string-literal`
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     * import type { CodegenConfig } from '@graphql-codegen/cli'
+     *
+     * const config: CodegenConfig = {
+     *   // ...
+     *   generates: {
+     *     'path/to/file.ts': {
+     *       plugins: ['typescript-operations'],
+     *       config: {
+     *         enumType: 'string-literal',
+     *       }
+     *     }
+     *   }
+     * }
+     * export default config
+     */
+    enumType?: ConvertSchemaEnumToDeclarationBlockString['outputType'];
+    /**
+     * @description Overrides the default value of enum values declared in your GraphQL schema.
+     * You can also map the entire enum to an external type by providing a string that of `module#type`.
+     *
+     * @exampleMarkdown
+     * ## With Custom Values
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: {
+     *              A: 'foo'
+     *            }
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     *
+     * ## With External Enum
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: './my-file#MyCustomEnum',
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     *
+     * ## Import All Enums from a file
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: './my-file',
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    enumValues?: EnumValuesMap;
+    /**
+     * @description This option controls whether or not a catch-all entry is added to enum type definitions for values that may be added in the future.
+     * This is useful if you are using `relay`.
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     * import type { CodegenConfig } from '@graphql-codegen/cli'
+     *
+     * const config: CodegenConfig = {
+     *   // ...
+     *   generates: {
+     *     'path/to/file.ts': {
+     *       plugins: ['typescript-operations'],
+     *       config: {
+     *         futureProofEnums: true
+     *       }
+     *     }
+     *   }
+     * }
+     * export default config
+     * ```
+     */
+    futureProofEnums?: boolean;
 }

package/typings/config.d.ts

@@ -1,4 +1,4 @@
-import { AvoidOptionalsConfig, RawDocumentsConfig } from '@graphql-codegen/visitor-plugin-common';
+import { AvoidOptionalsConfig, type ConvertSchemaEnumToDeclarationBlockString, type EnumValuesMap, RawDocumentsConfig } from '@graphql-codegen/visitor-plugin-common';
 /**
  * @description This plugin generates TypeScript types based on your GraphQLSchema _and_ your GraphQL operations and fragments.
  * It generates types for your GraphQL documents: Query, Mutation, Subscription and Fragment.
@@ -330,4 +330,118 @@ export interface TypeScriptDocumentsPluginConfig extends RawDocumentsConfig {
     nullability?: {
         errorHandlingClient: boolean;
     };
+    /**
+     * @description Controls the enum output type. Options: `string-literal` | `native-numeric` | `const` | `native-const` | `native`;
+     * @default `string-literal`
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     * import type { CodegenConfig } from '@graphql-codegen/cli'
+     *
+     * const config: CodegenConfig = {
+     *   // ...
+     *   generates: {
+     *     'path/to/file.ts': {
+     *       plugins: ['typescript-operations'],
+     *       config: {
+     *         enumType: 'string-literal',
+     *       }
+     *     }
+     *   }
+     * }
+     * export default config
+     */
+    enumType?: ConvertSchemaEnumToDeclarationBlockString['outputType'];
+    /**
+     * @description Overrides the default value of enum values declared in your GraphQL schema.
+     * You can also map the entire enum to an external type by providing a string that of `module#type`.
+     *
+     * @exampleMarkdown
+     * ## With Custom Values
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: {
+     *              A: 'foo'
+     *            }
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     *
+     * ## With External Enum
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: './my-file#MyCustomEnum',
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     *
+     * ## Import All Enums from a file
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file': {
+     *        // plugins...
+     *        config: {
+     *          enumValues: {
+     *            MyEnum: './my-file',
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    enumValues?: EnumValuesMap;
+    /**
+     * @description This option controls whether or not a catch-all entry is added to enum type definitions for values that may be added in the future.
+     * This is useful if you are using `relay`.
+     * @default false
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     * import type { CodegenConfig } from '@graphql-codegen/cli'
+     *
+     * const config: CodegenConfig = {
+     *   // ...
+     *   generates: {
+     *     'path/to/file.ts': {
+     *       plugins: ['typescript-operations'],
+     *       config: {
+     *         futureProofEnums: true
+     *       }
+     *     }
+     *   }
+     * }
+     * export default config
+     * ```
+     */
+    futureProofEnums?: boolean;
 }

package/typings/ts-operation-variables-to-object.d.cts

@@ -1,4 +1,11 @@
 import { TypeScriptOperationVariablesToObject as TSOperationVariablesToObject } from '@graphql-codegen/typescript';
+export declare const SCALARS: {
+    ID: string;
+    String: string;
+    Int: string;
+    Float: string;
+    Boolean: string;
+};
 export declare class TypeScriptOperationVariablesToObject extends TSOperationVariablesToObject {
     protected formatTypeString(fieldType: string, _isNonNullType: boolean, _hasDefaultValue: boolean): string;
     protected clearOptional(str: string): string;