@graphql-eslint/eslint-plugin 4.0.0-alpha.1 → 4.0.0-alpha.3

package/{index.browser.mjs → index.browser.js}

@@ -237,10 +237,23 @@ var require_schema_relay = __commonJS({
 });
 
 // src/parser.ts
-import debugFactory from "debug";
+import debugFactory2 from "debug";
 import { buildSchema, GraphQLError } from "graphql";
 import { parseGraphQLSDL } from "@graphql-tools/utils";
 
+// src/cache.ts
+import debugFactory from "debug";
+var log = debugFactory("graphql-eslint:ModuleCache"), ModuleCache = class {
+  map = /* @__PURE__ */ new Map();
+  set(cacheKey, result) {
+  }
+  get(cacheKey, settings = {
+    lifetime: 10
+    /* seconds */
+  }) {
+  }
+};
+
 // src/estree-converter/converter.ts
 import {
   Kind,
@@ -374,6 +387,84 @@ function convertToESTree(node, schema15) {
   );
 }
 
+// package.json
+var package_default = {
+  name: "@graphql-eslint/eslint-plugin",
+  version: "4.0.0-alpha.3",
+  type: "module",
+  description: "GraphQL plugin for ESLint",
+  repository: "https://github.com/B2o5T/graphql-eslint",
+  author: "Dotan Simha <dotansimha@gmail.com>",
+  license: "MIT",
+  engines: {
+    node: ">=18"
+  },
+  main: "dist/cjs/index.js",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      require: {
+        types: "./dist/cjs/index.d.ts",
+        default: "./dist/cjs/index.js"
+      },
+      import: {
+        types: "./dist/esm/index.d.ts",
+        default: "./dist/esm/index.js"
+      },
+      default: {
+        types: "./dist/esm/index.d.ts",
+        default: "./dist/esm/index.js"
+      }
+    }
+  },
+  types: "dist/esm/index.d.ts",
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "graphql"
+  ],
+  scripts: {
+    build: "tsup",
+    test: "vitest",
+    typecheck: "tsc --noEmit"
+  },
+  peerDependencies: {
+    eslint: ">=8.44.0",
+    graphql: "^16"
+  },
+  dependencies: {
+    "@graphql-tools/code-file-loader": "^8.0.0",
+    "@graphql-tools/graphql-tag-pluck": "8.3.2-alpha-20240803110708-298aeb8bb2ca4ef649bf09fc42f82fc88c6d5e13",
+    "@graphql-tools/utils": "^10.0.0",
+    debug: "^4.3.4",
+    "fast-glob": "^3.2.12",
+    "graphql-config": "^5.1.0",
+    "graphql-depth-limit": "^1.1.0",
+    "lodash.lowercase": "^4.3.0"
+  },
+  devDependencies: {
+    "@theguild/eslint-rule-tester": "workspace:*",
+    "@types/debug": "4.1.12",
+    "@types/eslint": "9.6.0",
+    "@types/estree": "1.0.5",
+    "@types/graphql-depth-limit": "1.1.6",
+    "@types/json-schema": "7.0.15",
+    "@types/lodash.lowercase": "4.3.9",
+    graphql: "16.9.0",
+    "json-schema-to-ts": "2.12.0",
+    "vite-tsconfig-paths": "^4.3.2"
+  },
+  publishConfig: {
+    directory: "dist",
+    access: "public"
+  },
+  sideEffects: !1
+};
+
+// src/meta.ts
+var { name, version } = package_default;
+
 // src/siblings.ts
 import {
   Kind as Kind3,
@@ -550,7 +641,7 @@ function getSiblings(documents) {
       cachedOperations = result;
     }
     return cachedOperations;
-  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit2(selectable, {
+  }, getFragment = (name2) => getFragments().filter((f) => f.document.name.value === name2), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit2(selectable, {
     FragmentSpread(spread) {
       let fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
       if (!fragment) {
@@ -567,7 +658,7 @@ function getSiblings(documents) {
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
     getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
-    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
+    getOperation: (name2) => getOperations().filter((o) => o.document.name?.value === name2),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
@@ -575,7 +666,7 @@ function getSiblings(documents) {
 }
 
 // src/parser.ts
-var debug = debugFactory("graphql-eslint:parser");
+var debug = debugFactory2("graphql-eslint:parser");
 debug("cwd %o", CWD);
 var LEGACY_PARSER_OPTIONS_KEYS = [
   "schema",
@@ -640,6 +731,13 @@ function parseForESLint(code, options) {
     throw error;
   }
 }
+var parser = {
+  parseForESLint,
+  meta: {
+    name: "@graphql-eslint/parser",
+    version
+  }
+};
 
 // src/rules/alphabetize.ts
 import {
@@ -1078,10 +1176,10 @@ function validateDocument({
           loc,
           message: error.message,
           suggest: hasDidYouMeanSuggestions ? matches.map((match) => {
-            let { name } = match.groups;
+            let { name: name2 } = match.groups;
             return {
-              desc: `Rename to \`${name}\``,
-              fix: (fixer) => fixer.replaceText(token, name)
+              desc: `Rename to \`${name2}\``,
+              fix: (fixer) => fixer.replaceText(token, name2)
             };
           }) : []
         });
@@ -1105,7 +1203,7 @@ var getFragmentDefsAndFragmentSpreads = (node) => {
   }), { fragmentDefs, fragmentSpreads };
 }, getMissingFragments = (node) => {
   let { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(node);
-  return [...fragmentSpreads].filter((name) => !fragmentDefs.has(name));
+  return [...fragmentSpreads].filter((name2) => !fragmentDefs.has(name2));
 }, handleMissingFragments = ({ ruleId, context, node }) => {
   let missingFragments = getMissingFragments(node);
   if (missingFragments.length > 0) {
@@ -1742,10 +1840,10 @@ Using the same name for all input parameters will make your schemas easier to co
         return currentNode;
       })(node);
       if (shouldCheckType(inputValueNode.parent.parent)) {
-        let mutationName = `${inputValueNode.parent.name.value}Input`, name = node.name.value;
-        (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) && context.report({
+        let mutationName = `${inputValueNode.parent.name.value}Input`, name2 = node.name.value;
+        (options.caseSensitiveInputType && node.name.value !== mutationName || name2.toLowerCase() !== mutationName.toLowerCase()) && context.report({
           node: node.name,
-          message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+          message: `Input type \`${name2}\` name should be \`${mutationName}\`.`,
           suggest: [
             {
               desc: `Rename to \`${mutationName}\``,
@@ -1828,11 +1926,11 @@ var RULE_ID2 = "lone-executable-definition", definitionTypes = ["fragment", ...O
       },
       "Document:exit"() {
         for (let { node, type } of definitions.slice(1)) {
-          let name = pascalCase(type), definitionName = node.name?.value;
-          definitionName && (name += ` "${definitionName}"`), context.report({
+          let name2 = pascalCase(type), definitionName = node.name?.value;
+          definitionName && (name2 += ` "${definitionName}"`), context.report({
             loc: node.name?.loc || getLocation(node.loc.start, type),
             messageId: RULE_ID2,
-            data: { name }
+            data: { name: name2 }
           });
         }
       }
@@ -2399,51 +2497,51 @@ ${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
         report(node, `${nodeType} "${nodeName}" should ${errorMessage}`, suggestedNames);
       }
       function getError() {
-        let name = nodeName.replace(/(^_+)|(_+$)/g, "");
-        if (ignorePattern && new RegExp(ignorePattern, "u").test(name))
+        let name2 = nodeName.replace(/(^_+)|(_+$)/g, "");
+        if (ignorePattern && new RegExp(ignorePattern, "u").test(name2))
           return;
-        if (prefix && !name.startsWith(prefix))
+        if (prefix && !name2.startsWith(prefix))
           return {
             errorMessage: `have "${prefix}" prefix`,
-            renameToNames: [prefix + name]
+            renameToNames: [prefix + name2]
           };
-        if (suffix && !name.endsWith(suffix))
+        if (suffix && !name2.endsWith(suffix))
           return {
             errorMessage: `have "${suffix}" suffix`,
-            renameToNames: [name + suffix]
+            renameToNames: [name2 + suffix]
           };
-        let forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name.startsWith(prefix2));
+        let forbiddenPrefix = forbiddenPrefixes?.find((prefix2) => name2.startsWith(prefix2));
         if (forbiddenPrefix)
           return {
             errorMessage: `not have "${forbiddenPrefix}" prefix`,
-            renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
+            renameToNames: [name2.replace(new RegExp(`^${forbiddenPrefix}`), "")]
           };
-        let forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name.endsWith(suffix2));
+        let forbiddenSuffix = forbiddenSuffixes?.find((suffix2) => name2.endsWith(suffix2));
         if (forbiddenSuffix)
           return {
             errorMessage: `not have "${forbiddenSuffix}" suffix`,
-            renameToNames: [name.replace(new RegExp(`${forbiddenSuffix}$`), "")]
+            renameToNames: [name2.replace(new RegExp(`${forbiddenSuffix}$`), "")]
           };
-        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix)))
+        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name2.startsWith(requiredPrefix)))
           return {
             errorMessage: `have one of the following prefixes: ${englishJoinWords(
               requiredPrefixes
             )}`,
-            renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name}`)
+            renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name2}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name2}`)
           };
-        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix)))
+        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name2.endsWith(requiredSuffix)))
           return {
             errorMessage: `have one of the following suffixes: ${englishJoinWords(
               requiredSuffixes
             )}`,
-            renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name}${suffix2}`)
+            renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name2} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name2}${suffix2}`)
           };
         if (!style)
           return;
-        if (!StyleToRegex[style].test(name))
+        if (!StyleToRegex[style].test(name2))
           return {
             errorMessage: `be in ${style} format`,
-            renameToNames: [convertCase(style, name)]
+            renameToNames: [convertCase(style, name2)]
           };
       }
     }, checkUnderscore = (isLeading) => (node) => {
@@ -2930,8 +3028,8 @@ var RULE_ID7 = "no-one-place-fragments", rule11 = {
     for (let { document, filePath } of allDocuments) {
       let relativeFilePath = relative(CWD, filePath);
       visit4(document, {
-        FragmentSpread({ name }) {
-          let spreadName = name.value;
+        FragmentSpread({ name: name2 }) {
+          let spreadName = name2.value;
           usedFragmentsMap[spreadName] ||= [], usedFragmentsMap[spreadName].push(relativeFilePath);
         }
       });
@@ -3186,7 +3284,7 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   Kind13.UNION_TYPE_EXTENSION,
   Kind13.ENUM_TYPE_DEFINITION,
   Kind13.ENUM_TYPE_EXTENSION
-], reachableTypesCache, RequestDirectiveLocations = /* @__PURE__ */ new Set([
+], reachableTypesCache = new ModuleCache(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
   DirectiveLocation.SUBSCRIPTION,
@@ -3197,8 +3295,9 @@ var RULE_ID9 = "no-unreachable-types", KINDS = [
   DirectiveLocation.VARIABLE_DEFINITION
 ]);
 function getReachableTypes(schema15) {
-  if (reachableTypesCache)
-    return reachableTypesCache;
+  let cachedValue = reachableTypesCache.get(schema15);
+  if (cachedValue)
+    return cachedValue;
   let reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
     let typeName = getTypeName(node);
     if (reachableTypes.has(typeName))
@@ -3235,7 +3334,7 @@ function getReachableTypes(schema15) {
         argTypeName && reachableTypes.add(argTypeName);
       }
     }
-  return reachableTypesCache = reachableTypes, reachableTypesCache;
+  return reachableTypesCache.set(schema15, reachableTypes), reachableTypes;
 }
 var rule15 = {
   meta: {
@@ -3316,10 +3415,11 @@ var rule15 = {
 
 // src/rules/no-unused-fields.ts
 import { TypeInfo as TypeInfo2, visit as visit6, visitWithTypeInfo as visitWithTypeInfo2 } from "graphql";
-var RULE_ID10 = "no-unused-fields", usedFieldsCache;
+var RULE_ID10 = "no-unused-fields", usedFieldsCache = new ModuleCache();
 function getUsedFields(schema15, operations) {
-  if (usedFieldsCache)
-    return usedFieldsCache;
+  let cachedValue = usedFieldsCache.get(schema15);
+  if (cachedValue)
+    return cachedValue;
   let usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo2(schema15), visitor = visitWithTypeInfo2(typeInfo, {
     Field(node) {
       if (!typeInfo.getFieldDef())
@@ -3330,7 +3430,7 @@ function getUsedFields(schema15, operations) {
   }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
   for (let { document } of allDocuments)
     visit6(document, visitor);
-  return usedFieldsCache = usedFields, usedFieldsCache;
+  return usedFieldsCache.set(schema15, usedFields), usedFields;
 }
 var rule16 = {
   meta: {
@@ -4463,7 +4563,7 @@ var RULE_ID18 = "require-nullable-result-in-root", rule27 = {
           for (let field of node.fields || []) {
             if (field.gqlType.type !== Kind20.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind20.NAMED_TYPE)
               continue;
-            let name = field.gqlType.gqlType.name.value, type = schema15.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+            let name2 = field.gqlType.gqlType.name.value, type = schema15.getType(name2), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
             context.report({
               node: field.gqlType,
               messageId: RULE_ID18,
@@ -4520,6 +4620,7 @@ var RULE_ID19 = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema12 = {
 }, rule28 = {
   meta: {
     type: "suggestion",
+    // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- false positive since we assign `problem.suggest` conditionally
     hasSuggestions: !0,
     docs: {
       category: "Operations",
@@ -4622,7 +4723,7 @@ Include it in your selection set{{ addition }}.`
       }
       function checkFields(rawType2) {
         let fields = rawType2.getFields();
-        if (!idNames.some((name) => fields[name]))
+        if (!idNames.some((name2) => fields[name2]))
           return;
         function hasIdField({ selections }) {
           return selections.some((selection) => {
@@ -4644,8 +4745,8 @@ Include it in your selection set{{ addition }}.`
         if (checkFragments(node), hasId)
           return;
         let pluralSuffix = idNames.length > 1 ? "s" : "", fieldName2 = englishJoinWords(
-          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
-        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`, problem = {
+          idNames.map((name2) => `\`${(parent.alias || parent.name).value}.${name2}\``)
+        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${englishJoinWords([...checkedFragmentSpreads].map((name2) => `\`${name2}\``))}`, problem = {
           loc,
           messageId: RULE_ID19,
           data: {
@@ -4825,7 +4926,7 @@ var RULE_ID21 = "selection-set-depth", schema13 = {
           checkFn({
             getDocument: () => document,
             reportError(error) {
-              let { line, column } = error.locations[0], token = context.getAncestors()[0].tokens.find(
+              let { line, column } = error.locations[0], token = context.sourceCode.getAncestors(node)[0].tokens.find(
                 (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
               );
               context.report({
@@ -5269,50 +5370,26 @@ var rules = {
 };
 
 // src/configs/index.ts
-var import_operations_all = __toESM(require_operations_all()), import_operations_recommended = __toESM(require_operations_recommended()), import_schema_all = __toESM(require_schema_all()), import_schema_recommended = __toESM(require_schema_recommended()), import_schema_relay = __toESM(require_schema_relay()), configs = {
+var import_operations_all = __toESM(require_operations_all(), 1), import_operations_recommended = __toESM(require_operations_recommended(), 1), import_schema_all = __toESM(require_schema_all(), 1), import_schema_recommended = __toESM(require_schema_recommended(), 1), import_schema_relay = __toESM(require_schema_relay(), 1), configs = {
   "schema-recommended": import_schema_recommended.default,
   "schema-all": import_schema_all.default,
   "schema-relay": import_schema_relay.default,
   "operations-recommended": import_operations_recommended.default,
-  "operations-all": import_operations_all.default
-};
-
-// src/flat-configs.ts
-var languageOptions = {
-  parser: { parseForESLint }
-}, flatConfigs = {
-  "operations-all": {
-    languageOptions,
-    rules: {
-      ...configs["operations-recommended"].rules,
-      ...configs["operations-all"].rules
-    }
-  },
-  "operations-recommended": {
-    languageOptions,
-    rules: configs["operations-recommended"].rules
+  "operations-all": import_operations_all.default,
+  "flat/schema-recommended": import_schema_recommended.default.rules,
+  "flat/schema-all": {
+    ...import_schema_recommended.default.rules,
+    ...import_schema_all.default.rules
   },
-  "schema-relay": {
-    languageOptions,
-    rules: configs["schema-relay"].rules
-  },
-  "schema-all": {
-    languageOptions,
-    rules: {
-      ...configs["schema-recommended"].rules,
-      ...configs["schema-all"].rules
-    }
-  },
-  "schema-recommended": {
-    languageOptions,
-    rules: configs["schema-recommended"].rules
+  "flat/schema-relay": import_schema_relay.default.rules,
+  "flat/operations-recommended": import_operations_recommended.default.rules,
+  "flat/operations-all": {
+    ...import_operations_recommended.default.rules,
+    ...import_operations_all.default.rules
   }
 };
 export {
   configs,
-  flatConfigs,
-  parseForESLint,
-  requireGraphQLSchemaFromContext,
-  requireSiblingsOperations,
+  parser,
   rules
 };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.3",
+  "type": "module",
   "description": "GraphQL plugin for ESLint",
   "repository": "https://github.com/B2o5T/graphql-eslint",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -12,21 +13,21 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "browser": "./index.browser.mjs",
       "require": {
         "types": "./cjs/index.d.ts",
         "default": "./cjs/index.js"
       },
       "import": {
-        "types": "./esm/index.d.mts",
+        "types": "./esm/index.d.ts",
         "default": "./esm/index.js"
       },
       "default": {
-        "types": "./esm/index.d.mts",
+        "types": "./esm/index.d.ts",
         "default": "./esm/index.js"
       }
     }
   },
+  "types": "esm/index.d.ts",
   "keywords": [
     "eslint",
     "eslintplugin",
@@ -39,11 +40,11 @@
   },
   "dependencies": {
     "@graphql-tools/code-file-loader": "^8.0.0",
-    "@graphql-tools/graphql-tag-pluck": "^8.0.0",
+    "@graphql-tools/graphql-tag-pluck": "8.3.2-alpha-20240803110708-298aeb8bb2ca4ef649bf09fc42f82fc88c6d5e13",
     "@graphql-tools/utils": "^10.0.0",
     "debug": "^4.3.4",
     "fast-glob": "^3.2.12",
-    "graphql-config": "^5.0.0",
+    "graphql-config": "^5.1.0",
     "graphql-depth-limit": "^1.1.0",
     "lodash.lowercase": "^4.3.0"
   },

package/cjs/configs/index.d.ts

@@ -1,174 +0,0 @@
-declare const configs: {
-    'schema-recommended': {
-        parser: string;
-        plugins: string[];
-        rules: {
-            '@graphql-eslint/description-style': string;
-            '@graphql-eslint/known-argument-names': string;
-            '@graphql-eslint/known-directives': string;
-            '@graphql-eslint/known-type-names': string;
-            '@graphql-eslint/lone-schema-definition': string;
-            '@graphql-eslint/naming-convention': (string | {
-                types: string;
-                FieldDefinition: string;
-                InputValueDefinition: string;
-                Argument: string;
-                DirectiveDefinition: string;
-                EnumValueDefinition: string;
-                'FieldDefinition[parent.name.value=Query]': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'FieldDefinition[parent.name.value=Mutation]': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'FieldDefinition[parent.name.value=Subscription]': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'EnumTypeDefinition,EnumTypeExtension': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'InterfaceTypeDefinition,InterfaceTypeExtension': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'UnionTypeDefinition,UnionTypeExtension': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                'ObjectTypeDefinition,ObjectTypeExtension': {
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-            })[];
-            '@graphql-eslint/no-hashtag-description': string;
-            '@graphql-eslint/no-typename-prefix': string;
-            '@graphql-eslint/no-unreachable-types': string;
-            '@graphql-eslint/possible-type-extension': string;
-            '@graphql-eslint/provided-required-arguments': string;
-            '@graphql-eslint/require-deprecation-reason': string;
-            '@graphql-eslint/require-description': (string | {
-                types: boolean;
-                DirectiveDefinition: boolean;
-                rootField: boolean;
-            })[];
-            '@graphql-eslint/strict-id-in-types': string;
-            '@graphql-eslint/unique-directive-names': string;
-            '@graphql-eslint/unique-directive-names-per-location': string;
-            '@graphql-eslint/unique-enum-value-names': string;
-            '@graphql-eslint/unique-field-definition-names': string;
-            '@graphql-eslint/unique-operation-types': string;
-            '@graphql-eslint/unique-type-names': string;
-        };
-    };
-    'schema-all': {
-        extends: string;
-        rules: {
-            '@graphql-eslint/alphabetize': (string | {
-                definitions: boolean;
-                fields: string[];
-                values: boolean;
-                arguments: string[];
-                groups: string[];
-            })[];
-            '@graphql-eslint/input-name': string;
-            '@graphql-eslint/no-root-type': (string | {
-                disallow: string[];
-            })[];
-            '@graphql-eslint/no-scalar-result-type-on-mutation': string;
-            '@graphql-eslint/require-deprecation-date': string;
-            '@graphql-eslint/require-field-of-type-query-in-mutation-result': string;
-            '@graphql-eslint/require-nullable-fields-with-oneof': string;
-            '@graphql-eslint/require-nullable-result-in-root': string;
-            '@graphql-eslint/require-type-pattern-with-oneof': string;
-        };
-    };
-    'schema-relay': {
-        parser: string;
-        plugins: string[];
-        rules: {
-            '@graphql-eslint/relay-arguments': string;
-            '@graphql-eslint/relay-connection-types': string;
-            '@graphql-eslint/relay-edge-types': string;
-            '@graphql-eslint/relay-page-info': string;
-        };
-    };
-    'operations-recommended': {
-        parser: string;
-        plugins: string[];
-        rules: {
-            '@graphql-eslint/executable-definitions': string;
-            '@graphql-eslint/fields-on-correct-type': string;
-            '@graphql-eslint/fragments-on-composite-type': string;
-            '@graphql-eslint/known-argument-names': string;
-            '@graphql-eslint/known-directives': string;
-            '@graphql-eslint/known-fragment-names': string;
-            '@graphql-eslint/known-type-names': string;
-            '@graphql-eslint/lone-anonymous-operation': string;
-            '@graphql-eslint/naming-convention': (string | {
-                VariableDefinition: string;
-                OperationDefinition: {
-                    style: string;
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-                FragmentDefinition: {
-                    style: string;
-                    forbiddenPrefixes: string[];
-                    forbiddenSuffixes: string[];
-                };
-            })[];
-            '@graphql-eslint/no-anonymous-operations': string;
-            '@graphql-eslint/no-deprecated': string;
-            '@graphql-eslint/no-duplicate-fields': string;
-            '@graphql-eslint/no-fragment-cycles': string;
-            '@graphql-eslint/no-undefined-variables': string;
-            '@graphql-eslint/no-unused-fragments': string;
-            '@graphql-eslint/no-unused-variables': string;
-            '@graphql-eslint/one-field-subscriptions': string;
-            '@graphql-eslint/overlapping-fields-can-be-merged': string;
-            '@graphql-eslint/possible-fragment-spread': string;
-            '@graphql-eslint/provided-required-arguments': string;
-            '@graphql-eslint/require-selections': string;
-            '@graphql-eslint/scalar-leafs': string;
-            '@graphql-eslint/selection-set-depth': (string | {
-                maxDepth: number;
-            })[];
-            '@graphql-eslint/unique-argument-names': string;
-            '@graphql-eslint/unique-directive-names-per-location': string;
-            '@graphql-eslint/unique-fragment-name': string;
-            '@graphql-eslint/unique-input-field-names': string;
-            '@graphql-eslint/unique-operation-name': string;
-            '@graphql-eslint/unique-variable-names': string;
-            '@graphql-eslint/value-literals-of-correct-type': string;
-            '@graphql-eslint/variables-are-input-types': string;
-            '@graphql-eslint/variables-in-allowed-position': string;
-        };
-    };
-    'operations-all': {
-        extends: string;
-        rules: {
-            '@graphql-eslint/alphabetize': (string | {
-                definitions: boolean;
-                selections: string[];
-                variables: boolean;
-                arguments: string[];
-                groups: string[];
-            })[];
-            '@graphql-eslint/lone-executable-definition': string;
-            '@graphql-eslint/match-document-filename': (string | {
-                query: string;
-                mutation: string;
-                subscription: string;
-                fragment: string;
-            })[];
-            '@graphql-eslint/no-one-place-fragments': string;
-            '@graphql-eslint/require-import-fragment': string;
-        };
-    };
-};
-
-export { configs };