@graphql-eslint/eslint-plugin 3.13.2-alpha-20221109140613-1815aa1 → 3.14.0-alpha-20221220004017-f1f0904

package/documents.d.ts

@@ -1,14 +1,14 @@
 import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode } from 'graphql';
 import { GraphQLProjectConfig } from 'graphql-config';
-export declare type FragmentSource = {
+export type FragmentSource = {
     filePath: string;
     document: FragmentDefinitionNode;
 };
-export declare type OperationSource = {
+export type OperationSource = {
     filePath: string;
     document: OperationDefinitionNode;
 };
-export declare type SiblingOperations = {
+export type SiblingOperations = {
     available: boolean;
     getFragment(fragmentName: string): FragmentSource[];
     getFragments(): FragmentSource[];

package/estree-converter/types.d.ts

@@ -1,15 +1,15 @@
 import type { ASTNode, TypeInfo, TypeNode, DocumentNode, ExecutableDefinitionNode, NameNode, TypeDefinitionNode, FieldDefinitionNode, ObjectTypeExtensionNode, ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, SelectionSetNode, SelectionNode, DefinitionNode, TypeExtensionNode, DirectiveDefinitionNode, VariableNode, FieldNode, FragmentSpreadNode, EnumValueDefinitionNode, ArgumentNode, NamedTypeNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, InputValueDefinitionNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InlineFragmentNode, VariableDefinitionNode, ListTypeNode, NonNullTypeNode, OperationTypeDefinitionNode } from 'graphql';
 import type { SourceLocation, Comment } from 'estree';
 import type { AST } from 'eslint';
-declare type SafeGraphQLType<T extends ASTNode> = T extends {
+type SafeGraphQLType<T extends ASTNode> = T extends {
     type: TypeNode;
 } ? Omit<T, 'loc' | 'type'> & {
     gqlType: T['type'];
 } : Omit<T, 'loc'>;
-declare type Writeable<T> = {
+type Writeable<T> = {
     -readonly [K in keyof T]: T[K];
 };
-export declare type TypeInformation = {
+export type TypeInformation = {
     argument: ReturnType<TypeInfo['getArgument']>;
     defaultValue: ReturnType<TypeInfo['getDefaultValue']>;
     directive: ReturnType<TypeInfo['getDirective']>;
@@ -20,10 +20,10 @@ export declare type TypeInformation = {
     parentType: ReturnType<TypeInfo['getParentType']>;
     gqlType: ReturnType<TypeInfo['getType']>;
 };
-declare type NodeWithName = TypeDefinitionNode | TypeExtensionNode | ExecutableDefinitionNode | DirectiveDefinitionNode | FieldDefinitionNode | EnumValueDefinitionNode | FieldNode | FragmentSpreadNode | VariableNode | ArgumentNode | NamedTypeNode;
-declare type NodeWithType = FieldDefinitionNode | InputValueDefinitionNode | OperationTypeDefinitionNode | NonNullTypeNode | ListTypeNode | VariableDefinitionNode;
-declare type ParentNode<T> = T extends DocumentNode ? AST.Program : T extends DefinitionNode ? DocumentNode : T extends EnumValueDefinitionNode ? EnumTypeDefinitionNode | EnumTypeExtensionNode : T extends InputValueDefinitionNode ? InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode | FieldDefinitionNode | DirectiveDefinitionNode : T extends FieldDefinitionNode ? ObjectTypeDefinitionNode | ObjectTypeExtensionNode | InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode : T extends SelectionSetNode ? ExecutableDefinitionNode | FieldNode | InlineFragmentNode : T extends SelectionNode ? SelectionSetNode : T extends TypeNode ? NodeWithType : T extends NameNode ? NodeWithName : unknown;
-declare type Node<T extends ASTNode, WithTypeInfo extends boolean> = Writeable<SafeGraphQLType<T>> & {
+type NodeWithName = TypeDefinitionNode | TypeExtensionNode | ExecutableDefinitionNode | DirectiveDefinitionNode | FieldDefinitionNode | EnumValueDefinitionNode | FieldNode | FragmentSpreadNode | VariableNode | ArgumentNode | NamedTypeNode;
+type NodeWithType = FieldDefinitionNode | InputValueDefinitionNode | OperationTypeDefinitionNode | NonNullTypeNode | ListTypeNode | VariableDefinitionNode;
+type ParentNode<T> = T extends DocumentNode ? AST.Program : T extends DefinitionNode ? DocumentNode : T extends EnumValueDefinitionNode ? EnumTypeDefinitionNode | EnumTypeExtensionNode : T extends InputValueDefinitionNode ? InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode | FieldDefinitionNode | DirectiveDefinitionNode : T extends FieldDefinitionNode ? ObjectTypeDefinitionNode | ObjectTypeExtensionNode | InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode : T extends SelectionSetNode ? ExecutableDefinitionNode | FieldNode | InlineFragmentNode : T extends SelectionNode ? SelectionSetNode : T extends TypeNode ? NodeWithType : T extends NameNode ? NodeWithName : unknown;
+type Node<T extends ASTNode, WithTypeInfo extends boolean> = Writeable<SafeGraphQLType<T>> & {
     type: T['kind'];
     loc: SourceLocation;
     range: AST.Range;
@@ -32,7 +32,7 @@ declare type Node<T extends ASTNode, WithTypeInfo extends boolean> = Writeable<S
     rawNode: () => T;
     parent: ParentNode<T>;
 };
-export declare type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
+export type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
     [K in keyof Node<T, W>]: Node<T, W>[K] extends ReadonlyArray<infer ArrayItem> ? GraphQLESTreeNode<ArrayItem, W>[] : GraphQLESTreeNode<Node<T, W>[K], W>;
 } : T extends AST.Program ? T & {
     parent: null;

package/estree-converter/utils.d.ts

@@ -3,7 +3,7 @@ import type { Comment, SourceLocation } from 'estree';
 import type { AST } from 'eslint';
 export declare const valueFromNode: (valueNode: import("graphql").ValueNode, variables?: import("graphql/jsutils/ObjMap").ObjMap<unknown>) => any;
 export declare function getBaseType(type: GraphQLOutputType): GraphQLNamedType;
-declare type TokenKindValue = '<SOF>' | '!' | '$' | '&' | '(' | ')' | '...' | ':' | '=' | '@' | '[' | ']' | '{' | '|' | '}' | 'Name' | 'Int' | 'Float' | 'String' | 'BlockString' | 'Comment';
+type TokenKindValue = '<SOF>' | '!' | '$' | '&' | '(' | ')' | '...' | ':' | '=' | '@' | '[' | ']' | '{' | '|' | '}' | 'Name' | 'Int' | 'Float' | 'String' | 'BlockString' | 'Comment';
 export declare function convertToken<T extends 'Line' | 'Block' | TokenKindValue>(token: Token, type: T): Omit<AST.Token, 'type'> & {
     type: T;
 };

package/index.js

@@ -221,7 +221,8 @@ const ARRAY_DEFAULT_OPTIONS = {
 };
 const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
 
-function validateDocument(context, schema = null, documentNode, rule) {
+function validateDocument({ context, schema = null, documentNode, rule, hasDidYouMeanSuggestions, }) {
+    var _a;
     if (documentNode.definitions.length === 0) {
         return;
     }
@@ -245,9 +246,20 @@ function validateDocument(context, schema = null, documentNode, rule) {
                         ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc
                         : token.loc;
             }
+            const didYouMeanContent = (_a = error.message.match(/Did you mean (?<content>.*)\?$/)) === null || _a === void 0 ? void 0 : _a.groups.content;
+            const matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
             context.report({
                 loc,
                 message: error.message,
+                suggest: hasDidYouMeanSuggestions
+                    ? matches.map(match => {
+                        const { name } = match.groups;
+                        return {
+                            desc: `Rename to \`${name}\``,
+                            fix: fixer => fixer.replaceText(token, name),
+                        };
+                    })
+                    : [],
             });
         }
     }
@@ -301,7 +313,7 @@ const handleMissingFragments = ({ ruleId, context, node }) => {
     }
     return node;
 };
-const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = []) => {
+const validationToRule = ({ ruleId, ruleName, getDocumentNode, schema = [], hasDidYouMeanSuggestions, }, docs) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
@@ -325,6 +337,7 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = [])
                     description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                 },
                 schema,
+                hasSuggestions: hasDidYouMeanSuggestions,
             },
             create(context) {
                 if (!ruleFn) {
@@ -339,30 +352,79 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = [])
                         const documentNode = getDocumentNode
                             ? getDocumentNode({ ruleId, context, node: node.rawNode() })
                             : node.rawNode();
-                        validateDocument(context, schema, documentNode, ruleFn);
+                        validateDocument({
+                            context,
+                            schema,
+                            documentNode,
+                            rule: ruleFn,
+                            hasDidYouMeanSuggestions,
+                        });
                     },
                 };
             },
         },
     };
 };
