@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230801163310-8bc4340

package/{configs/operations-recommended.json → cjs/configs/operations-recommended.js}

@@ -1,6 +1,8 @@
-{
-  "extends": "./base.json",
-  "rules": {
+"use strict";
+module.exports = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
     "@graphql-eslint/executable-definitions": "error",
     "@graphql-eslint/fields-on-correct-type": "error",
     "@graphql-eslint/fragments-on-composite-type": "error",
@@ -12,16 +14,16 @@
     "@graphql-eslint/naming-convention": [
       "error",
       {
-        "VariableDefinition": "camelCase",
-        "OperationDefinition": {
-          "style": "PascalCase",
-          "forbiddenPrefixes": ["Query", "Mutation", "Subscription", "Get"],
-          "forbiddenSuffixes": ["Query", "Mutation", "Subscription"]
+        VariableDefinition: "camelCase",
+        OperationDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
+          forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
         },
-        "FragmentDefinition": {
-          "style": "PascalCase",
-          "forbiddenPrefixes": ["Fragment"],
-          "forbiddenSuffixes": ["Fragment"]
+        FragmentDefinition: {
+          style: "PascalCase",
+          forbiddenPrefixes: ["Fragment"],
+          forbiddenSuffixes: ["Fragment"]
         }
       }
     ],
@@ -38,7 +40,7 @@
     "@graphql-eslint/provided-required-arguments": "error",
     "@graphql-eslint/require-id-when-available": "error",
     "@graphql-eslint/scalar-leafs": "error",
-    "@graphql-eslint/selection-set-depth": ["error", { "maxDepth": 7 }],
+    "@graphql-eslint/selection-set-depth": ["error", { maxDepth: 7 }],
     "@graphql-eslint/unique-argument-names": "error",
     "@graphql-eslint/unique-directive-names-per-location": "error",
     "@graphql-eslint/unique-input-field-names": "error",
@@ -47,4 +49,4 @@
     "@graphql-eslint/variables-are-input-types": "error",
     "@graphql-eslint/variables-in-allowed-position": "error"
   }
-}
+};

package/cjs/configs/relay.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    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;
+    };
+};
+
+export { _default as default };

package/{configs/relay.json → cjs/configs/relay.js}

@@ -1,9 +1,11 @@
-{
-  "extends": "./base.json",
-  "rules": {
+"use strict";
+module.exports = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
     "@graphql-eslint/relay-arguments": "error",
     "@graphql-eslint/relay-connection-types": "error",
     "@graphql-eslint/relay-edge-types": "error",
     "@graphql-eslint/relay-page-info": "error"
   }
-}
+};

package/cjs/configs/schema-all.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    extends: string;
+    rules: {
+        '@graphql-eslint/alphabetize': (string | {
+            fields: string[];
+            values: string[];
+            arguments: string[];
+        })[];
+        '@graphql-eslint/input-name': 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;
+    };
+};
+
+export { _default as default };

package/cjs/configs/schema-all.js

@@ -0,0 +1,21 @@
+"use strict";
+module.exports = {
+  extends: "./configs/schema-recommended",
+  rules: {
+    "@graphql-eslint/alphabetize": [
+      "error",
+      {
+        fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
+        values: ["EnumTypeDefinition"],
+        arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"]
+      }
+    ],
+    "@graphql-eslint/input-name": "error",
+    "@graphql-eslint/no-scalar-result-type-on-mutation": "error",
+    "@graphql-eslint/require-deprecation-date": "error",
+    "@graphql-eslint/require-field-of-type-query-in-mutation-result": "error",
+    "@graphql-eslint/require-nullable-fields-with-oneof": "error",
+    "@graphql-eslint/require-nullable-result-in-root": "error",
+    "@graphql-eslint/require-type-pattern-with-oneof": "error"
+  }
+};

package/cjs/configs/schema-recommended.d.ts

@@ -0,0 +1,49 @@
+declare const _default: {
+    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[];
+            };
+        })[];
+        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': string;
+        '@graphql-eslint/no-hashtag-description': string;
+        '@graphql-eslint/no-typename-prefix': string;
+        '@graphql-eslint/no-unreachable-types': string;
+        '@graphql-eslint/provided-required-arguments': string;
+        '@graphql-eslint/require-deprecation-reason': string;
+        '@graphql-eslint/require-description': (string | {
+            types: boolean;
+            DirectiveDefinition: 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-field-definition-names': string;
+        '@graphql-eslint/unique-operation-types': string;
+        '@graphql-eslint/unique-type-names': string;
+    };
+};
+
+export { _default as default };

package/{configs/schema-recommended.json → cjs/configs/schema-recommended.js}