-const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
+const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule({
+    ruleId: 'executable-definitions',
+    ruleName: 'ExecutableDefinitions',
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.',
     requiresSchema: true,
-}), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
+}), validationToRule({
+    ruleId: 'fields-on-correct-type',
+    ruleName: 'FieldsOnCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.',
     requiresSchema: true,
-}), validationToRule('fragments-on-composite-type', 'FragmentsOnCompositeTypes', {
+}), validationToRule({
+    ruleId: 'fragments-on-composite-type',
+    ruleName: 'FragmentsOnCompositeTypes',
+}, {
     category: 'Operations',
     description: 'Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.',
     requiresSchema: true,
-}), validationToRule('known-argument-names', 'KnownArgumentNames', {
+}), validationToRule({
+    ruleId: 'known-argument-names',
+    ruleName: 'KnownArgumentNames',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL field is only valid if all supplied arguments are defined by that field.',
     requiresSchema: true,
-}), validationToRule('known-directives', 'KnownDirectives', {
+}), validationToRule({
+    ruleId: 'known-directives',
+    ruleName: 'KnownDirectives',
+    getDocumentNode({ context, node: documentNode }) {
+        const { ignoreClientDirectives = [] } = context.options[0] || {};
+        if (ignoreClientDirectives.length === 0) {
+            return documentNode;
+        }
+        const filterDirectives = (node) => ({
+            ...node,
+            directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
+        });
+        return graphql.visit(documentNode, {
+            Field: filterDirectives,
+            OperationDefinition: filterDirectives,
+        });
+    },
+    schema: {
+        type: 'array',
+        maxItems: 1,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['ignoreClientDirectives'],
+            properties: {
+                ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
+            },
+        },
+    },
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.',
     requiresSchema: true,
@@ -379,31 +441,11 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
     ],