@@ -1,6 +1,8 @@
-{
-  "extends": "./base.json",
-  "rules": {
+"use strict";
+module.exports = {
+  parser: "@graphql-eslint/eslint-plugin",
+  plugins: ["@graphql-eslint"],
+  rules: {
     "@graphql-eslint/description-style": "error",
     "@graphql-eslint/known-argument-names": "error",
     "@graphql-eslint/known-directives": "error",
@@ -9,23 +11,23 @@
     "@graphql-eslint/naming-convention": [
       "error",
       {
-        "types": "PascalCase",
-        "FieldDefinition": "camelCase",
-        "InputValueDefinition": "camelCase",
-        "Argument": "camelCase",
-        "DirectiveDefinition": "camelCase",
-        "EnumValueDefinition": "UPPER_CASE",
+        types: "PascalCase",
+        FieldDefinition: "camelCase",
+        InputValueDefinition: "camelCase",
+        Argument: "camelCase",
+        DirectiveDefinition: "camelCase",
+        EnumValueDefinition: "UPPER_CASE",
         "FieldDefinition[parent.name.value=Query]": {
-          "forbiddenPrefixes": ["query", "get"],
-          "forbiddenSuffixes": ["Query"]
+          forbiddenPrefixes: ["query", "get"],
+          forbiddenSuffixes: ["Query"]
         },
         "FieldDefinition[parent.name.value=Mutation]": {
-          "forbiddenPrefixes": ["mutation"],
-          "forbiddenSuffixes": ["Mutation"]
+          forbiddenPrefixes: ["mutation"],
+          forbiddenSuffixes: ["Mutation"]
         },
         "FieldDefinition[parent.name.value=Subscription]": {
-          "forbiddenPrefixes": ["subscription"],
-          "forbiddenSuffixes": ["Subscription"]
+          forbiddenPrefixes: ["subscription"],
+          forbiddenSuffixes: ["Subscription"]
         }
       }
     ],
@@ -35,10 +37,7 @@
     "@graphql-eslint/no-unreachable-types": "error",
     "@graphql-eslint/provided-required-arguments": "error",
     "@graphql-eslint/require-deprecation-reason": "error",
-    "@graphql-eslint/require-description": [
-      "error",
-      { "types": true, "DirectiveDefinition": true }
-    ],
+    "@graphql-eslint/require-description": ["error", { types: true, DirectiveDefinition: true }],
     "@graphql-eslint/strict-id-in-types": "error",
     "@graphql-eslint/unique-directive-names": "error",
     "@graphql-eslint/unique-directive-names-per-location": "error",
@@ -46,4 +45,4 @@
     "@graphql-eslint/unique-operation-types": "error",
     "@graphql-eslint/unique-type-names": "error"
   }
-}
+};

package/cjs/documents.d.ts

@@ -0,0 +1,6 @@
+import { Source } from '@graphql-tools/utils';
+import { GraphQLProjectConfig } from 'graphql-config';
+
+declare const getDocuments: (project: GraphQLProjectConfig) => Source[];
+
+export { getDocuments };

package/cjs/documents.js

@@ -0,0 +1,81 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var documents_exports = {};
+__export(documents_exports, {
+  getDocuments: () => getDocuments
+});
+module.exports = __toCommonJS(documents_exports);
+var import_path = require("path");
+var import_debug = __toESM(require("debug"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_cache = require("./cache.js");
+const debug = (0, import_debug.default)("graphql-eslint:operations");
+const operationsCache = new import_cache.ModuleCache();
+const handleVirtualPath = (documents) => {
+  const filepathMap = /* @__PURE__ */ Object.create(null);
+  return documents.map((source) => {
+    var _a;
+    const location = source.location;
+    if ([".gql", ".graphql"].some((extension) => location.endsWith(extension))) {
+      return source;
+    }
+    (_a = filepathMap[location]) != null ? _a : filepathMap[location] = -1;
+    const index = filepathMap[location] += 1;
+    return {
+      ...source,
+      location: (0, import_path.resolve)(location, `${index}_document.graphql`)
+    };
+  });
+};
+const getDocuments = (project) => {
+  const documentsKey = project.documents;
+  if (!documentsKey) {
+    return [];
+  }
+  let siblings = operationsCache.get(documentsKey);
+  if (!siblings) {
+    debug("Loading operations from %o", project.documents);
+    const documents = project.loadDocumentsSync(project.documents, {
+      skipGraphQLImport: true,
+      pluckConfig: project.extensions.pluckConfig
+    });
+    if (debug.enabled) {
+      debug("Loaded %d operations", documents.length);
+      const operationsPaths = import_fast_glob.default.sync(project.documents, { absolute: true });
+      debug("Operations pointers %O", operationsPaths);
+    }
+    siblings = handleVirtualPath(documents);
+    operationsCache.set(documentsKey, siblings);
+  }
+  return siblings;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDocuments
+});

package/cjs/estree-converter/converter.d.ts

@@ -0,0 +1,8 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import { GraphQLESTreeNode } from './types.js';
+import 'eslint';
+import 'estree';
+
+declare function convertToESTree<T extends DocumentNode>(node: T, schema?: GraphQLSchema | null): GraphQLESTreeNode<T>;
+
+export { convertToESTree };

package/cjs/estree-converter/converter.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var converter_exports = {};
+__export(converter_exports, {
+  convertToESTree: () => convertToESTree
+});
+module.exports = __toCommonJS(converter_exports);
+var import_graphql = require("graphql");
+var import_utils = require("./utils.js");
+function convertToESTree(node, schema) {
+  const typeInfo = schema && new import_graphql.TypeInfo(schema);
+  const visitor = {
+    leave(node2, key, parent) {
+      const leadingComments = "description" in node2 && node2.description ? [
+        {
+          type: node2.description.block ? "Block" : "Line",
+          value: node2.description.value
+        }
+      ] : [];
+      const calculatedTypeInfo = typeInfo ? {
+        argument: typeInfo.getArgument(),
+        defaultValue: typeInfo.getDefaultValue(),
+        directive: typeInfo.getDirective(),
+        enumValue: typeInfo.getEnumValue(),
+        fieldDef: typeInfo.getFieldDef(),
+        inputType: typeInfo.getInputType(),
+        parentInputType: typeInfo.getParentInputType(),
+        parentType: typeInfo.getParentType(),
+        gqlType: typeInfo.getType()
+      } : {};
+      const rawNode = () => {
+        if (parent && key !== void 0) {
+          return parent[key];
+        }
+        return node2.kind === import_graphql.Kind.DOCUMENT ? {
+          ...node2,
+          definitions: node2.definitions.map(
+            (definition) => definition.rawNode()
+          )
+        } : node2;
+      };
+      const commonFields = {
+        ...node2,
+        type: node2.kind,
+        loc: (0, import_utils.convertLocation)(node2.loc),
+        range: [node2.loc.start, node2.loc.end],
+        leadingComments,
+        // Use function to prevent RangeError: Maximum call stack size exceeded
+        typeInfo: () => calculatedTypeInfo,
+        // Don't know if can fix error
+        rawNode
+      };
+      return "type" in node2 ? {
+        ...commonFields,
+        gqlType: node2.type
+      } : commonFields;
+    }
+  };
+  return (0, import_graphql.visit)(
+    node,
+    typeInfo ? (0, import_graphql.visitWithTypeInfo)(typeInfo, visitor) : visitor
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToESTree
+});

package/cjs/estree-converter/index.d.ts

@@ -0,0 +1,8 @@
+export { convertToESTree } from './converter.js';
+export { GraphQLESTreeNode, TypeInformation } from './types.js';
+export { convertLocation, convertToken, extractComments, extractTokens, getBaseType, valueFromNode } from './utils.js';
+import 'graphql';
+import 'eslint';
+import 'estree';
+import 'graphql/jsutils/Maybe';
+import 'graphql/jsutils/ObjMap';

package/cjs/estree-converter/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var estree_converter_exports = {};
+module.exports = __toCommonJS(estree_converter_exports);
+__reExport(estree_converter_exports, require("./converter.js"), module.exports);
+__reExport(estree_converter_exports, require("./types.js"), module.exports);
+__reExport(estree_converter_exports, require("./utils.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./converter.js"),
+  ...require("./types.js"),
+  ...require("./utils.js")
+});

package/cjs/estree-converter/types.d.ts

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

package/cjs/estree-converter/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/cjs/estree-converter/utils.d.ts

@@ -0,0 +1,18 @@
+import * as graphql_jsutils_Maybe from 'graphql/jsutils/Maybe';
+import * as graphql_jsutils_ObjMap from 'graphql/jsutils/ObjMap';
+import * as graphql from 'graphql';
+import { GraphQLOutputType, GraphQLNamedType, Token, Location } from 'graphql';
+import { AST } from 'eslint';
+import { Comment, SourceLocation } from 'estree';
+
+declare const valueFromNode: (valueNode: graphql.ValueNode, variables?: graphql_jsutils_Maybe.Maybe<graphql_jsutils_ObjMap.ObjMap<unknown>>) => any;
+declare function getBaseType(type: GraphQLOutputType): GraphQLNamedType;
+type TokenKindValue = ':' | '!' | '...' | '(' | ')' | '[' | ']' | '{' | '}' | '@' | '&' | '<SOF>' | '=' | '|' | '$' | 'BlockString' | 'Comment' | 'Float' | 'Int' | 'Name' | 'String';
+declare function convertToken<T extends TokenKindValue | 'Block' | 'Line'>(token: Token, type: T): Omit<AST.Token, 'type'> & {
+    type: T;
+};
+declare function extractTokens(filePath: string, code: string): AST.Token[];
+declare function extractComments(loc?: Location): Comment[];
+declare function convertLocation(location: Location): SourceLocation;
+
+export { convertLocation, convertToken, extractComments, extractTokens, getBaseType, valueFromNode };