-}, ({ context, node: documentNode }) => {
-    const { ignoreClientDirectives = [] } = context.options[0] || {};
-    if (ignoreClientDirectives.length === 0) {
-        return documentNode;
-    }
-    const filterDirectives = (node) => ({
-        ...node,
-        directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
-    });
-    return graphql.visit(documentNode, {
-        Field: filterDirectives,
-        OperationDefinition: filterDirectives,
-    });
+}), validationToRule({
+    ruleId: 'known-fragment-names',
+    ruleName: 'KnownFragmentNames',
+    getDocumentNode: handleMissingFragments,
 }, {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['ignoreClientDirectives'],
-        properties: {
-            ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
-        },
-    },
-}), validationToRule('known-fragment-names', 'KnownFragmentNames', {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.',
     requiresSchema: true,
@@ -454,138 +496,220 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
     ],
-}, handleMissingFragments), validationToRule('known-type-names', 'KnownTypeNames', {
+}), validationToRule({
+    ruleId: 'known-type-names',
+    ruleName: 'KnownTypeNames',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.',
     requiresSchema: true,
-}), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
+}), validationToRule({
+    ruleId: 'lone-anonymous-operation',
+    ruleName: 'LoneAnonymousOperation',
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.',
     requiresSchema: true,
-}), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
+}), validationToRule({
+    ruleId: 'lone-schema-definition',
+    ruleName: 'LoneSchemaDefinition',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if it contains only one schema definition.',
-}), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
+}), validationToRule({
+    ruleId: 'no-fragment-cycles',
+    ruleName: 'NoFragmentCycles',
+}, {
     category: 'Operations',
     description: 'A GraphQL fragment is only valid when it does not have cycles in fragments usage.',
     requiresSchema: true,
-}), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
+}), validationToRule({
+    ruleId: 'no-undefined-variables',
+    ruleName: 'NoUndefinedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.',
     requiresSchema: true,
     requiresSiblings: true,
-}, handleMissingFragments), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+}), validationToRule({
+    ruleId: 'no-unused-fragments',
+    ruleName: 'NoUnusedFragments',
+    getDocumentNode: ({ ruleId, context, node }) => {
+        const siblings = requireSiblingsOperations(ruleId, context);
+        const FilePathToDocumentsMap = [
+            ...siblings.getOperations(),
+            ...siblings.getFragments(),
+        ].reduce((map, { filePath, document }) => {
+            var _a;
+            (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
+            map[filePath].push(document);
+            return map;
+        }, Object.create(null));
+        const getParentNode = (currentFilePath, node) => {
+            const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node);
+            if (fragmentDefs.size === 0) {
+                return node;
+            }
+            // skip iteration over documents for current filepath
+            delete FilePathToDocumentsMap[currentFilePath];
+            for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
+                const missingFragments = getMissingFragments({
+                    kind: graphql.Kind.DOCUMENT,
+                    definitions: documents,
+                });
+                const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
+                if (isCurrentFileImportFragment) {
+                    return getParentNode(filePath, {
+                        kind: graphql.Kind.DOCUMENT,
+                        definitions: [...node.definitions, ...documents],
+                    });
+                }
+            }
+            return node;
+        };
+        return getParentNode(context.getFilename(), node);
+    },
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.',
     requiresSchema: true,
     requiresSiblings: true,
-}, ({ ruleId, context, node }) => {
-    const siblings = requireSiblingsOperations(ruleId, context);
-    const FilePathToDocumentsMap = [
-        ...siblings.getOperations(),
-        ...siblings.getFragments(),
-    ].reduce((map, { filePath, document }) => {
-        var _a;
-        (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
-        map[filePath].push(document);
-        return map;
-    }, Object.create(null));
-    const getParentNode = (currentFilePath, node) => {
-        const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node);
-        if (fragmentDefs.size === 0) {
-            return node;
-        }
-        // skip iteration over documents for current filepath
-        delete FilePathToDocumentsMap[currentFilePath];
-        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
-            const missingFragments = getMissingFragments({
-                kind: graphql.Kind.DOCUMENT,
-                definitions: documents,
-            });
-            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
-            if (isCurrentFileImportFragment) {
-                return getParentNode(filePath, {
-                    kind: graphql.Kind.DOCUMENT,
-                    definitions: [...node.definitions, ...documents],
-                });
-            }
-        }
-        return node;
-    };
-    return getParentNode(context.getFilename(), node);
-}), validationToRule('no-unused-variables', 'NoUnusedVariables', {
+}), validationToRule({
+    ruleId: 'no-unused-variables',
+    ruleName: 'NoUnusedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.',
     requiresSchema: true,
     requiresSiblings: true,
-}, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+}), validationToRule({
+    ruleId: 'overlapping-fields-can-be-merged',
+    ruleName: 'OverlappingFieldsCanBeMerged',
+}, {
     category: 'Operations',
     description: 'A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.',
     requiresSchema: true,
-}), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
+}), validationToRule({
+    ruleId: 'possible-fragment-spread',
+    ruleName: 'PossibleFragmentSpreads',
+}, {
     category: 'Operations',
     description: 'A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.',
     requiresSchema: true,
-}), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
+}), validationToRule({
+    ruleId: 'possible-type-extension',
+    ruleName: 'PossibleTypeExtensions',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Schema',
     description: 'A type extension is only valid if the type is defined and has the same kind.',
     // TODO: add in graphql-eslint v4
     recommended: false,
     requiresSchema: true,
     isDisabledForAllConfig: true,
-}), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
+}), validationToRule({
+    ruleId: 'provided-required-arguments',
+    ruleName: 'ProvidedRequiredArguments',
+}, {
     category: ['Schema', 'Operations'],
     description: 'A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.',
     requiresSchema: true,
-}), validationToRule('scalar-leafs', 'ScalarLeafs', {
+}), validationToRule({
+    ruleId: 'scalar-leafs',
+    ruleName: 'ScalarLeafs',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.',
     requiresSchema: true,
-}), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
+}), validationToRule({
+    ruleId: 'one-field-subscriptions',
+    ruleName: 'SingleFieldSubscriptions',
+}, {
     category: 'Operations',
     description: 'A GraphQL subscription is valid only if it contains a single root field.',
     requiresSchema: true,
-}), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
+}), validationToRule({
+    ruleId: 'unique-argument-names',
+    ruleName: 'UniqueArgumentNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL field or directive is only valid if all supplied arguments are uniquely named.',
     requiresSchema: true,
-}), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
+}), validationToRule({
+    ruleId: 'unique-directive-names',
+    ruleName: 'UniqueDirectiveNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if all defined directives have unique names.',
-}), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
+}), validationToRule({
+    ruleId: 'unique-directive-names-per-location',
+    ruleName: 'UniqueDirectivesPerLocation',
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.',
     requiresSchema: true,
-}), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
+}), validationToRule({
+    ruleId: 'unique-enum-value-names',
+    ruleName: 'UniqueEnumValueNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL enum type is only valid if all its values are uniquely named.',
     recommended: false,
     isDisabledForAllConfig: true,
-}), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
+}), validationToRule({
+    ruleId: 'unique-field-definition-names',
+    ruleName: 'UniqueFieldDefinitionNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL complex type is only valid if all its fields are uniquely named.',
-}), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
+}), validationToRule({
+    ruleId: 'unique-input-field-names',
+    ruleName: 'UniqueInputFieldNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL input object value is only valid if all supplied fields are uniquely named.',
-}), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
+}), validationToRule({
+    ruleId: 'unique-operation-types',
+    ruleName: 'UniqueOperationTypes',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if it has only one type per operation.',
-}), validationToRule('unique-type-names', 'UniqueTypeNames', {
+}), validationToRule({
+    ruleId: 'unique-type-names',
+    ruleName: 'UniqueTypeNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if all defined types have unique names.',
-}), validationToRule('unique-variable-names', 'UniqueVariableNames', {
+}), validationToRule({
+    ruleId: 'unique-variable-names',
+    ruleName: 'UniqueVariableNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all its variables are uniquely named.',
     requiresSchema: true,
-}), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
+}), validationToRule({
+    ruleId: 'value-literals-of-correct-type',
+    ruleName: 'ValuesOfCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all value literals are of the type expected at their position.',
     requiresSchema: true,
-}), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
+}), validationToRule({
+    ruleId: 'variables-are-input-types',
+    ruleName: 'VariablesAreInputTypes',
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).',
     requiresSchema: true,
-}), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
+}), validationToRule({
+    ruleId: 'variables-in-allowed-position',
+    ruleName: 'VariablesInAllowedPosition',
+}, {
     category: 'Operations',
     description: 'Variables passed to field arguments conform to type.',
     requiresSchema: true,

package/index.mjs

@@ -215,7 +215,8 @@ const ARRAY_DEFAULT_OPTIONS = {
 };
 const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
 
-function validateDocument(context, schema = null, documentNode, rule) {
+function validateDocument({ context, schema = null, documentNode, rule, hasDidYouMeanSuggestions, }) {
+    var _a;
     if (documentNode.definitions.length === 0) {
         return;
     }
@@ -239,9 +240,20 @@ function validateDocument(context, schema = null, documentNode, rule) {
                         ? sourceCode.getNodeByRangeIndex(token.range[1] + 1).loc
                         : token.loc;
             }
+            const didYouMeanContent = (_a = error.message.match(/Did you mean (?<content>.*)\?$/)) === null || _a === void 0 ? void 0 : _a.groups.content;
+            const matches = didYouMeanContent ? [...didYouMeanContent.matchAll(/"(?<name>[^"]*)"/g)] : [];
             context.report({
                 loc,
                 message: error.message,
+                suggest: hasDidYouMeanSuggestions
+                    ? matches.map(match => {
+                        const { name } = match.groups;
+                        return {
+                            desc: `Rename to \`${name}\``,
+                            fix: fixer => fixer.replaceText(token, name),
+                        };
+                    })
+                    : [],
             });
         }
     }
@@ -295,7 +307,7 @@ const handleMissingFragments = ({ ruleId, context, node }) => {
     }
     return node;
 };
-const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = []) => {
+const validationToRule = ({ ruleId, ruleName, getDocumentNode, schema = [], hasDidYouMeanSuggestions, }, docs) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
@@ -319,6 +331,7 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = [])
                     description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                 },
                 schema,
+                hasSuggestions: hasDidYouMeanSuggestions,
             },
             create(context) {
                 if (!ruleFn) {
@@ -333,30 +346,79 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode, schema = [])
                         const documentNode = getDocumentNode
                             ? getDocumentNode({ ruleId, context, node: node.rawNode() })
                             : node.rawNode();
-                        validateDocument(context, schema, documentNode, ruleFn);
+                        validateDocument({
+                            context,
+                            schema,
+                            documentNode,
+                            rule: ruleFn,
+                            hasDidYouMeanSuggestions,
+                        });
                     },
                 };
             },
         },
     };
 };
-const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
+const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule({
+    ruleId: 'executable-definitions',
+    ruleName: 'ExecutableDefinitions',
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.',
     requiresSchema: true,
-}), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
+}), validationToRule({
+    ruleId: 'fields-on-correct-type',
+    ruleName: 'FieldsOnCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.',
     requiresSchema: true,
-}), validationToRule('fragments-on-composite-type', 'FragmentsOnCompositeTypes', {
+}), validationToRule({
+    ruleId: 'fragments-on-composite-type',
+    ruleName: 'FragmentsOnCompositeTypes',
+}, {
     category: 'Operations',
     description: 'Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.',
     requiresSchema: true,
-}), validationToRule('known-argument-names', 'KnownArgumentNames', {
+}), validationToRule({
+    ruleId: 'known-argument-names',
+    ruleName: 'KnownArgumentNames',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL field is only valid if all supplied arguments are defined by that field.',
     requiresSchema: true,
-}), validationToRule('known-directives', 'KnownDirectives', {
+}), validationToRule({
+    ruleId: 'known-directives',
+    ruleName: 'KnownDirectives',
+    getDocumentNode({ context, node: documentNode }) {
+        const { ignoreClientDirectives = [] } = context.options[0] || {};
+        if (ignoreClientDirectives.length === 0) {
+            return documentNode;
+        }
+        const filterDirectives = (node) => ({
+            ...node,
+            directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
+        });
+        return visit(documentNode, {
+            Field: filterDirectives,
+            OperationDefinition: filterDirectives,
+        });
+    },
+    schema: {
+        type: 'array',
+        maxItems: 1,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['ignoreClientDirectives'],
+            properties: {
+                ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
+            },
+        },
+    },
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned.',
     requiresSchema: true,
@@ -373,31 +435,11 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
     ],
-}, ({ context, node: documentNode }) => {
-    const { ignoreClientDirectives = [] } = context.options[0] || {};
-    if (ignoreClientDirectives.length === 0) {
-        return documentNode;
-    }
-    const filterDirectives = (node) => ({
-        ...node,
-        directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
-    });
-    return visit(documentNode, {
-        Field: filterDirectives,
-        OperationDefinition: filterDirectives,
-    });
+}), validationToRule({
+    ruleId: 'known-fragment-names',
+    ruleName: 'KnownFragmentNames',
+    getDocumentNode: handleMissingFragments,
 }, {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['ignoreClientDirectives'],
-        properties: {
-            ignoreClientDirectives: ARRAY_DEFAULT_OPTIONS,
-        },
-    },
-}), validationToRule('known-fragment-names', 'KnownFragmentNames', {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.',
     requiresSchema: true,
@@ -448,138 +490,220 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
     ],
-}, handleMissingFragments), validationToRule('known-type-names', 'KnownTypeNames', {
+}), validationToRule({
+    ruleId: 'known-type-names',
+    ruleName: 'KnownTypeNames',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.',
     requiresSchema: true,
-}), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
+}), validationToRule({
+    ruleId: 'lone-anonymous-operation',
+    ruleName: 'LoneAnonymousOperation',
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.',
     requiresSchema: true,
-}), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
+}), validationToRule({
+    ruleId: 'lone-schema-definition',
+    ruleName: 'LoneSchemaDefinition',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if it contains only one schema definition.',
-}), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
+}), validationToRule({
+    ruleId: 'no-fragment-cycles',
+    ruleName: 'NoFragmentCycles',
+}, {
     category: 'Operations',
     description: 'A GraphQL fragment is only valid when it does not have cycles in fragments usage.',
     requiresSchema: true,
-}), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
+}), validationToRule({
+    ruleId: 'no-undefined-variables',
+    ruleName: 'NoUndefinedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.',
     requiresSchema: true,
     requiresSiblings: true,
-}, handleMissingFragments), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+}), validationToRule({
+    ruleId: 'no-unused-fragments',
+    ruleName: 'NoUnusedFragments',
+    getDocumentNode: ({ ruleId, context, node }) => {
+        const siblings = requireSiblingsOperations(ruleId, context);
+        const FilePathToDocumentsMap = [
+            ...siblings.getOperations(),
+            ...siblings.getFragments(),
+        ].reduce((map, { filePath, document }) => {
+            var _a;
+            (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
+            map[filePath].push(document);
+            return map;
+        }, Object.create(null));
+        const getParentNode = (currentFilePath, node) => {
+            const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node);
+            if (fragmentDefs.size === 0) {
+                return node;
+            }
+            // skip iteration over documents for current filepath
+            delete FilePathToDocumentsMap[currentFilePath];
+            for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
+                const missingFragments = getMissingFragments({
+                    kind: Kind.DOCUMENT,
+                    definitions: documents,
+                });
+                const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
+                if (isCurrentFileImportFragment) {
+                    return getParentNode(filePath, {
+                        kind: Kind.DOCUMENT,
+                        definitions: [...node.definitions, ...documents],
+                    });
+                }
+            }
+            return node;
+        };
+        return getParentNode(context.getFilename(), node);
+    },
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.',
     requiresSchema: true,
     requiresSiblings: true,
-}, ({ ruleId, context, node }) => {
-    const siblings = requireSiblingsOperations(ruleId, context);
-    const FilePathToDocumentsMap = [
-        ...siblings.getOperations(),
-        ...siblings.getFragments(),
-    ].reduce((map, { filePath, document }) => {
-        var _a;
-        (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
-        map[filePath].push(document);
-        return map;
-    }, Object.create(null));
-    const getParentNode = (currentFilePath, node) => {
-        const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(node);
-        if (fragmentDefs.size === 0) {
-            return node;
-        }
-        // skip iteration over documents for current filepath
-        delete FilePathToDocumentsMap[currentFilePath];
-        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
-            const missingFragments = getMissingFragments({
-                kind: Kind.DOCUMENT,
-                definitions: documents,
-            });
-            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
-            if (isCurrentFileImportFragment) {
-                return getParentNode(filePath, {
-                    kind: Kind.DOCUMENT,
-                    definitions: [...node.definitions, ...documents],
-                });
-            }
-        }
-        return node;
-    };
-    return getParentNode(context.getFilename(), node);
-}), validationToRule('no-unused-variables', 'NoUnusedVariables', {
+}), validationToRule({
+    ruleId: 'no-unused-variables',
+    ruleName: 'NoUnusedVariables',
+    getDocumentNode: handleMissingFragments,
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.',
     requiresSchema: true,
     requiresSiblings: true,
-}, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+}), validationToRule({
+    ruleId: 'overlapping-fields-can-be-merged',
+    ruleName: 'OverlappingFieldsCanBeMerged',
+}, {
     category: 'Operations',
     description: 'A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.',
     requiresSchema: true,
-}), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
+}), validationToRule({
+    ruleId: 'possible-fragment-spread',
+    ruleName: 'PossibleFragmentSpreads',
+}, {
     category: 'Operations',
     description: 'A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.',
     requiresSchema: true,
-}), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
+}), validationToRule({
+    ruleId: 'possible-type-extension',
+    ruleName: 'PossibleTypeExtensions',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Schema',
     description: 'A type extension is only valid if the type is defined and has the same kind.',
     // TODO: add in graphql-eslint v4
     recommended: false,
     requiresSchema: true,
     isDisabledForAllConfig: true,
-}), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
+}), validationToRule({
+    ruleId: 'provided-required-arguments',
+    ruleName: 'ProvidedRequiredArguments',
+}, {
     category: ['Schema', 'Operations'],
     description: 'A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.',
     requiresSchema: true,
-}), validationToRule('scalar-leafs', 'ScalarLeafs', {
+}), validationToRule({
+    ruleId: 'scalar-leafs',
+    ruleName: 'ScalarLeafs',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.',
     requiresSchema: true,
-}), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
+}), validationToRule({
+    ruleId: 'one-field-subscriptions',
+    ruleName: 'SingleFieldSubscriptions',
+}, {
     category: 'Operations',
     description: 'A GraphQL subscription is valid only if it contains a single root field.',
     requiresSchema: true,
-}), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
+}), validationToRule({
+    ruleId: 'unique-argument-names',
+    ruleName: 'UniqueArgumentNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL field or directive is only valid if all supplied arguments are uniquely named.',
     requiresSchema: true,
-}), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
+}), validationToRule({
+    ruleId: 'unique-directive-names',
+    ruleName: 'UniqueDirectiveNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if all defined directives have unique names.',
-}), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
+}), validationToRule({
+    ruleId: 'unique-directive-names-per-location',
+    ruleName: 'UniqueDirectivesPerLocation',
+}, {
     category: ['Schema', 'Operations'],
     description: 'A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.',
     requiresSchema: true,
-}), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
+}), validationToRule({
+    ruleId: 'unique-enum-value-names',
+    ruleName: 'UniqueEnumValueNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL enum type is only valid if all its values are uniquely named.',
     recommended: false,
     isDisabledForAllConfig: true,
-}), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
+}), validationToRule({
+    ruleId: 'unique-field-definition-names',
+    ruleName: 'UniqueFieldDefinitionNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL complex type is only valid if all its fields are uniquely named.',
-}), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
+}), validationToRule({
+    ruleId: 'unique-input-field-names',
+    ruleName: 'UniqueInputFieldNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL input object value is only valid if all supplied fields are uniquely named.',
-}), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
+}), validationToRule({
+    ruleId: 'unique-operation-types',
+    ruleName: 'UniqueOperationTypes',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if it has only one type per operation.',
-}), validationToRule('unique-type-names', 'UniqueTypeNames', {
+}), validationToRule({
+    ruleId: 'unique-type-names',
+    ruleName: 'UniqueTypeNames',
+}, {
     category: 'Schema',
     description: 'A GraphQL document is only valid if all defined types have unique names.',
-}), validationToRule('unique-variable-names', 'UniqueVariableNames', {
+}), validationToRule({
+    ruleId: 'unique-variable-names',
+    ruleName: 'UniqueVariableNames',
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all its variables are uniquely named.',
     requiresSchema: true,
-}), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
+}), validationToRule({
+    ruleId: 'value-literals-of-correct-type',
+    ruleName: 'ValuesOfCorrectType',
+    hasDidYouMeanSuggestions: true,
+}, {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all value literals are of the type expected at their position.',
     requiresSchema: true,
-}), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
+}), validationToRule({
+    ruleId: 'variables-are-input-types',
+    ruleName: 'VariablesAreInputTypes',
+}, {
     category: 'Operations',
     description: 'A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).',
     requiresSchema: true,
-}), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
+}), validationToRule({
+    ruleId: 'variables-in-allowed-position',
+    ruleName: 'VariablesInAllowedPosition',
+}, {
     category: 'Operations',
     description: 'Variables passed to field arguments conform to type.',
     requiresSchema: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.13.2-alpha-20221109140613-1815aa1",
+  "version": "3.14.0-alpha-20221220004017-f1f0904",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {
@@ -10,7 +10,7 @@
     "@babel/code-frame": "^7.18.6",
     "@graphql-tools/code-file-loader": "^7.3.6",
     "@graphql-tools/graphql-tag-pluck": "^7.3.6",
-    "@graphql-tools/utils": "^8.12.0",
+    "@graphql-tools/utils": "^9.0.0",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "fast-glob": "^3.2.12",

package/processor.d.ts

@@ -1,5 +1,5 @@
 import { Linter } from 'eslint';
-export declare type Block = Linter.ProcessorFile & {
+export type Block = Linter.ProcessorFile & {
     lineOffset: number;
     offset: number;
 };

package/rules/alphabetize.d.ts

@@ -4,7 +4,7 @@ declare const valuesEnum: ['EnumTypeDefinition'];
 declare const selectionsEnum: ('OperationDefinition' | 'FragmentDefinition')[];
 declare const variablesEnum: ['OperationDefinition'];
 declare const argumentsEnum: ('FieldDefinition' | 'Field' | 'DirectiveDefinition' | 'Directive')[];
-export declare type AlphabetizeConfig = {
+export type AlphabetizeConfig = {
     fields?: typeof fieldsEnum;
     values?: typeof valuesEnum;
     selections?: typeof selectionsEnum;

package/rules/description-style.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-declare type DescriptionStyleRuleConfig = {
+type DescriptionStyleRuleConfig = {
     style: 'inline' | 'block';
 };
 declare const rule: GraphQLESLintRule<[DescriptionStyleRuleConfig]>;

package/rules/graphql-js-validation.d.ts

@@ -1,2 +1,2 @@
-import type { GraphQLESLintRule } from '../types';
+import { GraphQLESLintRule } from '../types';
 export declare const GRAPHQL_JS_VALIDATIONS: Record<string, GraphQLESLintRule>;

package/rules/input-name.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-declare type InputNameRuleConfig = {
+type InputNameRuleConfig = {
     checkInputType?: boolean;
     caseSensitiveInputType?: boolean;
     checkQueries?: boolean;

package/rules/match-document-filename.d.ts

@@ -1,12 +1,12 @@
 import { CaseStyle as _CaseStyle } from '../utils';
 import { GraphQLESLintRule } from '../types';
-declare type CaseStyle = _CaseStyle | 'matchDocumentStyle';
+type CaseStyle = _CaseStyle | 'matchDocumentStyle';
 declare const ACCEPTED_EXTENSIONS: ['.gql', '.graphql'];
-declare type PropertySchema = {
+type PropertySchema = {
     style?: CaseStyle;
     suffix?: string;
 };
-export declare type MatchDocumentFilenameRuleConfig = {
+export type MatchDocumentFilenameRuleConfig = {
     fileExtension?: typeof ACCEPTED_EXTENSIONS[number];
     query?: CaseStyle | PropertySchema;
     mutation?: CaseStyle | PropertySchema;

package/rules/naming-convention.d.ts

@@ -15,9 +15,9 @@ declare const KindToDisplayName: {
     FragmentDefinition: string;
     VariableDefinition: string;
 };
-declare type AllowedKind = keyof typeof KindToDisplayName;
-declare type AllowedStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
-declare type PropertySchema = {
+type AllowedKind = keyof typeof KindToDisplayName;
+type AllowedStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
+type PropertySchema = {
     style?: AllowedStyle;
     suffix?: string;
     prefix?: string;
@@ -25,8 +25,8 @@ declare type PropertySchema = {
     forbiddenSuffixes?: string[];
     ignorePattern?: string;
 };
-declare type Options = AllowedStyle | PropertySchema;
-export declare type NamingConventionRuleConfig = {
+type Options = AllowedStyle | PropertySchema;
+export type NamingConventionRuleConfig = {
     allowLeadingUnderscore?: boolean;
     allowTrailingUnderscore?: boolean;
     types?: Options;

package/rules/no-root-type.d.ts

@@ -1,6 +1,6 @@
 import type { GraphQLESLintRule } from '../types';
 declare const ROOT_TYPES: ('mutation' | 'subscription')[];
-declare type NoRootTypeConfig = {
+type NoRootTypeConfig = {
     disallow: typeof ROOT_TYPES;
 };
 declare const rule: GraphQLESLintRule<[NoRootTypeConfig]>;

package/rules/relay-arguments.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-export declare type RelayArgumentsConfig = {
+export type RelayArgumentsConfig = {
     includeBoth?: boolean;
 };
 declare const rule: GraphQLESLintRule<[RelayArgumentsConfig], true>;

package/rules/relay-edge-types.d.ts

@@ -1,5 +1,5 @@
 import type { GraphQLESLintRule } from '../types';
-export declare type EdgeTypesConfig = {
+export type EdgeTypesConfig = {
     withEdgeSuffix?: boolean;
     shouldImplementNode?: boolean;
     listTypeCanWrapOnlyEdgeType?: boolean;

package/rules/require-description.d.ts

@@ -1,8 +1,8 @@
 import { Kind } from 'graphql';
 import type { GraphQLESLintRule } from '../types';
 declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.DIRECTIVE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.OPERATION_DEFINITION];
-declare type AllowedKind = typeof ALLOWED_KINDS[number];
-export declare type RequireDescriptionRuleConfig = {
+type AllowedKind = typeof ALLOWED_KINDS[number];
+export type RequireDescriptionRuleConfig = {
     types?: boolean;
 } & {
     [key in AllowedKind]?: boolean;

package/rules/require-id-when-available.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-export declare type RequireIdWhenAvailableRuleConfig = {
+export type RequireIdWhenAvailableRuleConfig = {
     fieldName: string | string[];
 };
 declare const rule: GraphQLESLintRule<[RequireIdWhenAvailableRuleConfig], true>;

package/rules/selection-set-depth.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-export declare type SelectionSetDepthRuleConfig = {
+export type SelectionSetDepthRuleConfig = {
     maxDepth: number;
     ignore?: string[];
 };

package/rules/strict-id-in-types.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLESLintRule } from '../types';
-export declare type StrictIdInTypesRuleConfig = {
+export type StrictIdInTypesRuleConfig = {
     acceptedIdNames?: string[];
     acceptedIdTypes?: string[];
     exceptions?: {

package/testkit.d.ts

@@ -2,14 +2,14 @@ import { RuleTester } from 'eslint';
 import type { ASTKindToNode } from 'graphql';
 import type { GraphQLESTreeNode } from './estree-converter';
 import type { GraphQLESLintRule, ParserOptions } from './types';
-export declare type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = {
+export type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = {
     [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
 } & Record<string, any>;
-export declare type GraphQLValidTestCase<Options> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
+export type GraphQLValidTestCase<Options> = Omit<RuleTester.ValidTestCase, 'options' | 'parserOptions'> & {
     options?: Options;
     parserOptions?: ParserOptions;
 };
-export declare type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
+export type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
     errors: number | (RuleTester.TestCaseError | string)[];
     output?: string | null;
 };

package/types.d.ts

@@ -5,8 +5,8 @@ import { IExtensions, IGraphQLProject } from 'graphql-config';
 import { GraphQLParseOptions } from '@graphql-tools/utils';
 import { GraphQLESLintRuleListener } from './testkit';
 import { SiblingOperations } from './documents';
-export declare type Schema = GraphQLSchema | Error | null;
-export declare type Pointer = string | string[];
+export type Schema = GraphQLSchema | Error | null;
+export type Pointer = string | string[];
 export interface ParserOptions {
     schema?: Pointer | Record<string, {
         headers: Record<string, string>;
@@ -24,29 +24,29 @@ export interface ParserOptions {
     skipGraphQLConfig?: boolean;
     filePath: string;
 }
-export declare type ParserServices = {
+export type ParserServices = {
     schema: Schema;
     siblingOperations: SiblingOperations;
 };
-export declare type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+export type GraphQLESLintParseResult = Linter.ESLintParseResult & {
     services: ParserServices;
 };
-declare type Location = AST.SourceLocation | ESTree.Position;
-declare type ReportDescriptorLocation = {
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
     node: {
         loc: Location;
     };
 } | {
     loc: Location;
 };
-export declare type ReportDescriptor = Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions & ReportDescriptorLocation;
-export declare type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'parserServices' | 'report' | 'options'> & {
+export type ReportDescriptor = Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions & ReportDescriptorLocation;
+export type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'parserServices' | 'report' | 'options'> & {
     options: Options;
     report(descriptor: ReportDescriptor): void;
     parserServices?: ParserServices;
 };
-export declare type CategoryType = 'Schema' | 'Operations';
-export declare type RuleDocsInfo<T> = Omit<Rule.RuleMetaData['docs'], 'category' | 'suggestion'> & {
+export type CategoryType = 'Schema' | 'Operations';
+export type RuleDocsInfo<T> = Omit<Rule.RuleMetaData['docs'], 'category' | 'suggestion'> & {
     category: CategoryType | CategoryType[];
     requiresSchema?: true;
     requiresSiblings?: true;
@@ -62,18 +62,18 @@ export declare type RuleDocsInfo<T> = Omit<Rule.RuleMetaData['docs'], 'category'
     graphQLJSRuleName?: string;
     isDisabledForAllConfig?: true;
 };
-export declare type GraphQLESLintRule<Options = any[], WithTypeInfo extends boolean = false> = {
+export type GraphQLESLintRule<Options = any[], WithTypeInfo extends boolean = false> = {
     create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
     meta: Omit<Rule.RuleMetaData, 'docs'> & {
         docs?: RuleDocsInfo<Options>;
     };
 };
-export declare type ValueOf<T> = T[keyof T];
-declare type Id<T> = {} & {
+export type ValueOf<T> = T[keyof T];
+type Id<T> = {} & {
     [P in keyof T]: T[P];
 };
-declare type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
-export declare type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+export type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
     [P in keyof T]: OmitDistributive<T[P], K>;
 }, K>;
 export {};

package/utils.d.ts

@@ -14,7 +14,7 @@ export declare const VIRTUAL_DOCUMENT_REGEX: RegExp;
 export declare const CWD: string;
 export declare const getTypeName: (node: any) => string;
 export declare const TYPES_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION];
-export declare type CaseStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE' | 'kebab-case';
+export type CaseStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE' | 'kebab-case';
 export declare const camelCase: (str: string) => string;
 export declare const convertCase: (style: CaseStyle, str: string) => string;
 export declare function getLocation(start: Position, fieldName?: string): AST.SourceLocation;